def build_service_map(self):
"""
Adds all known service definitions to service registry.
@todo: May be a bit fragile due to using BaseService.__subclasses__
"""
for cls in BaseService.__subclasses__():
assert hasattr(
cls, 'name'
), 'Service class must define name value. Service class in error: %s' % cls
if cls.name:
self.services_by_name[cls.name] = cls
self.add_servicedef_entry(cls.name, "base", cls)
interfaces = list(implementedBy(cls))
if interfaces:
self.add_servicedef_entry(cls.name, "interface",
interfaces[0])
if cls.__name__.startswith("Base"):
try:
client = "%s.%sProcessClient" % (cls.__module__,
cls.__name__[4:])
self.add_servicedef_entry(cls.name, "client",
named_any(client))
sclient = "%s.%sClient" % (cls.__module__,
cls.__name__[4:])
self.add_servicedef_entry(cls.name, "simple_client",
named_any(sclient))
except Exception, ex:
log.warning("Cannot find client for service %s" %
(cls.name))
def _write(self, data):
# write data to tcp client
log.debug("TcpServer._write(): data = " + str(data))
if self.connection_socket:
self.activity_seen = True;
MSGLEN = len(data)
total_sent = 0
while total_sent < MSGLEN:
sent = self.connection_socket.send(data[total_sent:])
if sent == 0:
raise RuntimeError("socket connection broken")
total_sent = total_sent + sent
else:
log.warning("TcpServer._write(): no connection yet, can not write data")
def load_service_mods(cls, path):
import pkgutil
import string
mod_prefix = string.replace(path, "/", ".")
for mod_imp, mod_name, is_pkg in pkgutil.iter_modules([path]):
if is_pkg:
cls.load_service_mods(path + "/" + mod_name)
else:
mod_qual = "%s.%s" % (mod_prefix, mod_name)
#print "Import", mod_qual
try:
named_any(mod_qual)
except Exception, ex:
log.warning("Import module '%s' failed: %s" % (mod_qual, ex))
def load_service_mods(cls, path):
import pkgutil
import string
mod_prefix = string.replace(path, "/", ".")
for mod_imp, mod_name, is_pkg in pkgutil.iter_modules([path]):
if is_pkg:
cls.load_service_mods(path + "/" + mod_name)
else:
mod_qual = "%s.%s" % (mod_prefix, mod_name)
#print "Import", mod_qual
try:
named_any(mod_qual)
except Exception, ex:
log.warning("Import module '%s' failed: %s" %
(mod_qual, ex))
def build_service_map(self):
"""
Adds all known service definitions to service registry.
@todo: May be a bit fragile due to using BaseService.__subclasses__
"""
for cls in BaseService.__subclasses__():
assert hasattr(cls, 'name'), 'Service class must define name value. Service class in error: %s' % cls
if cls.name:
self.services_by_name[cls.name] = cls
self.add_servicedef_entry(cls.name, "base", cls)
interfaces = list(implementedBy(cls))
if interfaces:
self.add_servicedef_entry(cls.name, "interface", interfaces[0])
if cls.__name__.startswith("Base"):
try:
client = "%s.%sProcessClient" % (cls.__module__, cls.__name__[4:])
self.add_servicedef_entry(cls.name, "client", named_any(client))
sclient = "%s.%sClient" % (cls.__module__, cls.__name__[4:])
self.add_servicedef_entry(cls.name, "simple_client", named_any(sclient))
except Exception, ex:
log.warning("Cannot find client for service %s" % (cls.name))
def add_servicedef_entry(self, name, key, value, append=False):
if not name:
#log.warning("No name for key=%s, value=%s" % (key, value))
return
if not name in self.services:
svc_def = IonServiceDefinition(name)
self.services[name] = svc_def
else:
svc_def = self.services[name]
oldvalue = getattr(svc_def, key, None)
if oldvalue is not None:
if append:
assert type(oldvalue) is list, "Cannot append to non-list: %s" % oldvalue
oldvalue.append(value)
else:
log.warning("Service %s, key=%s exists. Old=%s, new=%s" % (name, key, getattr(svc_def, key), value))
if not append:
setattr(svc_def, key, value)
def __init__(self,
direct_access_type=None,
input_callback=None,
ip_address=None,
session_timeout=None,
inactivity_timeout=None):
log.debug("DirectAccessServer.__init__()")
if not direct_access_type:
log.warning("DirectAccessServer.__init__(): direct access type not specified")
raise ServerError("DirectAccessServer.__init__(): direct access type not specified")
if not input_callback:
log.warning("DirectAccessServer.__init__(): callback not specified")
raise ServerError("DirectAccessServer.__init__(): callback not specified")
if not ip_address:
log.warning("DirectAccessServer.__init__(): IP address not specified")
raise ServerError("DirectAccessServer.__init__(): IP address not specified")
if not session_timeout:
log.warning("DirectAccessServer.__init__(): session timeout not specified")
raise ServerError("DirectAccessServer.__init__(): session timeout not specified")
if not inactivity_timeout:
log.warning("DirectAccessServer.__init__(): inactivity timeout not specified")
raise ServerError("DirectAccessServer.__init__(): inactivity timeout not specified")
# start the correct server based on direct_access_type
if direct_access_type == DirectAccessTypes.telnet:
self.server = TelnetServer(input_callback, ip_address)
elif direct_access_type == DirectAccessTypes.vsp:
self.server = SerialServer(input_callback, ip_address)
else:
raise ServerError("DirectAccessServer.__init__(): Unsupported direct access type")
log.debug("DirectAccessServer.__init__(): starting timer greenlet")
self.timer = gevent.spawn(self._timer_greenlet,
session_timeout=session_timeout,
inactivity_timeout=inactivity_timeout)
def add_servicedef_entry(self, name, key, value, append=False):
if not name:
#log.warning("No name for key=%s, value=%s" % (key, value))
return
if not name in self.services:
svc_def = IonServiceDefinition(name)
self.services[name] = svc_def
else:
svc_def = self.services[name]
oldvalue = getattr(svc_def, key, None)
if oldvalue is not None:
if append:
assert type(
oldvalue
) is list, "Cannot append to non-list: %s" % oldvalue
oldvalue.append(value)
else:
log.warning("Service %s, key=%s exists. Old=%s, new=%s" %
(name, key, getattr(svc_def, key), value))
if not append:
setattr(svc_def, key, value)
def __init__(self, input_callback=None, ip_address=None):
log.debug("TcpServer.__init__(): IP address = %s" %ip_address)
# save callback if specified
if not input_callback:
log.warning("TcpServer.__init__(): callback not specified")
raise ServerError("TcpServer.__init__(): callback not specified")
self.parent_input_callback = input_callback
# save ip address if specified
if not ip_address:
log.warning("TcpServer.__init__(): IP address not specified")
raise ServerError("TcpServer.__init__(): IP address not specified")
self.ip_address = ip_address
# search for an available port
self.port = self.PORT_RANGE_LOWER
# create a TCP socket
self.server_socket = gevent.socket.socket()
self.server_socket.allow_reuse_address = True
while True:
try:
log.debug("trying to bind to port %s on %s" %(str(self.port), self.ip_address))
self.server_socket.bind((self.ip_address, self.port))
break
except Exception as ex:
log.debug("exception caught for socket bind:" + str(ex))
self.port = self.port + 1
if self.port > self.PORT_RANGE_UPPER:
log.warning("TcpServer.__init__(): no available ports for server")
raise ServerError("TcpServer.__init__(): no available ports")
# create token for login verification of telnet
self.token = str(uuid.uuid4()).upper()
log.debug("TcpServer.__init__(): starting server greenlet")
self.server = gevent.spawn(self._server_greenlet)
