def __init__(self, id=None, config={}, hw_metadata={}):
EventEmitter.__init__(self)
self.id = id
self.config = config
self.status = None
self.device_timeout = config.get('max_time_since_last_seen', 300)
self._timeout_expect_new_status = None
def __init__(self, host='0.0.0.0', port=1234, tcp_backlog=20):
asyncore.dispatcher.__init__(self)
EventEmitter.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((host, port))
self.listen(tcp_backlog)
self.clients = {}
def __init__(self, host, port):
self._host = host
self._port = port
self._error = None
self._connect_called = False
asyncore.dispatcher.__init__(self)
EventEmitter.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
def __init__(self, ttl=None):
EventEmitter.__init__(self)
self.fd = None
self.ip = None
self.port = None
self.timeout = None
self.socket = None
self.connected = False
self.connecting = False
self.error = None
self.buffer = bytearray()
self.ttl = ttl
self.ttl_timeout = None
def __init__(self, sock, server):
self.id = sock.fileno()
debug("INFO", "NEW CLIENT: ", self.id)
self.server = server
self.request = None
self.proto = None
self.status = "alive"
self.processing = False
self.client_id = None
self.session_id = None
asyncore.dispatcher_with_send.__init__(self, sock)
EventEmitter.__init__(self)
# Proxy 'request' event to
self.on('request', self.process_request)
def __init__(self, id=None, config={}, hw_metadata={}):
EventEmitter.__init__(self)
self.id = id
self.config = config
self.key = config.get('key', None)
self.ip = config.get('ip', hw_metadata.get('ip', None))
self.port = config.get('port', 6668)
self.socket_timeout = config.get('socket_timeout', 10)
self.command_timeout = config.get('command_timeout', 5)
self.version = float(hw_metadata.get('version', '3.3'))
self.active = hw_metadata.get('active', None)
self.ablilty = hw_metadata.get('ablilty', None)
self.encrypt = hw_metadata.get('encrypt', None)
self.product_key = hw_metadata.get('productKey', None)
self.gw_id = hw_metadata.get('gwId', None)
self.dps = str(config.get('dps', 1))
self.persistent_connections = config.get('persistent_connections',
False)
self.get_status_on_start = config.get('get_status_on_start', True)
# Creates the connection object and sets event handlers
self.connection = AsyncSocketClient(ttl=config.get('socket_ttl', 300))
self.connection.on('connect', self._on_dev_connect)
self.connection.on('failure', self._on_dev_connection_failure)
self.connection.on('timeout', self._on_dev_connection_failure)
self.connection.on('break', self._on_dev_connection_break)
self.connection.on('disconnect', self._on_dev_disconnect)
self.connection.on('exception', self._on_dev_exception)
self.connection.on('error', self._on_dev_error)
self.connected = False
self.connecting = False
self.sync_proto = SyncProto(
self.connection,
self._encode_and_send_message,
self._read_and_parse_message,
)
self.sync_proto.on('drain', self._on_dev_send_drain)
self.sync_proto.on('send_error', self._on_dev_send_error)
self.sync_proto.on('receive_error', self._on_dev_recv_error)
# When IP address changes
self.on('_ip', self._on_ip_change)
# Connect to the device right away if persistent_connections is ON
if self.gw_id and self.ip:
self.emit('_ip')
def __init__(self,
async_socket,
encoder_and_sender,
reader_and_decoder,
timeout=None):
EventEmitter.__init__(self)
self.socket = async_socket
self.id = None
self.encode_and_send = encoder_and_sender
self.receive_and_decode = reader_and_decoder
self.command_queue = []
self.buffer = bytearray()
async_socket.on('connect', self._on_connect)
async_socket.on('break', self._on_disconnect)
async_socket.on('disconnect', self._on_disconnect)
async_socket.on('data', self._on_data)
self.on('_next', self._on_can_send_next_command)
def __init__(self,
id=None,
hw=None,
config={},
discovery_status='offline',
device_status="up",
switch_status=None,
hw_metadata={},
last_seen=None,
**kwargs):
EventEmitter.__init__(self)
self.id = id
self.discovery_status = discovery_status
self.device_status = device_status
self.switch_status = switch_status
self.last_status_update = 0
self.last_seen = last_seen
self.hw_metadata = hw_metadata
self.hooks = config.get('hooks', [])
self.metadata = config.get('metadata', {})
self.status_cache = config.get('status_cache', None)
self.refresh_status = int(config.get('refresh_status', 0))
self.hold_get_status = config.get('hold_get_status', False)
self.activation_key = config.get('activation_key', None)
self.fails_to_miss = config.get('fails_to_miss', 5)
self.config = config
self.hw_metadata = hw_metadata
self.hw_type = hw
self.hw = self._import_device_module(id, hw, config,
hw_metadata) if hw else None
self.connect_errors = 0
self.waiting_status = []
# Listen to device's events
if self.hw:
self.hw.on('status_update', self._on_status_update)
# Periodically refresh the device status
if self.refresh_status:
asyncorepp.set_interval(self._refresh_status, self.refresh_status)
