/usr/lib/python3/dist-packages/Ice_Instrumentation_ice.py is in python3-zeroc-ice 3.5.1-5.2.
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 | # **********************************************************************
#
# Copyright (c) 2003-2013 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.5.1
#
# <auto-generated>
#
# Generated from file `Instrumentation.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
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.'''
pass
def detach(self):
'''This method is called when the instrumented object is destroyed
and as a result the observer detached from the object.'''
pass
def failed(self, exceptionName):
'''Notification of a failure.
Arguments:
exceptionName The name of the exception.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_Observer)
__repr__ = __str__
_M_Ice.Instrumentation._t_Observer = IcePy.defineClass('::Ice::Instrumentation::Observer', Observer, -1, (), True, False, 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.'''
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.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ThreadObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_ThreadObserver = IcePy.defineClass('::Ice::Instrumentation::ThreadObserver', ThreadObserver, -1, (), True, False, None, (_M_Ice.Instrumentation._t_Observer,), ())
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.'''
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.'''
pass
def receivedBytes(self, num):
'''Notification of received bytes over the connection.
Arguments:
num The number of bytes received.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ConnectionObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_ConnectionObserver = IcePy.defineClass('::Ice::Instrumentation::ConnectionObserver', ConnectionObserver, -1, (), True, False, None, (_M_Ice.Instrumentation._t_Observer,), ())
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.'''
pass
def reply(self, size):
'''Reply notification.
Arguments:
size The size of the reply.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_DispatchObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_DispatchObserver = IcePy.defineClass('::Ice::Instrumentation::DispatchObserver', DispatchObserver, -1, (), True, False, None, (_M_Ice.Instrumentation._t_Observer,), ())
DispatchObserver._ice_type = _M_Ice.Instrumentation._t_DispatchObserver
_M_Ice.Instrumentation.DispatchObserver = DispatchObserver
del DispatchObserver
if 'RemoteObserver' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.RemoteObserver = Ice.createTempClass()
class RemoteObserver(_M_Ice.Instrumentation.Observer):
'''The remote invocation observer to instrument invocations that go
over the wire.'''
def __init__(self):
if Ice.getType(self) == _M_Ice.Instrumentation.RemoteObserver:
raise RuntimeError('Ice.Instrumentation.RemoteObserver is an abstract class')
def reply(self, size):
'''Reply notification.
Arguments:
size The size of the reply.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_RemoteObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_RemoteObserver = IcePy.defineClass('::Ice::Instrumentation::RemoteObserver', RemoteObserver, -1, (), True, False, None, (_M_Ice.Instrumentation._t_Observer,), ())
RemoteObserver._ice_type = _M_Ice.Instrumentation._t_RemoteObserver
_M_Ice.Instrumentation.RemoteObserver = RemoteObserver
del RemoteObserver
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.'''
pass
def userException(self):
'''Notification of a user exception.'''
pass
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.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_InvocationObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_InvocationObserver = IcePy.defineClass('::Ice::Instrumentation::InvocationObserver', InvocationObserver, -1, (), True, False, None, (_M_Ice.Instrumentation._t_Observer,), ())
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.'''
pass
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.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_ObserverUpdater)
__repr__ = __str__
_M_Ice.Instrumentation._t_ObserverUpdater = IcePy.defineClass('::Ice::Instrumentation::ObserverUpdater', ObserverUpdater, -1, (), True, False, 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.'''
pass
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.'''
pass
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#updateConnections 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.'''
pass
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#updateThreads 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.'''
pass
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.'''
pass
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.'''
pass
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.'''
pass
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_CommunicatorObserver)
__repr__ = __str__
_M_Ice.Instrumentation._t_CommunicatorObserver = IcePy.defineClass('::Ice::Instrumentation::CommunicatorObserver', CommunicatorObserver, -1, (), True, False, 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
|