idx int64 0 63k | question stringlengths 53 5.28k | target stringlengths 5 805 |
|---|---|---|
36,600 | def incoming_connections ( self ) : return list ( takewhile ( lambda c : c . direction == INCOMING , self . connections ) ) | Returns a list of all incoming connections for this peer . |
36,601 | def _get_peer_connection ( self , blacklist = None ) : blacklist = blacklist or set ( ) peer = None connection = None while connection is None : peer = self . _choose ( blacklist ) if not peer : raise NoAvailablePeerError ( "Can't find an available peer for '%s'" % self . service ) try : connection = yield peer . connect ( ) except NetworkError as e : log . info ( 'Failed to connect to %s. Trying a different host.' , peer . hostport , exc_info = e , ) connection = None blacklist . add ( peer . hostport ) raise gen . Return ( ( peer , connection ) ) | Find a peer and connect to it . |
36,602 | def send ( self , arg1 , arg2 , arg3 , headers = None , retry_limit = None , ttl = None , ) : peer , connection = yield self . _get_peer_connection ( ) arg1 , arg2 , arg3 = ( maybe_stream ( arg1 ) , maybe_stream ( arg2 ) , maybe_stream ( arg3 ) ) if retry_limit is None : retry_limit = DEFAULT_RETRY_LIMIT ttl = ttl or DEFAULT_TIMEOUT arg1 . close ( ) endpoint = yield read_full ( arg1 ) headers = headers or { } for k , v in self . headers . iteritems ( ) : headers . setdefault ( k , v ) if self . tracing_span is None : tracer = ClientTracer ( channel = self . tchannel ) self . tracing_span , _ = tracer . start_span ( service = self . service , endpoint = endpoint , hostport = self . _hostport , encoding = self . headers . get ( 'as' ) ) request = Request ( service = self . service , argstreams = [ InMemStream ( endpoint ) , arg2 , arg3 ] , id = connection . writer . next_message_id ( ) , headers = headers , endpoint = endpoint , ttl = ttl , tracing = tracing . span_to_tracing_field ( self . tracing_span ) ) if request . is_streaming_request or self . _hostport : retry_limit = 0 if request . is_streaming_request : request . ttl = 0 try : with self . tracing_span : response = yield self . send_with_retry ( request , peer , retry_limit , connection ) except Exception as e : exc_info = sys . exc_info ( ) yield self . tchannel . event_emitter . fire ( EventType . on_exception , request , e , ) six . reraise ( * exc_info ) log . debug ( "Got response %s" , response ) raise gen . Return ( response ) | Make a request to the Peer . |
36,603 | def clear ( self ) : try : for peer in self . _peers . values ( ) : peer . close ( ) finally : self . _peers = { } self . _resetting = False | Reset this PeerGroup . |
36,604 | def remove ( self , hostport ) : assert hostport , "hostport is required" peer = self . _peers . pop ( hostport , None ) peer_in_heap = peer and peer . index != - 1 if peer_in_heap : self . peer_heap . remove_peer ( peer ) return peer | Delete the Peer for the given host port . |
36,605 | def get ( self , hostport ) : assert hostport , "hostport is required" assert isinstance ( hostport , basestring ) , "hostport must be a string" if hostport not in self . _peers : self . _add ( hostport ) return self . _peers [ hostport ] | Get a Peer for the given destination . |
36,606 | def _add ( self , hostport ) : peer = self . peer_class ( tchannel = self . tchannel , hostport = hostport , on_conn_change = self . _update_heap , ) peer . rank = self . rank_calculator . get_rank ( peer ) self . _peers [ peer . hostport ] = peer self . peer_heap . add_and_shuffle ( peer ) | Creates a peer from the hostport and adds it to the peer heap |
36,607 | def _update_heap ( self , peer ) : rank = self . rank_calculator . get_rank ( peer ) if rank == peer . rank : return peer . rank = rank self . peer_heap . update_peer ( peer ) | Recalculate the peer s rank and update itself in the peer heap . |
36,608 | def _get_isolated ( self , hostport ) : assert hostport , "hostport is required" if hostport not in self . _peers : peer = self . peer_class ( tchannel = self . tchannel , hostport = hostport , ) self . _peers [ peer . hostport ] = peer return self . _peers [ hostport ] | Get a Peer for the given destination for a request . |
36,609 | def request ( self , service , hostport = None , ** kwargs ) : return PeerClientOperation ( peer_group = self , service = service , hostport = hostport , ** kwargs ) | Initiate a new request through this PeerGroup . |
36,610 | def choose ( self , hostport = None , blacklist = None ) : blacklist = blacklist or set ( ) if hostport : return self . _get_isolated ( hostport ) return self . peer_heap . smallest_peer ( ( lambda p : p . hostport not in blacklist and not p . is_ephemeral ) , ) | Choose a Peer that matches the given criteria . |
36,611 | def fail_to ( future ) : assert is_future ( future ) , 'you forgot to pass a future' def decorator ( f ) : @ wraps ( f ) def new_f ( * args , ** kwargs ) : try : return f ( * args , ** kwargs ) except Exception : future . set_exc_info ( sys . exc_info ( ) ) return new_f return decorator | A decorator for function callbacks to catch uncaught non - async exceptions and forward them to the given future . |
36,612 | def get_arg ( context , index ) : if index < len ( context . argstreams ) : arg = "" chunk = yield context . argstreams [ index ] . read ( ) while chunk : arg += chunk chunk = yield context . argstreams [ index ] . read ( ) raise tornado . gen . Return ( arg ) else : raise TChannelError ( ) | get value from arg stream in async way |
36,613 | def put ( self , value ) : io_loop = IOLoop . current ( ) new_hole = Future ( ) new_put = Future ( ) new_put . set_result ( new_hole ) with self . _lock : self . _put , put = new_put , self . _put answer = Future ( ) def _on_put ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) old_hole = put . result ( ) old_hole . set_result ( Node ( value , new_hole ) ) answer . set_result ( None ) io_loop . add_future ( put , _on_put ) return answer | Puts an item into the queue . |
36,614 | def get_nowait ( self ) : new_get = Future ( ) with self . _lock : if not self . _get . done ( ) : raise QueueEmpty get , self . _get = self . _get , new_get hole = get . result ( ) if not hole . done ( ) : new_get . set_result ( hole ) raise QueueEmpty node = hole . result ( ) value = node . value new_hole , node . next = node . next , None new_get . set_result ( new_hole ) return value | Returns a value from the queue without waiting . |
36,615 | def get ( self ) : io_loop = IOLoop . current ( ) new_get = Future ( ) with self . _lock : get , self . _get = self . _get , new_get answer = Future ( ) def _on_node ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) node = future . result ( ) value = node . value new_hole , node . next = node . next , None new_get . set_result ( new_hole ) answer . set_result ( value ) def _on_get ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) hole = future . result ( ) io_loop . add_future ( hole , _on_node ) io_loop . add_future ( get , _on_get ) return answer | Gets the next item from the queue . |
36,616 | def fragment ( self , space_left , fragment_msg ) : new_args = [ ] key_length = 2 for i , arg in enumerate ( self . args ) : if space_left >= key_length : space_left -= key_length if arg is not None : arg_length = len ( arg ) if space_left < arg_length : fragment_msg . args . append ( arg [ space_left : ] ) new_args . append ( arg [ : space_left ] ) space_left = 0 else : new_args . append ( arg ) space_left -= arg_length if space_left <= key_length : fragment_msg . args . append ( "" ) else : new_args . append ( "" ) else : for l in range ( i , len ( self . args ) ) : fragment_msg . args . append ( self . args [ l ] ) break self . args = new_args if space_left >= 0 and len ( fragment_msg . args ) == 0 : return None else : self . flags = FlagsType . fragment fragment_msg . id = self . id return fragment_msg | Streaming Message got fragmented based on payload size . All the data within space_left will be kept . All the rest will be shifted to next fragment message . |
36,617 | def response_from_mixed ( mixed ) : if mixed is None : return Response ( ) if not isinstance ( mixed , Response ) : return Response ( mixed ) return mixed | Create Response from mixed input . |
36,618 | def register_hook ( self , hook , event_type = None ) : if event_type is not None : assert type ( event_type ) is int , "register hooks with int values" return self . hooks [ event_type ] . append ( hook ) for event_type in EventType . _fields : func = getattr ( hook , event_type , None ) if callable ( func ) : event_value = getattr ( EventType , event_type ) self . register_hook ( func , event_value ) | If event_type is provided then hook will be called whenever that event is fired . |
36,619 | def init ( h ) : n = h . size ( ) for i in six . moves . range ( int ( math . floor ( n / 2 ) ) - 1 , - 1 , - 1 ) : down ( h , i , n ) | Initialize existing object into the heap . |
36,620 | def push ( h , x ) : h . push ( x ) up ( h , h . size ( ) - 1 ) | Push a new value into heap . |
36,621 | def pop ( h ) : n = h . size ( ) - 1 h . swap ( 0 , n ) down ( h , 0 , n ) return h . pop ( ) | Pop the heap value from the heap . |
36,622 | def remove ( h , i ) : n = h . size ( ) - 1 if n != i : h . swap ( i , n ) down ( h , i , n ) up ( h , i ) return h . pop ( ) | Remove the item at position i of the heap . |
36,623 | def fix ( h , i ) : down ( h , i , h . size ( ) ) up ( h , i ) | Rearrange the heap after the item at position i got updated . |
36,624 | def smallest ( heap , predicate ) : n = heap . size ( ) items = deque ( [ 0 ] ) while items : current = items . popleft ( ) if current >= n : continue if predicate ( heap . peek ( current ) ) : return current child1 = 2 * current + 1 child2 = child1 + 1 if child1 < n and child2 < n and heap . lt ( child2 , child1 ) : child1 , child2 = child2 , child1 if child1 < n : items . append ( child1 ) if child2 < n : items . append ( child2 ) raise NoMatchError ( ) | Finds the index of the smallest item in the heap that matches the given predicate . |
36,625 | def start_basic_span ( self , request ) : try : if request . tracing . trace_id : context = self . tracer . extract ( format = ZIPKIN_SPAN_FORMAT , carrier = request . tracing ) self . span = self . tracer . start_span ( operation_name = request . endpoint , child_of = context , tags = { tags . SPAN_KIND : tags . SPAN_KIND_RPC_SERVER } , ) except opentracing . UnsupportedFormatException : pass except : log . exception ( 'Cannot extract tracing span from Trace field' ) | Start tracing span from the protocol s tracing fields . This will only work if the tracer supports Zipkin - style span context . |
36,626 | def start_span ( self , request , headers , peer_host , peer_port ) : parent_context = None try : if headers and hasattr ( headers , 'iteritems' ) : tracing_headers = { k [ len ( TRACING_KEY_PREFIX ) : ] : v for k , v in headers . iteritems ( ) if k . startswith ( TRACING_KEY_PREFIX ) } parent_context = self . tracer . extract ( format = opentracing . Format . TEXT_MAP , carrier = tracing_headers ) if self . span and parent_context : for k , v in parent_context . baggage . iteritems ( ) : self . span . set_baggage_item ( k , v ) except : log . exception ( 'Cannot extract tracing span from headers' ) if self . span is None : self . span = self . tracer . start_span ( operation_name = request . endpoint , child_of = parent_context , tags = { tags . SPAN_KIND : tags . SPAN_KIND_RPC_SERVER } , ) if 'cn' in request . headers : self . span . set_tag ( tags . PEER_SERVICE , request . headers [ 'cn' ] ) if peer_host : self . span . set_tag ( tags . PEER_HOST_IPV4 , peer_host ) if peer_port : self . span . set_tag ( tags . PEER_PORT , peer_port ) if 'as' in request . headers : self . span . set_tag ( 'as' , request . headers [ 'as' ] ) return self . span | Start a new server - side span . If the span has already been started by start_basic_span this method only adds baggage from the headers . |
36,627 | def from_code ( cls , code , ** kw ) : return { TIMEOUT : TimeoutError , CANCELED : CanceledError , BUSY : BusyError , DECLINED : DeclinedError , UNEXPECTED_ERROR : UnexpectedError , BAD_REQUEST : BadRequestError , NETWORK_ERROR : NetworkError , UNHEALTHY : UnhealthyError , FATAL : FatalProtocolError , } [ code ] ( ** kw ) | Construct a TChannelError instance from an error code . |
36,628 | def register ( dispatcher , service_module , handler , method = None , service = None ) : if not service : service = service_module . __name__ . rsplit ( '.' , 1 ) [ - 1 ] if not method : method = handler . __name__ assert service , 'A service name could not be determined' assert method , 'A method name could not be determined' assert hasattr ( service_module . Iface , method ) , ( "Service %s doesn't define method %s" % ( service , method ) ) assert hasattr ( service_module , method + '_result' ) , ( "oneway methods are not yet supported" ) endpoint = '%s::%s' % ( service , method ) args_type = getattr ( service_module , method + '_args' ) result_type = getattr ( service_module , method + '_result' ) if dispatcher . _handler_returns_response : new_handler = build_handler ( result_type , handler ) else : new_handler = deprecated_build_handler ( result_type , handler ) dispatcher . register ( endpoint , new_handler , ThriftSerializer ( args_type ) , ThriftSerializer ( result_type ) ) return handler | Registers a Thrift service method with the given RequestDispatcher . |
36,629 | def write_result ( self , result ) : assert not self . finished , "Already sent a response" if not self . result . thrift_spec : self . finished = True return spec = self . result . thrift_spec [ 0 ] if result is not None : assert spec , "Tried to return a result for a void method." setattr ( self . result , spec [ 2 ] , result ) self . finished = True | Send back the result of this call . |
36,630 | def write_exc_info ( self , exc_info = None ) : exc_info = exc_info or sys . exc_info ( ) exc = exc_info [ 1 ] self . code = StatusCode . error for spec in self . result . thrift_spec [ 1 : ] : if spec and isinstance ( exc , spec [ 3 ] [ 0 ] ) : assert not self . finished , "Already sent a response" setattr ( self . result , spec [ 2 ] , exc ) self . finished = True return raise exc_info [ 0 ] , exc_info [ 1 ] , exc_info [ 2 ] | Write exception information to the response . |
36,631 | def call ( self , scheme , service , arg1 , arg2 = None , arg3 = None , timeout = None , retry_on = None , retry_limit = None , routing_delegate = None , hostport = None , shard_key = None , tracing_span = None , trace = None , caller_name = None , ) : assert format , "format is required" assert service , "service is required" assert arg1 , "arg1 is required" if arg2 is None : arg2 = "" if arg3 is None : arg3 = "" if timeout is None : timeout = DEFAULT_TIMEOUT if retry_on is None : retry_on = retry . DEFAULT if retry_limit is None : retry_limit = retry . DEFAULT_RETRY_LIMIT tracing . apply_trace_flag ( tracing_span , trace , self . _dep_tchannel . trace ) operation = self . _dep_tchannel . request ( service = service , hostport = hostport , arg_scheme = scheme , retry = retry_on , tracing_span = tracing_span ) transport_headers = { transport . SCHEME : scheme , transport . CALLER_NAME : caller_name or self . name , } if shard_key : transport_headers [ transport . SHARD_KEY ] = shard_key if routing_delegate : transport_headers [ transport . ROUTING_DELEGATE ] = routing_delegate response = yield operation . send ( arg1 = arg1 , arg2 = arg2 , arg3 = arg3 , headers = transport_headers , retry_limit = retry_limit , ttl = timeout , ) body = yield response . get_body ( ) headers = yield response . get_header ( ) t = TransportHeaders . from_dict ( response . headers ) result = Response ( body = body , headers = headers , transport = t , status = response . code , ) raise gen . Return ( result ) | Make low - level requests to TChannel services . |
36,632 | def thrift_request_builder ( service , thrift_module , hostport = None , thrift_class_name = None ) : maker = ThriftRequestMaker ( service = service , thrift_module = thrift_module , hostport = hostport , thrift_class_name = thrift_class_name ) methods = _create_methods ( thrift_module ) for name , method in methods . iteritems ( ) : method = types . MethodType ( method , maker , ThriftRequestMaker ) setattr ( maker , name , method ) return maker | Provide TChannel compatibility with Thrift - generated modules . |
36,633 | def read_body ( self , body ) : result_spec = self . result_type . thrift_spec for exc_spec in result_spec [ 1 : ] : exc = getattr ( body , exc_spec [ 2 ] ) if exc is not None : raise exc if len ( result_spec ) >= 1 and result_spec [ 0 ] is not None : if body . success is None : raise ValueExpectedError ( 'Expected a value to be returned for %s, ' 'but recieved None - only void procedures can ' 'return None.' % self . endpoint ) return body . success else : return None | Handles the response body for this request . |
36,634 | def get_rank ( self , peer ) : if not peer . connections : return self . TIERS [ 0 ] if not peer . has_incoming_connections : return self . TIERS [ 1 ] + peer . total_outbound_pendings return self . TIERS [ 2 ] + peer . total_outbound_pendings | Calculate the peer rank based on connections . |
36,635 | def prepare ( cls , * args , ** kwargs ) : cls . args = args cls . kwargs = kwargs cls . prepared = True | Set arguments to be used when instantiating a TChannel instance . |
36,636 | def reset ( cls , * args , ** kwargs ) : cls . local . tchannel = None cls . args = None cls . kwargs = None cls . prepared = False | Undo call to prepare useful for testing . |
36,637 | def get_instance ( cls ) : if not cls . prepared : raise SingletonNotPreparedError ( "prepare must be called before get_instance" ) if hasattr ( cls . local , 'tchannel' ) and cls . local . tchannel is not None : return cls . local . tchannel cls . local . tchannel = cls . tchannel_cls ( * cls . args , ** cls . kwargs ) return cls . local . tchannel | Get a configured thread - safe singleton TChannel instance . |
36,638 | def handle_pre_call ( self , message , connection ) : req = None try : req = connection . request_message_factory . build ( message ) if req : self . handle_call ( req , connection ) except TChannelError as e : log . warn ( 'Received a bad request.' , exc_info = True ) if req : e . tracing = req . tracing connection . send_error ( e ) | Handle incoming request message including CallRequestMessage and CallRequestContinueMessage |
36,639 | def register ( self , rule , handler , req_serializer = None , resp_serializer = None ) : assert handler , "handler must not be None" req_serializer = req_serializer or RawSerializer ( ) resp_serializer = resp_serializer or RawSerializer ( ) self . handlers [ rule ] = Handler ( handler , req_serializer , resp_serializer ) | Register a new endpoint with the given name . |
36,640 | def generate_checksum ( message , previous_csum = 0 ) : if message . message_type in CHECKSUM_MSG_TYPES : csum = compute_checksum ( message . checksum [ 0 ] , message . args , previous_csum , ) message . checksum = ( message . checksum [ 0 ] , csum ) | Generate checksum for messages with CALL_REQ CALL_REQ_CONTINUE CALL_RES CALL_RES_CONTINUE types . |
36,641 | def verify_checksum ( message , previous_csum = 0 ) : if message . message_type in CHECKSUM_MSG_TYPES : csum = compute_checksum ( message . checksum [ 0 ] , message . args , previous_csum , ) if csum == message . checksum [ 1 ] : return True else : return False else : return True | Verify checksum for incoming message . |
36,642 | def start ( self ) : if self . running : raise Exception ( 'Advertiser is already running' ) if self . io_loop is None : self . io_loop = tornado . ioloop . IOLoop . current ( ) self . running = True answer = tornado . gen . Future ( ) self . _schedule_ad ( 0 , answer ) return answer | Starts the advertise loop . |
36,643 | def _schedule_ad ( self , delay = None , response_future = None ) : if not self . running : return if delay is None : delay = self . interval_secs delay += random . uniform ( 0 , self . interval_max_jitter_secs ) self . _next_ad = self . io_loop . call_later ( delay , self . _ad , response_future ) | Schedules an ad request . |
36,644 | def add ( self , id , ttl_secs ) : ttl_secs = min ( ttl_secs + self . ttl_offset_secs , self . max_ttl_secs ) self . _tombstones [ id ] = IOLoop . current ( ) . call_later ( ttl_secs , self . forget , id , ) | Adds a new request to the Cemetery that is known to have timed out . |
36,645 | def clear ( self ) : io_loop = IOLoop . current ( ) while self . _tombstones : _ , req_timeout = self . _tombstones . popitem ( ) io_loop . remove_timeout ( req_timeout ) | Forget about all requests . |
36,646 | def get_header ( self ) : raw_header = yield get_arg ( self , 1 ) if not self . serializer : raise tornado . gen . Return ( raw_header ) else : header = self . serializer . deserialize_header ( raw_header ) raise tornado . gen . Return ( header ) | Get the header value from the response . |
36,647 | def get_body ( self ) : raw_body = yield get_arg ( self , 2 ) if not self . serializer : raise tornado . gen . Return ( raw_body ) else : body = self . serializer . deserialize_body ( raw_body ) raise tornado . gen . Return ( body ) | Get the body value from the response . |
36,648 | def set_body_s ( self , stream ) : if self . argstreams [ 2 ] . state == StreamState . init : self . argstreams [ 2 ] = stream else : raise TChannelError ( "Unable to change the body since the streaming has started" ) | Set customized body stream . |
36,649 | def set_header_s ( self , stream ) : if self . argstreams [ 1 ] . state == StreamState . init : self . argstreams [ 1 ] = stream else : raise TChannelError ( "Unable to change the header since the streaming has started" ) | Set customized header stream . |
36,650 | def read_message ( stream ) : answer = tornado . gen . Future ( ) io_loop = IOLoop . current ( ) def on_error ( future ) : log . info ( 'Failed to read data: %s' , future . exception ( ) ) return answer . set_exc_info ( future . exc_info ( ) ) @ fail_to ( answer ) def on_body ( size , future ) : if future . exception ( ) : return on_error ( future ) body = future . result ( ) f = frame . frame_rw . read ( BytesIO ( body ) , size = size ) message_type = f . header . message_type message_rw = messages . RW . get ( message_type ) if not message_rw : exc = errors . FatalProtocolError ( 'Unknown message type %s' , str ( message_type ) ) return answer . set_exception ( exc ) message = message_rw . read ( BytesIO ( f . payload ) ) message . id = f . header . message_id answer . set_result ( message ) @ fail_to ( answer ) def on_read_size ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) size_bytes = future . result ( ) size = frame . frame_rw . size_rw . read ( BytesIO ( size_bytes ) ) io_loop . add_future ( stream . read_bytes ( size - FRAME_SIZE_WIDTH ) , lambda f : on_body ( size , f ) ) try : read_size_future = stream . read_bytes ( FRAME_SIZE_WIDTH ) except Exception : answer . set_exc_info ( sys . exc_info ( ) ) else : read_size_future . add_done_callback ( on_read_size ) return answer | Reads a message from the given IOStream . |
36,651 | def set_close_callback ( self , cb ) : assert self . _close_cb is None , ( 'A close_callback has already been set for this connection.' ) self . _close_cb = stack_context . wrap ( cb ) if self . closed : self . _close_cb ( ) | Specify a function to be called when this connection is closed . |
36,652 | def send ( self , message ) : assert self . _handshake_performed , "Perform a handshake first." assert message . message_type in self . CALL_REQ_TYPES , ( "Message '%s' can't use send" % repr ( message ) ) message . id = message . id or self . writer . next_message_id ( ) assert message . id not in self . _outbound_pending_call , ( "Message ID '%d' already being used" % message . id ) future = tornado . gen . Future ( ) self . _outbound_pending_call [ message . id ] = future self . write ( message ) return future | Send the given message up the wire . Use this for messages which have a response message . |
36,653 | def write ( self , message ) : message . id = message . id or self . writer . next_message_id ( ) if message . message_type in self . CALL_REQ_TYPES : message_factory = self . request_message_factory else : message_factory = self . response_message_factory fragments = message_factory . fragment ( message ) return self . _write_fragments ( fragments ) | Writes the given message up the wire . |
36,654 | def initiate_handshake ( self , headers , timeout = None ) : io_loop = IOLoop . current ( ) timeout = timeout or DEFAULT_INIT_TIMEOUT_SECS self . writer . put ( messages . InitRequestMessage ( version = PROTOCOL_VERSION , headers = headers ) ) init_res_future = self . reader . get ( ) timeout_handle = io_loop . call_later ( timeout , ( lambda : init_res_future . set_exception ( errors . TimeoutError ( 'Handshake with %s:%d timed out. Did not receive an INIT_RES ' 'after %s seconds' % ( self . remote_host , self . remote_host_port , str ( timeout ) ) ) ) ) ) io_loop . add_future ( init_res_future , ( lambda _ : io_loop . remove_timeout ( timeout_handle ) ) , ) init_res = yield init_res_future if init_res . message_type != Types . INIT_RES : raise errors . UnexpectedError ( "Expected handshake response, got %s" % repr ( init_res ) ) self . _extract_handshake_headers ( init_res ) self . _handshake_performed = True self . _loop ( ) raise tornado . gen . Return ( init_res ) | Initiate a handshake with the remote host . |
36,655 | def expect_handshake ( self , headers ) : init_req = yield self . reader . get ( ) if init_req . message_type != Types . INIT_REQ : raise errors . UnexpectedError ( "You need to shake my hand first. Got %s" % repr ( init_req ) ) self . _extract_handshake_headers ( init_req ) self . _handshake_performed = True self . writer . put ( messages . InitResponseMessage ( PROTOCOL_VERSION , headers , init_req . id ) , ) self . _loop ( ) raise tornado . gen . Return ( init_req ) | Expect a handshake from the remote host . |
36,656 | def outgoing ( cls , hostport , process_name = None , serve_hostport = None , handler = None , tchannel = None ) : host , port = hostport . rsplit ( ":" , 1 ) process_name = process_name or "%s[%s]" % ( sys . argv [ 0 ] , os . getpid ( ) ) serve_hostport = serve_hostport or "0.0.0.0:0" stream = tornado . iostream . IOStream ( socket . socket ( socket . AF_INET , socket . SOCK_STREAM ) ) log . debug ( "Connecting to %s" , hostport ) try : yield stream . connect ( ( host , int ( port ) ) ) connection = cls ( stream , tchannel , direction = OUTGOING ) log . debug ( "Performing handshake with %s" , hostport ) yield connection . initiate_handshake ( headers = { 'host_port' : serve_hostport , 'process_name' : process_name , 'tchannel_language' : TCHANNEL_LANGUAGE , 'tchannel_language_version' : TCHANNEL_LANGUAGE_VERSION , 'tchannel_version' : TCHANNEL_VERSION , } ) except ( StreamClosedError , socket . error , errors . TimeoutError ) as e : log . warn ( "Couldn't connect to %s" , hostport ) raise NetworkError ( "Couldn't connect to %s" % hostport , e ) if handler : connection . serve ( handler ) raise tornado . gen . Return ( connection ) | Initiate a new connection to the given host . |
36,657 | def serve ( self , handler ) : assert handler , "handler is required" while not self . closed : message = yield self . await ( ) try : handler ( message , self ) except Exception : log . exception ( "Failed to process %s" , repr ( message ) ) | Serve calls over this connection using the given RequestHandler . |
36,658 | def send_error ( self , error ) : error_message = build_raw_error_message ( error ) write_future = self . writer . put ( error_message ) write_future . add_done_callback ( lambda f : IOLoop . current ( ) . add_callback ( self . tchannel . event_emitter . fire ( EventType . after_send_error , error , ) ) ) return write_future | Convenience method for writing Error frames up the wire . |
36,659 | def stream_request ( self , request , out_future ) : request . close_argstreams ( ) def on_done ( future ) : if future . exception ( ) and out_future . running ( ) : out_future . set_exc_info ( future . exc_info ( ) ) request . close_argstreams ( force = True ) stream_future = self . _stream ( request , self . request_message_factory ) stream_future . add_done_callback ( on_done ) return stream_future | send the given request and response is not required |
36,660 | def send_request ( self , request ) : assert self . _handshake_performed , "Perform a handshake first." assert request . id not in self . _outbound_pending_call , ( "Message ID '%d' already being used" % request . id ) future = tornado . gen . Future ( ) self . _outbound_pending_call [ request . id ] = future self . add_pending_outbound ( ) self . stream_request ( request , future ) . add_done_callback ( lambda f : self . remove_pending_outbound ( ) ) if request . ttl : self . _add_timeout ( request , future ) response_future = tornado . gen . Future ( ) IOLoop . current ( ) . add_future ( future , lambda f : self . adapt_result ( f , request , response_future ) , ) return response_future | Send the given request and response is required . |
36,661 | def _add_timeout ( self , request , future ) : io_loop = IOLoop . current ( ) t = io_loop . call_later ( request . ttl , self . _request_timed_out , request . id , request . service , request . ttl , future , ) io_loop . add_future ( future , lambda f : io_loop . remove_timeout ( t ) ) | Adds a timeout for the given request to the given future . |
36,662 | def get ( self ) : if not self . filling : self . fill ( ) answer = tornado . gen . Future ( ) def _on_result ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) answer . set_result ( future . result ( ) ) def _on_item ( future ) : if future . exception ( ) : return answer . set_exc_info ( future . exc_info ( ) ) future . result ( ) . add_done_callback ( _on_result ) self . queue . get ( ) . add_done_callback ( _on_item ) return answer | Receive the next message off the wire . |
36,663 | def put ( self , message ) : if self . draining is False : self . drain ( ) return self . _enqueue ( message ) | Enqueues the given message for writing to the wire . |
36,664 | def advertise ( self , routers = None , name = None , timeout = None , router_file = None , jitter = None , ) : name = name or self . name if not self . is_listening ( ) : self . listen ( ) return hyperbahn . advertise ( self , name , routers , timeout , router_file , jitter , ) | Make a service available on the Hyperbahn routing mesh . |
36,665 | def request ( self , hostport = None , service = None , arg_scheme = None , retry = None , ** kwargs ) : return self . peers . request ( hostport = hostport , service = service , arg_scheme = arg_scheme , retry = retry , ** kwargs ) | Initiate a new request through this TChannel . |
36,666 | def listen ( self , port = None ) : if self . is_listening ( ) : raise AlreadyListeningError ( "listen has already been called" ) if port : assert not self . _port , "Port has already been set." self . _port = int ( port ) assert self . _handler , "Call .host with a RequestHandler first" server = TChannelServer ( self ) bind_sockets_kwargs = { 'port' : self . _port , 'family' : socket . AF_INET , } if self . _reuse_port is True : bind_sockets_kwargs [ 'reuse_port' ] = True sockets = bind_sockets ( ** bind_sockets_kwargs ) assert sockets , "No sockets bound for port %d" % self . _port self . _port = sockets [ 0 ] . getsockname ( ) [ 1 ] server . add_sockets ( sockets ) self . _server = server | Start listening for incoming connections . |
36,667 | def _register_simple ( self , endpoint , scheme , f ) : assert scheme in DEFAULT_NAMES , ( "Unsupported arg scheme %s" % scheme ) if scheme == JSON : req_serializer = JsonSerializer ( ) resp_serializer = JsonSerializer ( ) else : req_serializer = RawSerializer ( ) resp_serializer = RawSerializer ( ) self . _handler . register ( endpoint , f , req_serializer , resp_serializer ) return f | Register a simple endpoint with this TChannel . |
36,668 | def _register_thrift ( self , service_module , handler , ** kwargs ) : import tchannel . thrift as thrift thrift . register ( self . _handler , service_module , handler , ** kwargs ) return handler | Register a Thrift endpoint on this TChannel . |
36,669 | def register ( self , endpoint , scheme = None , handler = None , ** kwargs ) : assert endpoint is not None , "endpoint is required" if endpoint is TChannel . FALLBACK : decorator = partial ( self . _handler . register , TChannel . FALLBACK ) if handler is not None : return decorator ( handler ) else : return decorator if not scheme : if inspect . ismodule ( endpoint ) : scheme = "thrift" else : scheme = "raw" scheme = scheme . lower ( ) if scheme == 'thrift' : decorator = partial ( self . _register_thrift , endpoint , ** kwargs ) else : decorator = partial ( self . _register_simple , endpoint , scheme , ** kwargs ) if handler is not None : return decorator ( handler ) else : return decorator | Register a handler with this TChannel . |
36,670 | def lt ( self , i , j ) : if self . peers [ i ] . rank == self . peers [ j ] . rank : return self . peers [ i ] . order < self . peers [ j ] . order return self . peers [ i ] . rank < self . peers [ j ] . rank | Compare the priority of two peers . |
36,671 | def push_peer ( self , peer ) : self . order += 1 peer . order = self . order + random . randint ( 0 , self . size ( ) ) heap . push ( self , peer ) | Push a new peer into the heap |
36,672 | def add_and_shuffle ( self , peer ) : self . push_peer ( peer ) r = random . randint ( 0 , self . size ( ) - 1 ) self . swap_order ( peer . index , r ) | Push a new peer into the heap and shuffle the heap |
36,673 | def remove_peer ( self , peer ) : if peer . index < 0 or peer . index >= self . size ( ) : raise IndexError ( 'Peer index is out of range' ) assert peer is self . peers [ peer . index ] , "peer is not in the heap" return heap . remove ( self , peer . index ) | Remove the peer from the heap . |
36,674 | def token_request ( self , authorization_code ) : if not self . _client . token_endpoint : return None request = { 'grant_type' : 'authorization_code' , 'code' : authorization_code , 'redirect_uri' : self . _redirect_uri } logger . debug ( 'making token request: %s' , request ) client_auth_method = self . _client . registration_response . get ( 'token_endpoint_auth_method' , 'client_secret_basic' ) auth_header = _ClientAuthentication ( self . _client . client_id , self . _client . client_secret ) ( client_auth_method , request ) resp = self . _provider_configuration . requests_session . post ( self . _client . token_endpoint , data = request , headers = auth_header ) . json ( ) logger . debug ( 'received token response: %s' , json . dumps ( resp ) ) if 'error' in resp : token_resp = TokenErrorResponse ( ** resp ) else : token_resp = AccessTokenResponse ( ** resp ) token_resp . verify ( keyjar = self . _client . keyjar ) if 'id_token' in resp : token_resp [ 'id_token_jwt' ] = resp [ 'id_token' ] return token_resp | Makes a token request . If the token_endpoint is not configured in the provider metadata no request will be made . |
36,675 | def log_background_messages ( self , name = None ) : with self . lock : if name : self . _log_messages_by_thread ( name ) else : self . _log_all_messages ( ) | Forwards messages logged on background to Robot Framework log . |
36,676 | def reset_rammbock ( self ) : for client in self . _clients : client . close ( ) for server in self . _servers : server . close ( ) self . _init_caches ( ) | Closes all connections deletes all servers clients and protocols . |
36,677 | def clear_message_streams ( self ) : for client in self . _clients : client . empty ( ) for server in self . _servers : server . empty ( ) | Resets streams and sockets of incoming messages . |
36,678 | def new_protocol ( self , protocol_name ) : if self . _protocol_in_progress : raise Exception ( 'Can not start a new protocol definition in middle of old.' ) if protocol_name in self . _protocols : raise Exception ( 'Protocol %s already defined' % protocol_name ) self . _init_new_message_stack ( Protocol ( protocol_name , library = self ) ) self . _protocol_in_progress = True | Start defining a new protocol template . |
36,679 | def end_protocol ( self ) : protocol = self . _get_message_template ( ) self . _protocols [ protocol . name ] = protocol self . _protocol_in_progress = False | End protocol definition . |
36,680 | def start_udp_server ( self , ip , port , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_server ( UDPServer , ip , port , name , timeout , protocol , family ) | Starts a new UDP server to given ip and port . |
36,681 | def start_tcp_server ( self , ip , port , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_server ( TCPServer , ip , port , name , timeout , protocol , family ) | Starts a new TCP server to given ip and port . |
36,682 | def start_sctp_server ( self , ip , port , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_server ( SCTPServer , ip , port , name , timeout , protocol , family ) | Starts a new STCP server to given ip and port . |
36,683 | def start_udp_client ( self , ip = None , port = None , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_client ( UDPClient , ip , port , name , timeout , protocol , family ) | Starts a new UDP client . |
36,684 | def start_tcp_client ( self , ip = None , port = None , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_client ( TCPClient , ip , port , name , timeout , protocol , family ) | Starts a new TCP client . |
36,685 | def start_sctp_client ( self , ip = None , port = None , name = None , timeout = None , protocol = None , family = 'ipv4' ) : self . _start_client ( SCTPClient , ip , port , name , timeout , protocol , family ) | Starts a new SCTP client . |
36,686 | def accept_connection ( self , name = None , alias = None , timeout = 0 ) : server = self . _servers . get ( name ) server . accept_connection ( alias , timeout ) | Accepts a connection to server identified by name or the latest server if name is empty . |
36,687 | def connect ( self , host , port , name = None ) : client = self . _clients . get ( name ) client . connect_to ( host , port ) | Connects a client to given host and port . If client name is not given then connects the latest client . |
36,688 | def server_receives_binary_from ( self , name = None , timeout = None , connection = None , label = None ) : server , name = self . _servers . get_with_name ( name ) msg , ip , port = server . receive_from ( timeout = timeout , alias = connection ) self . _register_receive ( server , label , name , connection = connection ) return msg , ip , port | Receive raw binary message . Returns message ip and port . |
36,689 | def new_message ( self , message_name , protocol = None , * parameters ) : proto = self . _get_protocol ( protocol ) if not proto : raise Exception ( "Protocol not defined! Please define a protocol before creating a message!" ) if self . _protocol_in_progress : raise Exception ( "Protocol definition in progress. Please finish it before starting to define a message." ) configs , fields , header_fields = self . _parse_parameters ( parameters ) self . _raise_error_if_configs_or_fields ( configs , fields , 'New message' ) self . _init_new_message_stack ( MessageTemplate ( message_name , proto , header_fields ) ) | Define a new message template with message_name . |
36,690 | def save_template ( self , name , unlocked = False ) : if isinstance ( unlocked , basestring ) : unlocked = unlocked . lower ( ) != 'false' template = self . _get_message_template ( ) if not unlocked : template . set_as_saved ( ) self . _message_templates [ name ] = ( template , self . _field_values ) | Save a message template for later use with Load template . |
36,691 | def load_template ( self , name , * parameters ) : template , fields , header_fields = self . _set_templates_fields_and_header_fields ( name , parameters ) self . _init_new_message_stack ( template , fields , header_fields ) | Load a message template saved with Save template . Optional parameters are default values for message header separated with colon . |
36,692 | def load_copy_of_template ( self , name , * parameters ) : template , fields , header_fields = self . _set_templates_fields_and_header_fields ( name , parameters ) copy_of_template = copy . deepcopy ( template ) copy_of_fields = copy . deepcopy ( fields ) self . _init_new_message_stack ( copy_of_template , copy_of_fields , header_fields ) | Load a copy of message template saved with Save template when originally saved values need to be preserved from test to test . Optional parameters are default values for message header separated with colon . |
36,693 | def get_message ( self , * parameters ) : _ , message_fields , header_fields = self . _get_parameters_with_defaults ( parameters ) return self . _encode_message ( message_fields , header_fields ) | Get encoded message . |
36,694 | def validate_message ( self , msg , * parameters ) : _ , message_fields , header_fields = self . _get_parameters_with_defaults ( parameters ) self . _validate_message ( msg , message_fields , header_fields ) | Validates given message using template defined with New Message and field values given as optional arguments . |
36,695 | def uint ( self , length , name , value = None , align = None ) : self . _add_field ( UInt ( length , name , value , align = align ) ) | Add an unsigned integer to template . |
36,696 | def int ( self , length , name , value = None , align = None ) : self . _add_field ( Int ( length , name , value , align = align ) ) | Add an signed integer to template . |
36,697 | def chars ( self , length , name , value = None , terminator = None ) : self . _add_field ( Char ( length , name , value , terminator ) ) | Add a char array to template . |
36,698 | def new_struct ( self , type , name , * parameters ) : configs , parameters , _ = self . _get_parameters_with_defaults ( parameters ) self . _add_struct_name_to_params ( name , parameters ) self . _message_stack . append ( StructTemplate ( type , name , self . _current_container , parameters , length = configs . get ( 'length' ) , align = configs . get ( 'align' ) ) ) | Defines a new struct to template . |
36,699 | def _new_list ( self , size , name ) : self . _message_stack . append ( ListTemplate ( size , name , self . _current_container ) ) | Defines a new list to template of size and with name . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.