class PortAgent(object):
_agent = 'http://localhost:8500/v1/agent/'
def __init__(self, config):
self.config = config
self.refdes = config.get('refdes', config['type'])
self.ttl = config['ttl']
self.num_connections = 0
self.disconnect_notification_id = None
self.router = Router(self)
self.stats_publisher = StatisticsPublisher()
self.stats_publisher.connect()
self.connections = set()
self.clients = set()
self._register_loggers()
self._create_routes()
self._start_servers()
self.get_consul_host()
heartbeat_task = task.LoopingCall(self._heartbeat)
heartbeat_task.start(interval=HEARTBEAT_INTERVAL)
log.msg('Base PortAgent initialization complete')
def _register_loggers(self):
"""
Create and register the binary and ascii loggers
:return:
"""
if not os.path.exists(CURRENTDIR):
os.makedirs(CURRENTDIR)
binary_name = '%s.datalog' % self.refdes
ascii_name = '%s.log' % self.refdes
self.data_logger = ArchivingDailyLogFile(
binary_name, CURRENTDIR, os.path.join(ARCHIVEDIR, self.refdes))
self.ascii_logger = ArchivingDailyLogFile(
ascii_name, CURRENTDIR, os.path.join(DISCARDDIR, self.refdes))
self.router.register(EndpointType.DATALOGGER, self.data_logger)
self.router.register(EndpointType.LOGGER, self.ascii_logger)
def _create_routes(self):
"""
Default routes for all port agent types
This provides a mapping from packet type to endpoint type
:return:
"""
# Register the logger and datalogger to receive all messages
self.router.add_route(PacketType.ALL,
EndpointType.LOGGER,
data_format=Format.ASCII)
self.router.add_route(PacketType.ALL,
EndpointType.DATALOGGER,
data_format=Format.PACKET)
# from DRIVER
self.router.add_route(PacketType.FROM_DRIVER,
EndpointType.INSTRUMENT,
data_format=Format.RAW)
# from INSTRUMENT
self.router.add_route(PacketType.FROM_INSTRUMENT,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.FROM_INSTRUMENT,
EndpointType.RAW,
data_format=Format.RAW)
self.router.add_route(PacketType.PICKLED_FROM_INSTRUMENT,
EndpointType.CLIENT,
data_format=Format.PACKET)
# from COMMAND SERVER
self.router.add_route(PacketType.PA_COMMAND,
EndpointType.COMMAND_HANDLER,
data_format=Format.PACKET)
# from PORT_AGENT
self.router.add_route(PacketType.PA_CONFIG,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.PA_CONFIG,
EndpointType.COMMAND,
data_format=Format.RAW)
self.router.add_route(PacketType.PA_FAULT,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.PA_HEARTBEAT,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS,
EndpointType.COMMAND,
data_format=Format.RAW)
# from COMMAND HANDLER
self.router.add_route(PacketType.DIGI_CMD,
EndpointType.DIGI,
data_format=Format.RAW)
# from DIGI
self.router.add_route(PacketType.DIGI_RSP,
EndpointType.CLIENT,
data_format=Format.PACKET)
self.router.add_route(PacketType.DIGI_RSP,
EndpointType.COMMAND,
data_format=Format.RAW)
def get_service_name_id(self, service):
"""
Given a service name, compute the fully qualified service name and id for this agent
:param service: service name
:return:
"""
base_id = 'port-agent'
if service != 'data':
name = service + '-' + base_id
else:
name = base_id
service_id = name + '-' + self.refdes
return name, service_id
@inlineCallbacks
def got_port_cb(self, service, port_obj):
"""
Called after a port is successfully bound by the server.
Register the service with Consul.
:param service: service to be registered
:param port_obj: port object containing the IP address and port
:return:
"""
ipaddr = port_obj.getHost()
port = ipaddr.port
self.config['ports'][service] = port
name, service_id = self.get_service_name_id(service)
values = {
'ID': service_id,
'Name': name,
'Port': port,
'Check': {
'TTL': '%ss' % self.ttl
},
'Tags': [self.refdes]
}
response = yield put(self._agent + 'service/register',
json.dumps(values))
if response.code != httplib.OK:
log.msg(service + 'http response: %s' % response.code)
def _start_servers(self):
"""
Start the base port agent servers:
DATA
COMMAND
SNIFF
:return:
"""
self.data_endpoint = TCP4ServerEndpoint(reactor, 0)
self.data_endpoint.listen(
DataFactory(self, PacketType.FROM_DRIVER,
EndpointType.CLIENT)).addCallback(
partial(self.got_port_cb, 'data'))
self.command_endpoint = TCP4ServerEndpoint(reactor, 0)
self.command_endpoint.listen(
CommandFactory(self, PacketType.PA_COMMAND,
EndpointType.COMMAND)).addCallback(
partial(self.got_port_cb, 'command'))
self.sniff_endpoint = TCP4ServerEndpoint(reactor, 0)
self.sniff_endpoint.listen(
DataFactory(self, PacketType.UNKNOWN,
EndpointType.LOGGER)).addCallback(
partial(self.got_port_cb, 'sniff'))
@inlineCallbacks
def _heartbeat(self):
"""
Send a heartbeat packet and set our Consul status to PASS
:return:
"""
packets = Packet.create('HB', PacketType.PA_HEARTBEAT)
self.router.got_data(packets)
# Set TTL Check Status
check_string = self._agent + 'check/pass/service:'
for service in self.config['ports']:
name, service_id = self.get_service_name_id(service)
yield get(check_string + service_id)
@inlineCallbacks
def get_consul_host(self):
"""
Fetch our host information from Consul
:return:
"""
url = self._agent + 'self'
try:
response = yield get(url)
body = yield readBody(response)
data = json.loads(body)
host = data['Member']['Addr']
self.config['host'] = host
except (ConnectionRefusedError, KeyError) as e:
log.msg('Unable to retrieve host address from consul: ', e)
reactor.callLater(CONSUL_RETRY_INTERVAL, self.get_consul_host)
def client_connected(self, connection):
"""
Log an incoming client connection
:param connection: connection object
:return:
"""
log.msg('CLIENT CONNECTED FROM ', connection)
self.clients.add(connection)
def client_disconnected(self, connection):
"""
Log a client disconnect
:param connection: connection object
:return:
"""
self.clients.remove(connection)
log.msg('CLIENT DISCONNECTED FROM ', connection)
def instrument_connected(self, connection):
"""
Log a successful instrument connection,
notifying the driver if the target number of connections is reached.
:param connection: connection object
:return:
"""
log.msg('CONNECTED TO ', connection)
self.connections.add(connection)
if len(self.connections) == self.num_connections:
# We are now CONNECTED
# Cancel any pending DISCONNECTED notification
if self.disconnect_notification_id is not None:
try:
self.disconnect_notification_id.cancel()
except AlreadyCalled:
pass
finally:
self.disconnect_notification_id = None
# Notify driver we are CONNECTED
self.router.got_data(
Packet.create('CONNECTED', PacketType.PA_STATUS))
def instrument_disconnected(self, connection):
"""
Log a instrument disconnect,
notifying the driver after INSTRUMENT_DISCONNECT_FORGIVENESS_INTERVAL
if the target number of connections is not reached.
:param connection: connection object
:return:
"""
self.connections.remove(connection)
log.msg('DISCONNECTED FROM ', connection)
if self.disconnect_notification_id is None:
self.disconnect_notification_id = reactor.callLater(
INSTRUMENT_DISCONNECT_FORGIVENESS_INTERVAL,
self.notify_disconnected)
def notify_disconnected(self):
"""
Send a disconnect notification to the instrument driver
:return:
"""
log.msg('Notifying driver we are DISCONNECTED')
self.disconnect_notification_id = None
self.router.got_data(
Packet.create('DISCONNECTED', PacketType.PA_STATUS))
def register_commands(self, command_protocol):
"""
Register the available commands for this agent on a new CommandProtocol object
:param command_protocol: CommandProtocol object
:return:
"""
log.msg('PortAgent register commands for protocol: %s' %
command_protocol)
command_protocol.register_command('get_state', self.get_state)
command_protocol.register_command('get_config', self.get_config)
command_protocol.register_command('get_version', self.get_version)
def get_state(self, *args):
"""
Respond to an incoming get_state request
:param args: not applicable to this command
:return:
"""
log.msg('get_state: %r %d' % (self.connections, self.num_connections))
if len(self.connections) == self.num_connections:
return Packet.create('CONNECTED', PacketType.PA_STATUS)
return Packet.create('DISCONNECTED', PacketType.PA_STATUS)
def get_config(self, *args):
"""
Respond to an incoming get_config request
:param args: not applicable to this command
:return:
"""
return Packet.create(json.dumps(self.config), PacketType.PA_CONFIG)
# noinspection PyMethodMayBeStatic
def get_version(self, *args):
"""
Respond to an incoming get_version request
:param args: not applicable to this command
:return:
"""
return Packet.create(ooi_port_agent.__version__, PacketType.PA_CONFIG)
class PortAgent(object):
_agent = 'http://localhost:8500/v1/agent/'
def __init__(self, config):
self.config = config
self.data_port = config['port']
self.command_port = config['commandport']
self.sniff_port = config['sniffport']
self.name = config.get('name', str(self.command_port))
self.refdes = config.get('refdes', config['type'])
self.ttl = config['ttl']
self.data_name = 'port-agent'
self.command_name = 'command-port-agent'
self.sniffer_name = 'sniff-port-agent'
self.data_port_id = '%s-%s' % (self.data_name, self.refdes)
self.command_port_id = '%s-%s' % (self.command_name, self.refdes)
self.sniffer_port_id = '%s-%s' % (self.sniffer_name, self.refdes)
self.router = Router()
self.connections = set()
self.clients = set()
self._register_loggers()
self._create_routes()
self._start_servers()
self._heartbeat()
self.num_connections = 0
log.msg('Base PortAgent initialization complete')
def _register_loggers(self):
self.data_logger = DailyLogFile('%s.datalog' % self.name, '.')
self.ascii_logger = DailyLogFile('%s.log' % self.name, '.')
self.router.register(EndpointType.DATALOGGER, self.data_logger)
self.router.register(EndpointType.LOGGER, self.ascii_logger)
def _create_routes(self):
# Register the logger and datalogger to receive all messages
self.router.add_route(PacketType.ALL, EndpointType.LOGGER, data_format=Format.ASCII)
self.router.add_route(PacketType.ALL, EndpointType.DATALOGGER, data_format=Format.PACKET)
# from DRIVER
self.router.add_route(PacketType.FROM_DRIVER, EndpointType.INSTRUMENT, data_format=Format.RAW)
# from INSTRUMENT
self.router.add_route(PacketType.FROM_INSTRUMENT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PICKLED_FROM_INSTRUMENT, EndpointType.CLIENT, data_format=Format.PACKET)
# from COMMAND SERVER
self.router.add_route(PacketType.PA_COMMAND, EndpointType.COMMAND_HANDLER, data_format=Format.PACKET)
# from PORT_AGENT
self.router.add_route(PacketType.PA_CONFIG, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_CONFIG, EndpointType.COMMAND, data_format=Format.RAW)
self.router.add_route(PacketType.PA_FAULT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_HEARTBEAT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS, EndpointType.COMMAND, data_format=Format.RAW)
# from COMMAND HANDLER
self.router.add_route(PacketType.DIGI_CMD, EndpointType.DIGI, data_format=Format.RAW)
# from DIGI
self.router.add_route(PacketType.DIGI_RSP, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.DIGI_RSP, EndpointType.COMMAND, data_format=Format.RAW)
@staticmethod
def done(response, caller=''):
log.msg(caller + 'http response: %s' % response.code)
def data_port_cb(self, port):
self.data_port = port.getHost().port
values = {
'ID': self.data_port_id,
'Name': self.data_name,
'Port': self.data_port,
'Check': {'TTL': '%ss' % self.ttl},
'Tags': [self.refdes]
}
put(self._agent + 'service/register', json.dumps(values)).addCallback(self.done, caller='data_port_cb: ')
log.msg('data_port_cb: port is', self.data_port)
def command_port_cb(self, port):
self.command_port = port.getHost().port
values = {
'ID': self.command_port_id,
'Name': self.command_name,
'Port': self.command_port,
'Check': {'TTL': '%ss' % self.ttl},
'Tags': [self.refdes]
}
put(self._agent + 'service/register', json.dumps(values)).addCallback(self.done, caller='command_port_cb: ')
log.msg('command_port_cb: port is', self.command_port)
def sniff_port_cb(self, port):
self.sniff_port = port.getHost().port
values = {
'ID': self.sniffer_port_id,
'Name': self.sniffer_name,
'Port': self.sniff_port,
'Check': {'TTL': '%ss' % self.ttl},
'Tags': [self.refdes]
}
put(self._agent + 'service/register', json.dumps(values)).addCallback(self.done, caller='sniff_port_cb: ')
log.msg('sniff_port_cb: port is', self.sniff_port)
def _start_servers(self):
self.data_endpoint = TCP4ServerEndpoint(reactor, self.data_port)
data_deferred = self.data_endpoint.listen(DataFactory(self, PacketType.FROM_DRIVER, EndpointType.CLIENT))
data_deferred.addCallback(self.data_port_cb)
self.command_endpoint = TCP4ServerEndpoint(reactor, self.command_port)
command_deferred = self.command_endpoint.listen(
CommandFactory(self, PacketType.PA_COMMAND, EndpointType.COMMAND))
command_deferred.addCallback(self.command_port_cb)
self.sniff_port = int(self.sniff_port)
self.sniff_endpoint = TCP4ServerEndpoint(reactor, self.sniff_port)
sniff_deferred = self.sniff_endpoint.listen(DataFactory(self, PacketType.UNKNOWN, EndpointType.LOGGER))
sniff_deferred.addCallback(self.sniff_port_cb)
def _heartbeat(self):
packets = Packet.create('HB', PacketType.PA_HEARTBEAT)
self.router.got_data(packets)
# Set TTL Check Status
check_string = self._agent + 'check/pass/service:'
get(check_string + self.data_port_id).addCallback(
self.done, caller='%s TTL check status: ' % self.data_port_id)
get(check_string + self.command_port_id).addCallback(
self.done, caller='%s TTL check status: ' % self.command_port_id)
get(check_string + self.sniffer_port_id).addCallback(
self.done, caller='%s TTL check status: ' % self.sniffer_port_id)
reactor.callLater(HEARTBEAT_INTERVAL, self._heartbeat)
def client_connected(self, connection):
log.msg('CLIENT CONNECTED FROM ', connection)
self.clients.add(connection)
def client_disconnected(self, connection):
self.clients.remove(connection)
log.msg('CLIENT DISCONNECTED FROM ', connection)
def instrument_connected(self, connection):
log.msg('CONNECTED TO ', connection)
self.connections.add(connection)
if len(self.connections) == self.num_connections:
self.router.got_data(Packet.create('CONNECTED', PacketType.PA_STATUS))
def instrument_disconnected(self, connection):
self.connections.remove(connection)
log.msg('DISCONNECTED FROM ', connection)
self.router.got_data(Packet.create('DISCONNECTED', PacketType.PA_STATUS))
def register_commands(self, command_protocol):
log.msg('PortAgent register commands for protocol: %s' % command_protocol)
command_protocol.register_command('get_state', self.get_state)
command_protocol.register_command('get_config', self.get_config)
command_protocol.register_command('get_version', self.get_version)
def get_state(self, *args):
log.msg('get_state: %r %d' % (self.connections, self.num_connections))
if len(self.connections) == self.num_connections:
return Packet.create('CONNECTED', PacketType.PA_STATUS)
return Packet.create('DISCONNECTED', PacketType.PA_STATUS)
def get_config(self, *args):
return Packet.create(json.dumps(self.config), PacketType.PA_CONFIG)
def get_version(self, *args):
return Packet.create(ooi_port_agent.__version__, PacketType.PA_CONFIG)
from webob import Request
from router import Router
from utils import controller
@controller
def hello(req):
if req.method == 'POST':
return 'Hello {}!'.format(req.params['name'])
elif req.method == 'GET':
return '''<form method="POST">
Your name: <input type="text" name="name">
<input type="submit">
</form>'''
hello_world = Router()
hello_world.add_route('/', controller=hello)
request = Request.blank('/')
# resp = request.get_response(hello_world)
# print(resp)
request.method = 'POST'
request.body = b'name=Gerardo'
resp = request.get_response(hello_world)
print(resp)
import wsgiref.validate
from router import Router
from request import Request
import controller
import config
router = Router()
router.add_route('/home', controller.home_controller)
router.add_route('/messages', controller.messages_controller)
router.add_route('/upload', controller.upload_controller)
router.add_route(config.STATIC_BASE_URI, controller.static_controller)
@wsgiref.validate.validator
def application(environ, start_response):
request = Request(environ)
route_callback = router.resolve(request.URI_PATH)
response = route_callback(request)
start_response(response.status, response.headers)
return [response.body]
class PortAgent(object):
_agent = 'http://localhost:8500/v1/agent/'
def __init__(self, config):
self.config = config
self.refdes = config.get('refdes', config['type'])
self.ttl = config['ttl']
self.num_connections = 0
self.disconnect_notification_id = None
self.router = Router(self)
self.stats_publisher = StatisticsPublisher()
self.stats_publisher.connect()
self.connections = set()
self.clients = set()
self._register_loggers()
self._create_routes()
self._start_servers()
self.get_consul_host()
heartbeat_task = task.LoopingCall(self._heartbeat)
heartbeat_task.start(interval=HEARTBEAT_INTERVAL)
log.msg('Base PortAgent initialization complete')
def _register_loggers(self):
"""
Create and register the binary and ascii loggers
:return:
"""
if not os.path.exists(CURRENTDIR):
os.makedirs(CURRENTDIR)
binary_name = '%s.datalog' % self.refdes
ascii_name = '%s.log' % self.refdes
self.data_logger = ArchivingDailyLogFile(binary_name, CURRENTDIR, os.path.join(ARCHIVEDIR, self.refdes))
self.ascii_logger = ArchivingDailyLogFile(ascii_name, CURRENTDIR, os.path.join(DISCARDDIR, self.refdes))
self.router.register(EndpointType.DATALOGGER, self.data_logger)
self.router.register(EndpointType.LOGGER, self.ascii_logger)
def _create_routes(self):
"""
Default routes for all port agent types
This provides a mapping from packet type to endpoint type
:return:
"""
# Register the logger and datalogger to receive all messages
self.router.add_route(PacketType.ALL, EndpointType.LOGGER, data_format=Format.ASCII)
self.router.add_route(PacketType.ALL, EndpointType.DATALOGGER, data_format=Format.PACKET)
# from DRIVER
self.router.add_route(PacketType.FROM_DRIVER, EndpointType.INSTRUMENT, data_format=Format.RAW)
# from INSTRUMENT
self.router.add_route(PacketType.FROM_INSTRUMENT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.FROM_INSTRUMENT, EndpointType.RAW, data_format=Format.RAW)
self.router.add_route(PacketType.PICKLED_FROM_INSTRUMENT, EndpointType.CLIENT, data_format=Format.PACKET)
# from COMMAND SERVER
self.router.add_route(PacketType.PA_COMMAND, EndpointType.COMMAND_HANDLER, data_format=Format.PACKET)
# from PORT_AGENT
self.router.add_route(PacketType.PA_CONFIG, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_CONFIG, EndpointType.COMMAND, data_format=Format.RAW)
self.router.add_route(PacketType.PA_FAULT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_HEARTBEAT, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.PA_STATUS, EndpointType.COMMAND, data_format=Format.RAW)
# from COMMAND HANDLER
self.router.add_route(PacketType.DIGI_CMD, EndpointType.DIGI, data_format=Format.RAW)
# from DIGI
self.router.add_route(PacketType.DIGI_RSP, EndpointType.CLIENT, data_format=Format.PACKET)
self.router.add_route(PacketType.DIGI_RSP, EndpointType.COMMAND, data_format=Format.RAW)
def get_service_name_id(self, service):
"""
Given a service name, compute the fully qualified service name and id for this agent
:param service: service name
:return:
"""
base_id = 'port-agent'
if service != 'data':
name = service + '-' + base_id
else:
name = base_id
service_id = name + '-' + self.refdes
return name, service_id
@inlineCallbacks
def got_port_cb(self, service, port_obj):
"""
Called after a port is successfully bound by the server.
Register the service with Consul.
:param service: service to be registered
:param port_obj: port object containing the IP address and port
:return:
"""
ipaddr = port_obj.getHost()
port = ipaddr.port
self.config['ports'][service] = port
name, service_id = self.get_service_name_id(service)
values = {
'ID': service_id,
'Name': name,
'Port': port,
'Check': {'TTL': '%ss' % self.ttl},
'Tags': [self.refdes]
}
response = yield put(self._agent + 'service/register', json.dumps(values))
if response.code != httplib.OK:
log.msg(service + 'http response: %s' % response.code)
def _start_servers(self):
"""
Start the base port agent servers:
DATA
COMMAND
SNIFF
:return:
"""
self.data_endpoint = TCP4ServerEndpoint(reactor, 0)
self.data_endpoint.listen(
DataFactory(self, PacketType.FROM_DRIVER, EndpointType.CLIENT)
).addCallback(partial(self.got_port_cb, 'data'))
self.command_endpoint = TCP4ServerEndpoint(reactor, 0)
self.command_endpoint.listen(
CommandFactory(self, PacketType.PA_COMMAND, EndpointType.COMMAND)
).addCallback(partial(self.got_port_cb, 'command'))
self.sniff_endpoint = TCP4ServerEndpoint(reactor, 0)
self.sniff_endpoint.listen(
DataFactory(self, PacketType.UNKNOWN, EndpointType.LOGGER)
).addCallback(partial(self.got_port_cb, 'sniff'))
@inlineCallbacks
def _heartbeat(self):
"""
Send a heartbeat packet and set our Consul status to PASS
:return:
"""
packets = Packet.create('HB', PacketType.PA_HEARTBEAT)
self.router.got_data(packets)
# Set TTL Check Status
check_string = self._agent + 'check/pass/service:'
for service in self.config['ports']:
name, service_id = self.get_service_name_id(service)
yield get(check_string + service_id)
@inlineCallbacks
def get_consul_host(self):
"""
Fetch our host information from Consul
:return:
"""
url = self._agent + 'self'
try:
response = yield get(url)
body = yield readBody(response)
data = json.loads(body)
host = data['Member']['Addr']
self.config['host'] = host
except (ConnectionRefusedError, KeyError) as e:
log.msg('Unable to retrieve host address from consul: ', e)
reactor.callLater(CONSUL_RETRY_INTERVAL, self.get_consul_host)
def client_connected(self, connection):
"""
Log an incoming client connection
:param connection: connection object
:return:
"""
log.msg('CLIENT CONNECTED FROM ', connection)
self.clients.add(connection)
def client_disconnected(self, connection):
"""
Log a client disconnect
:param connection: connection object
:return:
"""
self.clients.remove(connection)
log.msg('CLIENT DISCONNECTED FROM ', connection)
def instrument_connected(self, connection):
"""
Log a successful instrument connection,
notifying the driver if the target number of connections is reached.
:param connection: connection object
:return:
"""
log.msg('CONNECTED TO ', connection)
self.connections.add(connection)
if len(self.connections) == self.num_connections:
# We are now CONNECTED
# Cancel any pending DISCONNECTED notification
if self.disconnect_notification_id is not None:
try:
self.disconnect_notification_id.cancel()
except AlreadyCalled:
pass
finally:
self.disconnect_notification_id = None
# Notify driver we are CONNECTED
self.router.got_data(Packet.create('CONNECTED', PacketType.PA_STATUS))
def instrument_disconnected(self, connection):
"""
Log a instrument disconnect,
notifying the driver after INSTRUMENT_DISCONNECT_FORGIVENESS_INTERVAL
if the target number of connections is not reached.
:param connection: connection object
:return:
"""
self.connections.remove(connection)
log.msg('DISCONNECTED FROM ', connection)
if self.disconnect_notification_id is None:
self.disconnect_notification_id = reactor.callLater(INSTRUMENT_DISCONNECT_FORGIVENESS_INTERVAL,
self.notify_disconnected)
def notify_disconnected(self):
"""
Send a disconnect notification to the instrument driver
:return:
"""
log.msg('Notifying driver we are DISCONNECTED')
self.disconnect_notification_id = None
self.router.got_data(Packet.create('DISCONNECTED', PacketType.PA_STATUS))
def register_commands(self, command_protocol):
"""
Register the available commands for this agent on a new CommandProtocol object
:param command_protocol: CommandProtocol object
:return:
"""
log.msg('PortAgent register commands for protocol: %s' % command_protocol)
command_protocol.register_command('get_state', self.get_state)
command_protocol.register_command('get_config', self.get_config)
command_protocol.register_command('get_version', self.get_version)
def get_state(self, *args):
"""
Respond to an incoming get_state request
:param args: not applicable to this command
:return:
"""
log.msg('get_state: %r %d' % (self.connections, self.num_connections))
if len(self.connections) == self.num_connections:
return Packet.create('CONNECTED', PacketType.PA_STATUS)
return Packet.create('DISCONNECTED', PacketType.PA_STATUS)
def get_config(self, *args):
"""
Respond to an incoming get_config request
:param args: not applicable to this command
:return:
"""
return Packet.create(json.dumps(self.config), PacketType.PA_CONFIG)
# noinspection PyMethodMayBeStatic
def get_version(self, *args):
"""
Respond to an incoming get_version request
:param args: not applicable to this command
:return:
"""
return Packet.create(ooi_port_agent.__version__, PacketType.PA_CONFIG)
import cgi
import os
import wsgiref.validate
from conteroller import index
from router import Router
from utils import parse_http_x_www_form_urlencoded_post_data, \
parse_http_get_data, parse_http_headers, \
parse_http_content_type, parse_http_uri
DEBUG = True
STATIC_URL = '/static/'
STATIC_ROOT = 'data/'
router = Router()
router.add_route('/', index)
@wsgiref.validate.validator
def application(environ, start_response):
# https://www.python.org/dev/peps/pep-3333/#environ-variables
REQUEST_METHOD = environ['REQUEST_METHOD']
CONTENT_TYPE, CONTENT_TYPE_KWARGS = parse_http_content_type(environ)
SERVER_PROTOCOL = environ['SERVER_PROTOCOL']
HEADERS = parse_http_headers(environ)
URI_PATH = environ['PATH_INFO']
URI_QUERY = environ['QUERY_STRING']
URI = parse_http_uri(environ)
POST = cgi.FieldStorage(fp=environ['wsgi.input'],
environ=environ,
keep_blank_values=True)
