NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

gateLockMessenger.py (4570B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\stargate\client\gateLockMessenger.py
      2 from datetime import datetime
      3 from six.moves import http_client as httplib
      4 import logging
      5 from eveProto.generated.eve_public.stargate.lock.api.notices_pb2 import RestrictedSystemsNotice, ActivatedNotice, DeactivatedNotice
      6 from eveProto.generated.eve_public.stargate.lock.api.requests_pb2 import GetRequest, GetResponse, GetRestrictedSystemsRequest, GetRestrictedSystemsResponse
      7 from stargate.common.lock_details import LockDetails
      8 from stackless_response_router.exceptions import TimeoutException
      9 logger = logging.getLogger(__name__)
     10 TIMEOUT = 5
     11 
     12 class ClientGateLockMessenger(object):
     13 
     14     def __init__(self, public_gateway):
     15         self.public_gateway = public_gateway
     16         self._restricted_systems_notice_callback = None
     17         self._activated_notice_callback = None
     18         self._deactivated_notice_callback = None
     19 
     20     def subscribe_to_restricted_systems_notice(self, callback):
     21         self._restricted_systems_notice_callback = callback
     22         self.public_gateway.subscribe_to_notice(RestrictedSystemsNotice, self._on_restricted_systems_notice)
     23 
     24     def _on_restricted_systems_notice(self, payload, primitive):
     25         solar_system_ids = [ entry.sequential for entry in payload.solarsystems ]
     26         self._restricted_systems_notice_callback(solar_system_ids)
     27 
     28     def subscribe_to_activated_lock_notice(self, callback):
     29         self._activated_notice_callback = callback
     30         self.public_gateway.subscribe_to_notice(ActivatedNotice, self._on_activated_notice)
     31 
     32     def _on_activated_notice(self, payload, primitive):
     33         lock_details = LockDetails(payload.solarsystem.sequential, payload.gate.sequential, payload.expiry.ToDatetime())
     34         self._activated_notice_callback(lock_details)
     35 
     36     def subscribe_to_deactivated_lock_notice(self, callback):
     37         self._deactivated_notice_callback = callback
     38         self.public_gateway.subscribe_to_notice(DeactivatedNotice, self._on_deactivated_notice)
     39 
     40     def _on_deactivated_notice(self, payload, primitive):
     41         lock_details = LockDetails(payload.solarsystem.sequential, payload.gate.sequential, datetime.now())
     42         self._deactivated_notice_callback(lock_details)
     43 
     44     def get_restricted_systems_request(self):
     45         request = GetRestrictedSystemsRequest()
     46         try:
     47             logger.info('Emanation Lock - get_restricted_systems_request:\nRequest: {request}'.format(request=request))
     48             request_primitive, response_channel = self.public_gateway.send_character_request(request, GetRestrictedSystemsResponse, TIMEOUT)
     49             response_primitive, payload = response_channel.receive()
     50             logger.info('Emanation Lock - get_restricted_systems_request returned: {status_code} - {payload}'.format(status_code=response_primitive.status_code, payload=payload))
     51             if response_primitive.status_code == httplib.NOT_FOUND:
     52                 return []
     53             solar_systems = [ entry.sequential for entry in payload.solarsystems ]
     54             return solar_systems
     55         except TimeoutException:
     56             logger.error('Emanation Lock - get_restricted_systems_request timed out {request}'.format(request=request))
     57             return []
     58         except Exception as exception:
     59             logger.error('Emanation Lock - Error in get_restricted_systems_request {request} - {exception}'.format(request=request, exception=exception))
     60             return []
     61 
     62     def get_request(self):
     63         request = GetRequest()
     64         try:
     65             logger.info('Emanation Lock - get_request:\nRequest: {request}'.format(request=request))
     66             request_primitive, response_channel = self.public_gateway.send_character_request(request, GetResponse, TIMEOUT)
     67             response_primitive, payload = response_channel.receive()
     68             logger.info('Emanation Lock - get_request returned: {status_code} - {payload}'.format(status_code=response_primitive.status_code, payload=payload))
     69             if response_primitive.status_code == httplib.NOT_FOUND:
     70                 return None
     71             return LockDetails(session.solarsystemid2, payload.gate.sequential, payload.expiry.ToDatetime())
     72         except TimeoutException:
     73             logger.error('Emanation Lock - get_request timed out {request}'.format(request=request))
     74             return None
     75         except Exception as exception:
     76             logger.error('Emanation Lock - Error in get_request {request} - {exception}'.format(request=request, exception=exception))
     77             return None