def __init__(self, sysname): self._sysname = sysname self.ready = Event() # exchange/queues/bindings self._exchanges = {} # names -> { subscriber, topictrie(queue name) } self._queues = {} # names -> gevent queue self._bindings_by_queue = defaultdict( list) # queue name -> [(ex, binding)] self._lock_declarables = coros.RLock( ) # exchanges, queues, bindings, routing method # consumers self._consumers = defaultdict( list) # queue name -> [ctag, channel._on_deliver] self._consumers_by_ctag = {} # ctag -> queue_name ?? self._ctag_pool = IDPool() # pool of consumer tags self._lock_consumers = coros.RLock( ) # lock for interacting with any consumer related attrs # deliveries self._unacked = {} # dtag -> (ctag, msg) self._lock_unacked = coros.RLock( ) # lock for interacting with unacked field self._gl_msgs = None self._gl_pool = Pool() self.gl_ioloop = None self.errors = []
def attach_transport(self, transport): """ Attaches a bound transport and indicates this channel is now open. """ self._transport = transport self._lock = coros.RLock() self._fsm.process(self.I_ATTACH)
def __init__(self): self.client = None self.running = False self.ready = event.Event() self._lock = coros.RLock() self.interceptors = {} # endpoint interceptors
def __init__(self, sock, address): sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self.sock = sock self.sockfile = sock.makefile() self.writelock = coros.RLock() self.address = address self.link_state = 'connected' # or disconnected
def __init__(self): self.deleted_keys = [] self.aborted_keys = [] self.exc = None # Protect exc, since some paths test it and then use it, which # can run afoul race conditions. self._exc_protect = coros.RLock()
def __init__(self, sock, address): sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) sock.read = sock.recv sock.write = sock.sendall self.sock = sock self.unpacker = msgpack.Unpacker(sock, encoding='utf-8') self.writelock = coros.RLock() self.address = address self.link_state = 'connected' # or disconnected self.recv_buf = deque()
def __init__(self): log.debug("In NodeB.__init__") self.ready = event.Event() self._lock = coros.RLock() self._pool = IDPool() self._bidir_pool = { } # maps inactive/active our numbers (from self._pool) to channels self._pool_map = { } # maps active pika channel numbers to our numbers (from self._pool) amqp.Node.__init__(self)
def __init__(self, host='127.0.0.1', port=4212, password='******', connect_timeout=5, result_timeout=5, out_port=8081): # Receive buffer self._recvbuffer = None # Output port self._out_port = out_port # VLC socket self._socket = None # Result timeout self._resulttimeout = result_timeout # Shutting down flag self._shuttingDown = gevent.event.Event() # Authentication done event self._auth = gevent.event.AsyncResult() # Request lock self._resultlock = coros.RLock() # Request result self._result = gevent.event.AsyncResult() # VLC version string self._vlcver = None # Saving password self._password = password # Logger logger = logging.getLogger('VlcClient_init') # Making connection try: self._socket = telnetlib.Telnet(host, port, connect_timeout) logger.debug("Successfully connected with VLC socket!") except Exception as e: raise VlcException( "Socket creation error! VLC is not running? ERROR: " + repr(e)) # Spawning recvData greenlet gevent.spawn(self._recvData) gevent.sleep() # Waiting for authentication event try: if self._auth.get(timeout=self._resulttimeout) == False: errmsg = "Authentication error" logger.error(errmsg) raise VlcException(errmsg) except gevent.Timeout: errmsg = "Authentication timeout" logger.error(errmsg) raise VlcException(errmsg)
class RPCRequestEndpointUnit(RequestEndpointUnit): def _send(self, msg, headers=None, **kwargs): log.info("MESSAGE SEND [S->D] RPC: %s" % str(msg)) try: res, res_headers = RequestEndpointUnit._send(self, msg, headers=headers, **kwargs) except exception.Timeout: self._sample_request(-1, 'Timeout', msg, headers, '', {}) raise # possibly sample before we do any raising self._sample_request(res_headers['status_code'], res_headers['error_message'], msg, headers, res, res_headers) # Check response header if res_headers["status_code"] != 200: log.debug("RPCRequestEndpointUnit received an error (%d): %s", res_headers['status_code'], res_headers['error_message']) self._raise_exception(res_headers["status_code"], res_headers["error_message"]) return res, res_headers def _sample_request(self, status, status_descr, msg, headers, response, response_headers): """ Performs sFlow sampling of a completed/errored RPC request (if configured to). Makes two calls: 1) get_sflow_manager (overridden at process level) 2) make sample dict (the kwargs to sflow_manager.transaction, may be overridden where appropriate) Then performs the transact call if the manager says to do so. """ if CFG.container.get('sflow', {}).get('enabled', False): sm = self._get_sflow_manager() if sm and sm.should_sample: app_name = self._get_sample_name() try: trans_kwargs = self._build_sample(app_name, status, status_descr, msg, headers, response, response_headers) sm.transaction(**trans_kwargs) except Exception: log.exception("Could not sample, ignoring") else: log.debug( "No SFlowManager or it told us not to sample this transaction" ) def _get_sample_name(self): """ Gets the app_name that should be used for the sample. Typically this would be a process id. """ # at the rpc level we really don't know, we're not a process. return "unknown-rpc-client" def _get_sflow_manager(self): """ Finds the sFlow manager that should be used. """ # at this level, we don't have any ref back to the container other than the singleton from pyon.container.cc import Container if Container.instance: return Container.instance.sflow_manager return None def _build_sample(self, name, status, status_descr, msg, headers, response, response_headers): """ Builds a transaction sample. Should return a dict in the form of kwargs to be passed to SFlowManager.transaction. """ # build args to pass to transaction extra_attrs = { 'conv-id': headers.get('conv-id', ''), 'service': response_headers.get('sender-service', '') } cur_time_ms = int(time.time() * 1000) time_taken = (cur_time_ms - int(headers.get( 'ts', cur_time_ms))) * 1000 # sflow wants microseconds! # build op name: typically sender-service.op, or falling back to sender.op op_first = response_headers.get( 'sender-service', response_headers.get('sender', headers.get('receiver', ''))) if "," in op_first: op_first = op_first.rsplit(',', 1)[-1] op = ".".join((op_first, headers.get('op', 'unknown'))) # status code map => ours to sFlow (defaults to 3 aka INTERNAL_ERROR) status = SFlowManager.status_map.get(status, 3) sample = { 'app_name': name, 'op': op, 'attrs': extra_attrs, 'status_descr': status_descr, 'status': str(status), 'req_bytes': len(str(msg)), 'resp_bytes': len(str(response)), 'uS': time_taken, 'initiator': headers.get('sender', ''), 'target': headers.get('receiver', '') } return sample conv_id_counter = 0 _lock = coros.RLock() # @TODO: is this safe? _conv_id_root = None def _build_conv_id(self): """ Builds a unique conversation id based on the container name. """ with RPCRequestEndpointUnit._lock: RPCRequestEndpointUnit.conv_id_counter += 1 if not RPCRequestEndpointUnit._conv_id_root: # set default to use uuid-4, similar to what we'd get out of the container id anyway RPCRequestEndpointUnit._conv_id_root = str(uuid.uuid4())[0:6] # try to get the real one from the container, but do it safely try: from pyon.container.cc import Container if Container.instance and Container.instance.id: RPCRequestEndpointUnit._conv_id_root = Container.instance.id except: pass return "%s-%d" % (RPCRequestEndpointUnit._conv_id_root, RPCRequestEndpointUnit.conv_id_counter) def _build_header(self, raw_msg): """ Build header override. This should set header values that are invariant or have nothing to do with the specific call being made (such as op). """ headers = RequestEndpointUnit._build_header(self, raw_msg) headers['protocol'] = 'rpc' headers[ 'conv-seq'] = 1 # @TODO will not work well with agree/status etc headers['conv-id'] = self._build_conv_id() headers['language'] = 'ion-r2' headers['encoding'] = 'msgpack' headers['format'] = raw_msg.__class__.__name__ # hmm headers['reply-by'] = 'todo' # clock sync is a problem return headers def _raise_exception(self, code, message): if str(code) in exception_map: raise exception_map[str(code)](message) else: log.debug("Raising ServerError") raise ServerError(message)