/usr/lib/python2.7/dist-packages/Ice/Instrumentation_ice.py is in python-zeroc-ice 3.7.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 | # -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
#
# Ice version 3.7.0
#
# <auto-generated>
#
# Generated from file `Instrumentation.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.EndpointF_ice
import Ice.ConnectionF_ice
import Ice.Current_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
# Start of module Ice.Instrumentation
_M_Ice.Instrumentation = Ice.openModule('Ice.Instrumentation')
__name__ = 'Ice.Instrumentation'
_M_Ice.Instrumentation.__doc__ = """
The Instrumentation local interfaces enable observing a number of
Ice core internal components (threads, connections, etc).
"""
if 'Observer' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.Observer = Ice.createTempClass()
class Observer(object):
"""
The object observer interface used by instrumented objects to
notify the observer of their existence.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.Observer:
raise RuntimeError('Ice.Instrumentation.Observer is an abstract class')
def attach(self):
"""
This method is called when the instrumented object is created
or when the observer is attached to an existing object.
"""
raise NotImplementedError("method 'attach' not implemented")
def detach(self):
"""
This method is called when the instrumented object is destroyed
and as a result the observer detached from the object.
"""
raise NotImplementedError("method 'detach' not implemented")
def failed(self, exceptionName):
"""
Notification of a failure.
Arguments:
exceptionName -- The name of the exception.
"""
raise NotImplementedError("method 'failed' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_Observer)
__repr__ = __str__
_M_Ice.Instrumentation._t_Observer = IcePy.defineValue('::Ice::Instrumentation::Observer', Observer, -1, (), False, True, None, ())
Observer._ice_type = _M_Ice.Instrumentation._t_Observer
_M_Ice.Instrumentation.Observer = Observer
del Observer
if 'ThreadState' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ThreadState = Ice.createTempClass()
class ThreadState(Ice.EnumBase):
"""
The thread state enumeration keeps track of the different possible
states of Ice threads.
Enumerators:
ThreadStateIdle -- The thread is idle.
ThreadStateInUseForIO -- The thread is in use performing reads or writes for Ice
connections. This state is only for threads from an Ice thread
pool.
ThreadStateInUseForUser -- The thread is calling user code (servant implementation, AMI
callbacks). This state is only for threads from an Ice thread
pool.
ThreadStateInUseForOther -- The thread is performing other internal activities (DNS
lookups, timer callbacks, etc).
"""
def __init__(self, _n, _v):
Ice.EnumBase.__init__(self, _n, _v)
def valueOf(self, _n):
if _n in self._enumerators:
return self._enumerators[_n]
return None
valueOf = classmethod(valueOf)
ThreadState.ThreadStateIdle = ThreadState("ThreadStateIdle", 0)
ThreadState.ThreadStateInUseForIO = ThreadState("ThreadStateInUseForIO", 1)
ThreadState.ThreadStateInUseForUser = ThreadState("ThreadStateInUseForUser", 2)
ThreadState.ThreadStateInUseForOther = ThreadState("ThreadStateInUseForOther", 3)
ThreadState._enumerators = { 0:ThreadState.ThreadStateIdle, 1:ThreadState.ThreadStateInUseForIO, 2:ThreadState.ThreadStateInUseForUser, 3:ThreadState.ThreadStateInUseForOther }
_M_Ice.Instrumentation._t_ThreadState = IcePy.defineEnum('::Ice::Instrumentation::ThreadState', ThreadState, (), ThreadState._enumerators)
_M_Ice.Instrumentation.ThreadState = ThreadState
del ThreadState
if 'ThreadObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ThreadObserver = Ice.createTempClass()
class ThreadObserver(_M_Ice.Instrumentation.Observer):
"""
The thread observer interface to instrument Ice threads. This can
be threads from the Ice thread pool or utility threads used by the
Ice core.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.ThreadObserver:
raise RuntimeError('Ice.Instrumentation.ThreadObserver is an abstract class')
def stateChanged(self, oldState, newState):
"""
Notification of thread state change.
Arguments:
oldState -- The previous thread state.
newState -- The new thread state.
"""
raise NotImplementedError("method 'stateChanged' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ThreadObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_ThreadObserver = IcePy.defineValue('::Ice::Instrumentation::ThreadObserver', ThreadObserver, -1, (), False, True, None, ())
ThreadObserver._ice_type = _M_Ice.Instrumentation._t_ThreadObserver
_M_Ice.Instrumentation.ThreadObserver = ThreadObserver
del ThreadObserver
if 'ConnectionState' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ConnectionState = Ice.createTempClass()
class ConnectionState(Ice.EnumBase):
"""
The state of an Ice connection.
Enumerators:
ConnectionStateValidating -- The connection is being validated.
ConnectionStateHolding -- The connection is holding the reception of new messages.
ConnectionStateActive -- The connection is active and can send and receive messages.
ConnectionStateClosing -- The connection is being gracefully shutdown and waits for the
peer to close its end of the connection.
ConnectionStateClosed -- The connection is closed and waits for potential dispatch to be
finished before being destroyed and detached from the observer.
"""
def __init__(self, _n, _v):
Ice.EnumBase.__init__(self, _n, _v)
def valueOf(self, _n):
if _n in self._enumerators:
return self._enumerators[_n]
return None
valueOf = classmethod(valueOf)
ConnectionState.ConnectionStateValidating = ConnectionState("ConnectionStateValidating", 0)
ConnectionState.ConnectionStateHolding = ConnectionState("ConnectionStateHolding", 1)
ConnectionState.ConnectionStateActive = ConnectionState("ConnectionStateActive", 2)
ConnectionState.ConnectionStateClosing = ConnectionState("ConnectionStateClosing", 3)
ConnectionState.ConnectionStateClosed = ConnectionState("ConnectionStateClosed", 4)
ConnectionState._enumerators = { 0:ConnectionState.ConnectionStateValidating, 1:ConnectionState.ConnectionStateHolding, 2:ConnectionState.ConnectionStateActive, 3:ConnectionState.ConnectionStateClosing, 4:ConnectionState.ConnectionStateClosed }
_M_Ice.Instrumentation._t_ConnectionState = IcePy.defineEnum('::Ice::Instrumentation::ConnectionState', ConnectionState, (), ConnectionState._enumerators)
_M_Ice.Instrumentation.ConnectionState = ConnectionState
del ConnectionState
if 'ConnectionObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ConnectionObserver = Ice.createTempClass()
class ConnectionObserver(_M_Ice.Instrumentation.Observer):
"""
The connection observer interface to instrument Ice connections.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.ConnectionObserver:
raise RuntimeError('Ice.Instrumentation.ConnectionObserver is an abstract class')
def sentBytes(self, num):
"""
Notification of sent bytes over the connection.
Arguments:
num -- The number of bytes sent.
"""
raise NotImplementedError("method 'sentBytes' not implemented")
def receivedBytes(self, num):
"""
Notification of received bytes over the connection.
Arguments:
num -- The number of bytes received.
"""
raise NotImplementedError("method 'receivedBytes' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ConnectionObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_ConnectionObserver = IcePy.defineValue('::Ice::Instrumentation::ConnectionObserver', ConnectionObserver, -1, (), False, True, None, ())
ConnectionObserver._ice_type = _M_Ice.Instrumentation._t_ConnectionObserver
_M_Ice.Instrumentation.ConnectionObserver = ConnectionObserver
del ConnectionObserver
if 'DispatchObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.DispatchObserver = Ice.createTempClass()
class DispatchObserver(_M_Ice.Instrumentation.Observer):
"""
The dispatch observer to instrument servant dispatch.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.DispatchObserver:
raise RuntimeError('Ice.Instrumentation.DispatchObserver is an abstract class')
def userException(self):
"""
Notification of a user exception.
"""
raise NotImplementedError("method 'userException' not implemented")
def reply(self, size):
"""
Reply notification.
Arguments:
size -- The size of the reply.
"""
raise NotImplementedError("method 'reply' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_DispatchObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_DispatchObserver = IcePy.defineValue('::Ice::Instrumentation::DispatchObserver', DispatchObserver, -1, (), False, True, None, ())
DispatchObserver._ice_type = _M_Ice.Instrumentation._t_DispatchObserver
_M_Ice.Instrumentation.DispatchObserver = DispatchObserver
del DispatchObserver
if 'ChildInvocationObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ChildInvocationObserver = Ice.createTempClass()
class ChildInvocationObserver(_M_Ice.Instrumentation.Observer):
"""
The child invocation observer to instrument remote or collocated
invocations.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.ChildInvocationObserver:
raise RuntimeError('Ice.Instrumentation.ChildInvocationObserver is an abstract class')
def reply(self, size):
"""
Reply notification.
Arguments:
size -- The size of the reply.
"""
raise NotImplementedError("method 'reply' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ChildInvocationObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_ChildInvocationObserver = IcePy.defineValue('::Ice::Instrumentation::ChildInvocationObserver', ChildInvocationObserver, -1, (), False, True, None, ())
ChildInvocationObserver._ice_type = _M_Ice.Instrumentation._t_ChildInvocationObserver
_M_Ice.Instrumentation.ChildInvocationObserver = ChildInvocationObserver
del ChildInvocationObserver
if 'RemoteObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.RemoteObserver = Ice.createTempClass()
class RemoteObserver(_M_Ice.Instrumentation.ChildInvocationObserver):
"""
The remote observer to instrument invocations that are sent over
the wire.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.RemoteObserver:
raise RuntimeError('Ice.Instrumentation.RemoteObserver is an abstract class')
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_RemoteObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_RemoteObserver = IcePy.defineValue('::Ice::Instrumentation::RemoteObserver', RemoteObserver, -1, (), False, True, None, ())
RemoteObserver._ice_type = _M_Ice.Instrumentation._t_RemoteObserver
_M_Ice.Instrumentation.RemoteObserver = RemoteObserver
del RemoteObserver
if 'CollocatedObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.CollocatedObserver = Ice.createTempClass()
class CollocatedObserver(_M_Ice.Instrumentation.ChildInvocationObserver):
"""
The collocated observer to instrument invocations that are
collocated.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.CollocatedObserver:
raise RuntimeError('Ice.Instrumentation.CollocatedObserver is an abstract class')
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_CollocatedObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_CollocatedObserver = IcePy.defineValue('::Ice::Instrumentation::CollocatedObserver', CollocatedObserver, -1, (), False, True, None, ())
CollocatedObserver._ice_type = _M_Ice.Instrumentation._t_CollocatedObserver
_M_Ice.Instrumentation.CollocatedObserver = CollocatedObserver
del CollocatedObserver
if 'InvocationObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.InvocationObserver = Ice.createTempClass()
class InvocationObserver(_M_Ice.Instrumentation.Observer):
"""
The invocation observer to instrument invocations on proxies. A
proxy invocation can either result in a collocated or remote
invocation. If it results in a remote invocation, a sub-observer is
requested for the remote invocation.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.InvocationObserver:
raise RuntimeError('Ice.Instrumentation.InvocationObserver is an abstract class')
def retried(self):
"""
Notification of the invocation being retried.
"""
raise NotImplementedError("method 'retried' not implemented")
def userException(self):
"""
Notification of a user exception.
"""
raise NotImplementedError("method 'userException' not implemented")
def getRemoteObserver(self, con, endpt, requestId, size):
"""
Get a remote observer for this invocation.
Arguments:
con -- The connection information.
endpt -- The connection endpoint.
requestId -- The ID of the invocation.
size -- The size of the invocation.
Returns: The observer to instrument the remote invocation.
"""
raise NotImplementedError("method 'getRemoteObserver' not implemented")
def getCollocatedObserver(self, adapter, requestId, size):
"""
Get a collocated observer for this invocation.
Arguments:
adapter -- The object adapter hosting the collocated Ice object.
requestId -- The ID of the invocation.
size -- The size of the invocation.
Returns: The observer to instrument the collocated invocation.
"""
raise NotImplementedError("method 'getCollocatedObserver' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_InvocationObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_InvocationObserver = IcePy.defineValue('::Ice::Instrumentation::InvocationObserver', InvocationObserver, -1, (), False, True, None, ())
InvocationObserver._ice_type = _M_Ice.Instrumentation._t_InvocationObserver
_M_Ice.Instrumentation.InvocationObserver = InvocationObserver
del InvocationObserver
if 'ObserverUpdater' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ObserverUpdater = Ice.createTempClass()
class ObserverUpdater(object):
"""
The observer updater interface. This interface is implemented by
the Ice run-time and an instance of this interface is provided by
the Ice communicator on initialization to the
CommunicatorObserver object set with the communicator
initialization data. The Ice communicator calls
CommunicatorObserver#setObserverUpdater to provide the observer
updater.
This interface can be used by add-ins implementing the
CommunicatorObserver interface to update the observers of
connections and threads.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.ObserverUpdater:
raise RuntimeError('Ice.Instrumentation.ObserverUpdater is an abstract class')
def updateConnectionObservers(self):
"""
Update connection observers associated with each of the Ice
connection from the communicator and its object adapters.
When called, this method goes through all the connections and
for each connection CommunicatorObserver#getConnectionObserver
is called. The implementation of getConnectionObserver has the
possibility to return an updated observer if necessary.
"""
raise NotImplementedError("method 'updateConnectionObservers' not implemented")
def updateThreadObservers(self):
"""
Update thread observers associated with each of the Ice thread
from the communicator and its object adapters.
When called, this method goes through all the threads and for
each thread CommunicatorObserver#getThreadObserver is
called. The implementation of getThreadObserver has the
possibility to return an updated observer if necessary.
"""
raise NotImplementedError("method 'updateThreadObservers' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ObserverUpdater)
__repr__ = __str__
_M_Ice.Instrumentation._t_ObserverUpdater = IcePy.defineValue('::Ice::Instrumentation::ObserverUpdater', ObserverUpdater, -1, (), False, True, None, ())
ObserverUpdater._ice_type = _M_Ice.Instrumentation._t_ObserverUpdater
_M_Ice.Instrumentation.ObserverUpdater = ObserverUpdater
del ObserverUpdater
if 'CommunicatorObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.CommunicatorObserver = Ice.createTempClass()
class CommunicatorObserver(object):
"""
The communicator observer interface used by the Ice run-time to
obtain and update observers for its observable objects. This
interface should be implemented by add-ins that wish to observe Ice
objects in order to collect statistics. An instance of this
interface can be provided to the Ice run-time through the Ice
communicator initialization data.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.CommunicatorObserver:
raise RuntimeError('Ice.Instrumentation.CommunicatorObserver is an abstract class')
def getConnectionEstablishmentObserver(self, endpt, connector):
"""
This method should return an observer for the given endpoint
information and connector. The Ice run-time calls this method
for each connection establishment attempt.
Arguments:
endpt -- The endpoint.
connector -- The description of the connector. For IP transports, this is typically the IP address to connect to.
Returns: The observer to instrument the connection establishment.
"""
raise NotImplementedError("method 'getConnectionEstablishmentObserver' not implemented")
def getEndpointLookupObserver(self, endpt):
"""
This method should return an observer for the given endpoint
information. The Ice run-time calls this method to resolve an
endpoint and obtain the list of connectors.
For IP endpoints, this typically involves doing a DNS lookup to
obtain the IP addresses associated with the DNS name.
Arguments:
endpt -- The endpoint.
Returns: The observer to instrument the endpoint lookup.
"""
raise NotImplementedError("method 'getEndpointLookupObserver' not implemented")
def getConnectionObserver(self, c, e, s, o):
"""
This method should return a connection observer for the given
connection. The Ice run-time calls this method for each new
connection and for all the Ice communicator connections when
ObserverUpdater#updateConnectionObservers is called.
Arguments:
c -- The connection information.
e -- The connection endpoint.
s -- The state of the connection.
o -- The old connection observer if one is already set or a null reference otherwise.
Returns: The connection observer to instrument the connection.
"""
raise NotImplementedError("method 'getConnectionObserver' not implemented")
def getThreadObserver(self, parent, id, s, o):
"""
This method should return a thread observer for the given
thread. The Ice run-time calls this method for each new thread
and for all the Ice communicator threads when
ObserverUpdater#updateThreadObservers is called.
Arguments:
parent -- The parent of the thread.
id -- The ID of the thread to observe.
s -- The state of the thread.
o -- The old thread observer if one is already set or a null reference otherwise.
Returns: The thread observer to instrument the thread.
"""
raise NotImplementedError("method 'getThreadObserver' not implemented")
def getInvocationObserver(self, prx, operation, ctx):
"""
This method should return an invocation observer for the given
invocation. The Ice run-time calls this method for each new
invocation on a proxy.
Arguments:
prx -- The proxy used for the invocation.
operation -- The name of the invocation.
ctx -- The context specified by the user.
Returns: The invocation observer to instrument the invocation.
"""
raise NotImplementedError("method 'getInvocationObserver' not implemented")
def getDispatchObserver(self, c, size):
"""
This method should return a dispatch observer for the given
dispatch. The Ice run-time calls this method each time it
receives an incoming invocation to be dispatched for an Ice
object.
Arguments:
c -- The current object as provided to the Ice servant dispatching the invocation.
size -- The size of the dispatch.
Returns: The dispatch observer to instrument the dispatch.
"""
raise NotImplementedError("method 'getDispatchObserver' not implemented")
def setObserverUpdater(self, updater):
"""
The Ice run-time calls this method when the communicator is
initialized. The add-in implementing this interface can use
this object to get the Ice run-time to re-obtain observers for
observed objects.
Arguments:
updater -- The observer updater object.
"""
raise NotImplementedError("method 'setObserverUpdater' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_CommunicatorObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_CommunicatorObserver = IcePy.defineValue('::Ice::Instrumentation::CommunicatorObserver', CommunicatorObserver, -1, (), False, True, None, ())
CommunicatorObserver._ice_type = _M_Ice.Instrumentation._t_CommunicatorObserver
_M_Ice.Instrumentation.CommunicatorObserver = CommunicatorObserver
del CommunicatorObserver
# End of module Ice.Instrumentation
__name__ = 'Ice'
# End of module Ice
|