def __init__( self, instance, service_url, modes=[], id='geovelo', timeout=10, api_key=None, feed_publisher=DEFAULT_GEOVELO_FEED_PUBLISHER, verify=True, **kwargs ): self.instance = instance self.sn_system_id = id if not is_url(service_url): raise ValueError('service_url {} is not a valid url'.format(service_url)) self.service_url = service_url self.api_key = api_key self.timeout = timeout self.modes = modes self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_GEOVELO_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_GEOVELO_TIMEOUT_S'], ) self._feed_publisher = FeedPublisher(**feed_publisher) if feed_publisher else None self.verify = verify
def __init__(self, id, service_url, service_args, timezone, object_id_tag=None, destination_id_tag=None, instance=None, timeout=10, **kwargs): self.service_url = service_url self.service_args = service_args self.timeout = timeout #timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.destination_id_tag = destination_id_tag self.instance = instance self.breaker = pybreaker.CircuitBreaker(fail_max=app.config['CIRCUIT_BREAKER_MAX_TIMEO_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_TIMEO_TIMEOUT_S']) # Note: if the timezone is not know, pytz raise an error self.timezone = pytz.timezone(timezone) if kwargs.get('redis_host') and kwargs.get('rate_limit_count'): self.rate_limiter = RateLimiter(conditions=[{'requests': kwargs.get('rate_limit_count'), 'seconds': kwargs.get('rate_limit_duration', 1)}], redis_host=kwargs.get('redis_host'), redis_port=kwargs.get('redis_port', 6379), redis_db=kwargs.get('redis_db', 0), redis_password=kwargs.get('redis_password'), redis_namespace=kwargs.get('redis_namespace', 'jormungandr.rate_limiter')) else: self.rate_limiter = FakeRateLimiter()
def __init__(self, id, service_url, service_args, timezone, object_id_tag=None, destination_id_tag=None, instance=None, timeout=10, **kwargs): self.service_url = service_url if (service_url[-1] == u'/') else (service_url + '/') self.service_args = service_args self.timeout = timeout # timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.destination_id_tag = destination_id_tag self.instance = instance fail_max = kwargs.get( 'circuit_breaker_max_fail', app.config.get(str('CIRCUIT_BREAKER_MAX_CLEVERAGE_FAIL'), 5)) reset_timeout = kwargs.get( 'circuit_breaker_reset_timeout', app.config.get(str('CIRCUIT_BREAKER_CLEVERAGE_TIMEOUT_S'), 60)) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) self.timezone = pytz.timezone(timezone)
def init_breaker(cls): from app import settings cls._breaker = pybreaker.CircuitBreaker( fail_max=settings['WIKI_API_CIRCUIT_MAXFAIL'], reset_timeout=settings['WIKI_API_CIRCUIT_TIMEOUT'], exclude=[HTTPError40X], listeners=[LogListener()])
def __init__(self, url, network, username, password, operators={'cykleo'}, verify_certificate=False, service_id=None, organization_id=None, timeout=2, feed_publisher=DEFAULT_CYKLEO_FEED_PUBLISHER, **kwargs): self.url = url self.network = network.lower() self.service_id = service_id self.organization_id = organization_id self.verify_certificate = verify_certificate self.username = username self.password = password self.operators = [o.lower() for o in operators] self.timeout = timeout self.breaker = pybreaker.CircuitBreaker( fail_max=kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_CYKLEO_FAIL']), reset_timeout=kwargs.get( 'circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_CYKLEO_TIMEOUT_S']), ) self._feed_publisher = FeedPublisher( **feed_publisher) if feed_publisher else None
def __init__(self, url, operators, dataset, timeout=1, feed_publisher=DEFAULT_STAR_FEED_PUBLISHER, **kwargs): self.ws_service_template = url + '/?dataset={}&refine.idparc={}' self.operators = [o.lower() for o in operators] self.timeout = timeout self.dataset = dataset fail_max = kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_STAR_FAIL']) reset_timeout = kwargs.get( 'circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_STAR_TIMEOUT_S']) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) self._feed_publisher = FeedPublisher( **feed_publisher) if feed_publisher else None self.log = logging.LoggerAdapter(logging.getLogger(__name__), extra={'dataset': self.dataset})
def __init__(self, instance, service_url, api_key, network, feed_publisher=DEFAULT_INSTANT_SYSTEM_FEED_PUBLISHER, rating_scale_min=None, rating_scale_max=None, timeout=2): self.instance = instance self.service_url = service_url self.api_key = api_key self.network = network self.rating_scale_min = rating_scale_min self.rating_scale_max = rating_scale_max self.system_id = 'Instant System' self.timeout = timeout self.feed_publisher = None if feed_publisher is None else RsFeedPublisher( **feed_publisher) self.journey_metadata = rsj.MetaData( system_id=self.system_id, network=self.network, rating_scale_min=self.rating_scale_min, rating_scale_max=self.rating_scale_max) self.logger = logging.getLogger("{} {}".format(__name__, self.system_id)) self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_INSTANT_SYSTEM_FAIL'], reset_timeout=app. config['CIRCUIT_BREAKER_INSTANT_SYSTEM_TIMEOUT_S'])
def __init__(self, instance, service_url, asgard_socket, modes=None, id=None, timeout=10, api_key=None, socket_ttl=app.config['ASGARD_ZMQ_SOCKET_TTL_SECONDS'], **kwargs): super(Asgard, self).__init__(name=instance.name, zmq_context=instance.context, socket_path=asgard_socket, socket_ttl=socket_ttl, instance=instance, service_url=service_url, modes=modes or [], id=id or 'asgard', timeout=timeout, api_key=api_key, **kwargs) self.asgard_socket = asgard_socket self.timeout = timeout self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_ASGARD_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_ASGARD_TIMEOUT_S'], ) self.socket_ttl = socket_ttl self.logger = logging.getLogger(__name__)
def circuit_breaker(logger, name, fail_max=5, reset_timeout=60, state_storage=None, exclude=None): if exclude is None: exclude = [] breaker = pybreaker.CircuitBreaker( name=name, listeners=[breaker_logger(logger)], exclude=exclude, fail_max=fail_max, reset_timeout=reset_timeout, state_storage=state_storage, ) def circuit_breaker_middleware(ctx, call): context = ctx.get(_CONTEXT, {}) log = logger.bind(**context) if breaker.current_state == "open": log.info("circuitbreaker.open", name=breaker.name) call = breaker(call) try: ctx = call(ctx) return ctx except pybreaker.CircuitBreakerError: return ctx return circuit_breaker_middleware
def __init__( self, service_url, api_key, network, feed_publisher=DEFAULT_BLABLALINES_FEED_PUBLISHER, timedelta=3600, timeout=2, ): self.service_url = service_url self.api_key = api_key self.network = network self.system_id = 'blablalines' self.timeout = timeout self.timedelta = timedelta self.feed_publisher = None if feed_publisher is None else RsFeedPublisher( **feed_publisher) self.logger = logging.getLogger("{} {}".format(__name__, self.system_id)) self.breaker = pybreaker.CircuitBreaker( fail_max=app.config.get( str('CIRCUIT_BREAKER_MAX_BLABLALINES_FAIL'), 4), reset_timeout=app.config.get( str('CIRCUIT_BREAKER_BLABLALINES_TIMEOUT_S'), 60), ) self.call_params = '' self.journey_metadata = rsj.MetaData(system_id=self.system_id, network=self.network, rating_scale_min=None, rating_scale_max=None)
def __init__( self, host='localhost', port=6379, password=None, db=0, default_timeout=300, key_prefix=None, **kwargs ): fail_max = kwargs.pop('fail_max', 5) reset_timeout = kwargs.pop('reset_timeout', 60) BaseRedisCache.__init__(self, host, port, password, db, default_timeout, key_prefix, **kwargs) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout)
def __init__(self, context, name, zmq_socket, realtime_proxies_configuration=[]): self.geom = None self._sockets = queue.Queue() self.socket_path = zmq_socket self._scenario = None self._scenario_name = None self.nb_created_socket = 0 self.lock = Lock() self.context = context self.name = name self.timezone = None # timezone will be fetched from the kraken self.publication_date = -1 self.is_up = True self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_INSTANCE_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_INSTANCE_TIMEOUT_S']) self.georef = georef.Kraken(self) self.planner = planner.Kraken(self) self.schedule = schedule.MixedSchedule(self) self.realtime_proxy_manager = realtime_schedule.RealtimeProxyManager( realtime_proxies_configuration) from jormungandr.autocomplete.kraken import Kraken self.autocomplete = Kraken()
def __init__( self, id, service_url, requestor_ref, object_id_tag=None, destination_id_tag=None, instance=None, timeout=10, **kwargs ): self.service_url = service_url self.requestor_ref = requestor_ref # login for siri self.timeout = timeout # timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.destination_id_tag = destination_id_tag self.instance = instance fail_max = kwargs.get( 'circuit_breaker_max_fail', app.config.get(str('CIRCUIT_BREAKER_MAX_SIRI_FAIL'), 5) ) reset_timeout = kwargs.get( 'circuit_breaker_reset_timeout', app.config.get(str('CIRCUIT_BREAKER_SIRI_TIMEOUT_S'), 60) ) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) # A step is applied on from_datetime to discretize calls and allow caching them self.from_datetime_step = kwargs.get( 'from_datetime_step', app.config['CACHE_CONFIGURATION'].get('TIMEOUT_SIRI', 60) )
def __init__(self, instance, service_url, modes=[], id='valhalla', timeout=10, api_key=None, **kwargs): self.instance = instance self.sn_system_id = id if not is_url(service_url): raise ValueError( 'service_url {} is not a valid url'.format(service_url)) self.service_url = service_url self.api_key = api_key self.timeout = timeout self.modes = modes self.costing_options = kwargs.get('costing_options', None) # kilometres is default units self.directions_options = {'units': 'kilometers'} self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_VALHALLA_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_VALHALLA_TIMEOUT_S'], ) # the mode's park cost represent the initial cost to leave the given mode # it is used to represent that it takes time to park a car or a bike # since valhalla does not handle such a time, we rig valhalla's result to add it self.mode_park_cost = kwargs.get( 'mode_park_cost', {}) # a dict giving the park time (in s) by mode
def __init__(self, instance, service_base_url, modes=[], id='here', timeout=10, api_id=None, api_code=None, feed_publisher=DEFAULT_HERE_FEED_PUBLISHER, **kwargs): self.instance = instance self.sn_system_id = id if not service_base_url: raise ValueError('service_url {} is not a valid HERE url'.format( service_base_url)) service_base_url = service_base_url.rstrip('/') self.routing_service_url = 'https://{base_url}/calculateroute.json'.format( base_url=service_base_url) self.matrix_service_url = 'https://matrix.{base_url}/calculatematrix.json'.format( base_url=service_base_url) self.api_id = api_id self.api_code = api_code self.modes = modes self.timeout = timeout self.max_points = 100 # max number of point asked in the routing matrix self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_HERE_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_HERE_TIMEOUT_S']) self.log = logging.LoggerAdapter(logging.getLogger(__name__), extra={'streetnetwork_id': id}) self._feed_publisher = FeedPublisher( **feed_publisher) if feed_publisher else None
def __init__(self, id, service_url, timezone, object_id_tag=None, timeout=10, redis_host=None, redis_db=0, redis_port=6379, redis_password=None, max_requests_by_second=15, redis_namespace='jormungandr.rate_limiter'): self.service_url = service_url self.timeout = timeout # timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_SYNTHESE_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_SYNTHESE_TIMEOUT_S']) self.timezone = pytz.timezone(timezone) if not redis_host: self.rate_limiter = FakeRateLimiter() else: self.rate_limiter = RateLimiter(conditions=[{ 'requests': max_requests_by_second, 'seconds': 1 }], redis_host=redis_host, redis_port=redis_port, redis_db=redis_db, redis_password=redis_password, redis_namespace=redis_namespace)
def __init__(self, id, service_url, service_args, timezone, object_id_tag=None, destination_id_tag=None, instance=None, timeout=10, **kwargs): self.service_url = service_url self.service_args = service_args self.timeout = timeout #timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.destination_id_tag = destination_id_tag self.instance = instance fail_max = kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_TIMEO_FAIL']) reset_timeout = kwargs.get('circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_TIMEO_TIMEOUT_S']) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) # A step is applied on from_datetime to discretize calls and allow caching them self.from_datetime_step = kwargs.get('from_datetime_step', app.config['CACHE_CONFIGURATION'].get('TIMEOUT_TIMEO', 60)) # Note: if the timezone is not know, pytz raise an error self.timezone = pytz.timezone(timezone) if kwargs.get('redis_host') and kwargs.get('rate_limit_count'): self.rate_limiter = RateLimiter(conditions=[{'requests': kwargs.get('rate_limit_count'), 'seconds': kwargs.get('rate_limit_duration', 1)}], redis_host=kwargs.get('redis_host'), redis_port=kwargs.get('redis_port', 6379), redis_db=kwargs.get('redis_db', 0), redis_password=kwargs.get('redis_password'), redis_namespace=kwargs.get('redis_namespace', 'jormungandr.rate_limiter')) else: self.rate_limiter = FakeRateLimiter()
def __init__(self, network, contract, api_key, operators={'jcdecaux'}, timeout=10, feed_publisher=DEFAULT_JCDECAUX_FEED_PUBLISHER, **kwargs): self.network = network.lower() self.contract = contract self.api_key = api_key self.operators = [o.lower() for o in operators] self.timeout = timeout fail_max = kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_JCDECAUX_FAIL']) reset_timeout = kwargs.get( 'circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_JCDECAUX_TIMEOUT_S']) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) self._feed_publisher = FeedPublisher( **feed_publisher) if feed_publisher else None self._data = {} self._last_update = datetime.datetime(1970, 1, 1) self._update_interval = 30
def __init__(self, network, contract, api_key, timeout=10): self.network = network self.contract = contract self.api_key = api_key self.timeout = timeout self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_JCDECAUX_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_JCDECAUX_TIMEOUT_S'])
def __init__(self, id_ao, network, url, operators={'keolis'}, timeout=5, **kwargs): self.id_ao = id_ao self.network = network.lower() self.WS_URL = url self.operators = [o.lower() for o in operators] self.timeout = timeout self._client = None self.breaker = pybreaker.CircuitBreaker(fail_max=kwargs.get('fail_max', 5), reset_timeout=kwargs.get('reset_timeout', 120))
def __init__(self, service_url, max_park_duration=DEFAULT_MAX_PARKING_DURATION): self.service_url = service_url self.max_park_duration = max_park_duration # TODO: put into a config when the POC is validated one_minute = timedelta(seconds=60).total_seconds() self.breaker = pybreaker.CircuitBreaker(fail_max=10, reset_timeout=one_minute) self.request_timeout = timedelta(seconds=0.1).total_seconds() self.logger = logging.getLogger(__name__)
def __init__(self, network, contract, api_key, operators={'jcdecaux'}, timeout=10, **kwargs): self.network = network.lower() self.contract = contract self.api_key = api_key self.operators = [o.lower() for o in operators] self.timeout = timeout fail_max = kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_JCDECAUX_FAIL']) reset_timeout = kwargs.get('circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_JCDECAUX_TIMEOUT_S']) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout)
def __init__(self, url, timeout=2, **kwargs): self.url = url self.timeout = timeout self.breaker = pybreaker.CircuitBreaker( fail_max=kwargs.get('circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_SYTRAL_FAIL']), reset_timeout=kwargs.get( 'circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_SYTRAL_TIMEOUT_S'] ), )
def __init__(self, id_ao, network, url, operators={'keolis'}, timeout=5, feed_publisher=DEFAULT_ATOS_FEED_PUBLISHER, **kwargs): self.id_ao = id_ao self.network = network.lower() self.WS_URL = url self.operators = [o.lower() for o in operators] self.timeout = timeout self._client = None self.breaker = pybreaker.CircuitBreaker(fail_max=kwargs.get('fail_max', 5), reset_timeout=kwargs.get('reset_timeout', 120)) self._feed_publisher = FeedPublisher(**feed_publisher) if feed_publisher else None
def __init__(self, **kwargs): self.host = kwargs.get('host') self.timeout = kwargs.get('timeout', 2) # used for slow call, like geocoding # used for fast call like reverse geocoding and features self.fast_timeout = kwargs.get('fast_timeout', 0.2) self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_BRAGI_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_BRAGI_TIMEOUT_S'], )
def __init__( self, id, service_url, service_args, timezone, object_id_tag=None, destination_id_tag=None, instance=None, timeout=10, **kwargs ): self.service_url = service_url self.service_args = service_args self.timeout = timeout # timeout in seconds self.rt_system_id = id self.object_id_tag = object_id_tag if object_id_tag else id self.destination_id_tag = destination_id_tag if destination_id_tag else "source" self.timeo_stop_code = kwargs.get("source_stop_code", "StopTimeoCode") self.timeo_line_code = kwargs.get("source_line_code", "LineTimeoCode") self.next_stop_time_number = kwargs.get("next_stop_time_number", 5) self.instance = instance fail_max = kwargs.get( 'circuit_breaker_max_fail', app.config.get(str('CIRCUIT_BREAKER_MAX_TIMEO_FAIL'), 5) ) reset_timeout = kwargs.get( 'circuit_breaker_reset_timeout', app.config.get(str('CIRCUIT_BREAKER_TIMEO_TIMEOUT_S'), 60) ) self.breaker = pybreaker.CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout) # A step is applied on from_datetime to discretize calls and allow caching them self.from_datetime_step = kwargs.get( 'from_datetime_step', app.config.get(str('CACHE_CONFIGURATION'), {}).get(str('TIMEOUT_TIMEO'), 60) ) # Note: if the timezone is not know, pytz raise an error self.timezone = pytz.timezone(timezone) if kwargs.get('redis_host') and kwargs.get('rate_limit_count'): self.rate_limiter = RateLimiter( conditions=[ {'requests': kwargs.get('rate_limit_count'), 'seconds': kwargs.get('rate_limit_duration', 1)} ], redis_host=kwargs.get('redis_host'), redis_port=kwargs.get('redis_port', 6379), redis_db=kwargs.get('redis_db', 0), redis_password=kwargs.get('redis_password'), redis_namespace=kwargs.get('redis_namespace', 'jormungandr.rate_limiter'), ) else: self.rate_limiter = FakeRateLimiter() # We consider that all errors, greater than or equal to 100, are blocking self.INTERNAL_TIMEO_ERROR_CODE_LIMIT = 100
def __init__(self, instance, service_base_url, modes=[], id='here', timeout=10, apiKey=None, matrix_type=MatrixType.simple_matrix.value, max_matrix_points=default_values.here_max_matrix_points, realtime_traffic=True, language="english", engine_type="diesel", engine_average_consumption=7, feed_publisher=DEFAULT_HERE_FEED_PUBLISHER, **kwargs): self.instance = instance self.sn_system_id = id if not service_base_url: raise ValueError('service_url {} is not a valid HERE url'.format( service_base_url)) service_base_url = service_base_url.rstrip('/') self.routing_service_url = 'https://{base_url}/calculateroute.json'.format( base_url=service_base_url) self.matrix_service_url = 'https://matrix.{base_url}/calculatematrix.json'.format( base_url=service_base_url) self.log = logging.LoggerAdapter( logging.getLogger(__name__), extra={'streetnetwork_id': text_type(id)}) self.apiKey = apiKey self.modes = modes self.timeout = timeout self.matrix_type = self._get_matrix_type(matrix_type) self.max_matrix_points = self._get_max_matrix_points(max_matrix_points) self.realtime_traffic = self._get_realtime_traffic(realtime_traffic) self.language = self._get_language(language.lower()) self.engine_type = self._get_engine_type(engine_type.lower()) self.engine_average_consumption = engine_average_consumption self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_HERE_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_HERE_TIMEOUT_S'], ) self.log.debug( 'Here, load configuration max_matrix_points={} - matrix_type={} - realtime_traffic={} - language={} - engine_type={} - engine_average_consumption={}' .format( self.max_matrix_points, self.matrix_type.value, self.realtime_traffic.value, self.language.value, self.engine_type, self.engine_average_consumption, )) self._feed_publisher = FeedPublisher( **feed_publisher) if feed_publisher else None
def __init__(self, service_url, timeout=2, **kwargs): self.logger = logging.getLogger(__name__) self.service_url = service_url self.timeout = timeout self.breaker = pybreaker.CircuitBreaker( fail_max=kwargs.get( 'circuit_breaker_max_fail', app.config['CIRCUIT_BREAKER_MAX_FORSETI_FAIL']), reset_timeout=kwargs.get( 'circuit_breaker_reset_timeout', app.config['CIRCUIT_BREAKER_FORSETI_TIMEOUT_S']), )
def __init__(self, instance, url, timeout=10, api_key=None, **kwargs): self.instance = instance if not is_url(url): raise ValueError('service_url is invalid, you give {}'.format(url)) self.service_url = url self.api_key = api_key self.timeout = timeout self.costing_options = kwargs.get('costing_options', None) # kilometres is default units self.directions_options = {'units': 'kilometers'} self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_VALHALLA_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_VALHALLA_TIMEOUT_S'])
def __init__( self, context, name, zmq_socket, street_network_configurations, ridesharing_configurations, realtime_proxies_configuration, zmq_socket_type, autocomplete_type, ): self.geom = None self._sockets = deque() self.socket_path = zmq_socket self._scenario = None self._scenario_name = None self.lock = Lock() self.context = context self.name = name self.timezone = None # timezone will be fetched from the kraken self.publication_date = -1 self.is_initialized = False # kraken hasn't been called yet we don't have geom nor timezone self.breaker = pybreaker.CircuitBreaker( fail_max=app.config['CIRCUIT_BREAKER_MAX_INSTANCE_FAIL'], reset_timeout=app.config['CIRCUIT_BREAKER_INSTANCE_TIMEOUT_S'], ) self.georef = georef.Kraken(self) self.planner = planner.Kraken(self) street_network_configurations = _set_default_street_network_config( street_network_configurations) self.street_network_services = street_network.StreetNetwork.get_street_network_services( self, street_network_configurations) self.ridesharing_services = [] if ridesharing_configurations is not None: self.ridesharing_services = ridesharing_service.Ridesharing.get_ridesharing_services( self, ridesharing_configurations) self.ptref = ptref.PtRef(self) self.schedule = schedule.MixedSchedule(self) self.realtime_proxy_manager = realtime_schedule.RealtimeProxyManager( realtime_proxies_configuration, self) self._autocomplete_type = autocomplete_type if self._autocomplete_type is not None and self._autocomplete_type not in global_autocomplete: raise RuntimeError('impossible to find autocomplete system {} ' 'cannot initialize instance {}'.format( autocomplete_type, name)) self.zmq_socket_type = zmq_socket_type