def makeService(self, options):
rpc = TriggerXMLRPCServer(allowNone=True, useDateTime=True)
xmlrpc.addIntrospection(rpc)
site_factory = server.Site(rpc)
# Try to setup SSL
if ssl is not None:
ctx = ssl.DefaultOpenSSLContextFactory(options['ssl-keyfile'],
options['ssl-certfile'])
xmlrpc_service = SSLServer(int(options['port']), site_factory, ctx)
# Or fallback to clear-text =(
else:
xmlrpc_service = TCPServer(int(options['port']), site_factory)
# SSH Manhole service
console_service = makeConsoleService(
{
'sshPort': 'tcp:%s' % options['ssh-port'],
'telnetPort': None,
'passwd': options['ssh-users'],
'namespace': {
'service': rpc,
'rebuild': rebuild,
'factory': site_factory,
}
}
)
svc = MultiService()
xmlrpc_service.setServiceParent(svc)
console_service.setServiceParent(svc)
return svc
def initXMLRPCServer():
""" Start the XML RPC server """
ensureXMLRPCOptions()
if Hellanzb.XMLRPC_PORT == None:
warn('Hellanzb.XMLRPC_PORT = None, not starting the XML-RPC server')
return
hxmlrpcs = HellaXMLRPCServer()
xmlrpc.addIntrospection(hxmlrpcs)
SECURE = True
try:
if SECURE:
secure = HtPasswdWrapper(hxmlrpcs, 'hellanzb',
Hellanzb.XMLRPC_PASSWORD,
'hellanzb XML RPC')
reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(secure))
else:
reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(hxmlrpcs))
except CannotListenError, cle:
error(str(cle))
raise FatalError(
'Cannot bind to XML RPC port, is another hellanzb queue daemon already running?'
)
def generate_manager_server(manager):
'''Generate a wrapping XMLRPC server class for a given type'''
class ManagerXMLRPCServer(xmlrpc.XMLRPC):
_ebRender = ebRender
ManagerXMLRPCServer.__name__ = '%sXMLRPCServer' % \
manager.__class__.__name__
ManagerXMLRPCServer.__doc__ = 'XMLRPC Server wrapper for %s' % \
manager.__class__.__name__
manager_server = ManagerXMLRPCServer()
#Now add instancemethods for all exposed methods
for attrname in dir(manager):
attr = getattr(manager, attrname)
if getattr(attr, XMLRPC_EXPOSE, False):
wrapped = generate_wrapped_method(attr, attrname)
if getattr(attr, XMLRPC_REQUIRE_AUTHENTICATION, False):
setattr(wrapped, XMLRPC_REQUIRE_AUTHENTICATION, True)
wrapped_name = wrapped.__name__
wrapped = new.instancemethod(wrapped, manager_server, manager_server.__class__)
setattr(manager_server, wrapped_name, wrapped)
xmlrpc.addIntrospection(manager_server)
return manager_server
def start():
# Initiliaze MyApp
app = PlotServerApp(False)
# Make wx application twisted aware
# Have to run "wxreactor.install()" on top before
reactor.registerWxApp(app)
# Make a XML-RPC Server listening on a port
port = common.defaultPort
# Add introspection so doc strings will show up on client side
# (TODO: Adding introspection doesn't seem to work)
xmlrpc.addIntrospection(app)
root = resource.Resource()
root.putChild('RPC2', app)
#root.putChild('SOAP', app)
# TODO: make it possible to pass in the interface to use, rather than
# restricting it unconditionally to localhost
reactor.listenTCP(port, server.Site(root), interface='127.0.0.1')
# Start both reactor parts (wx MainLoop and XML-RPC server)
reactor.run()
# restore stdout/stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
def generate_manager_server(manager):
'''Generate a wrapping XMLRPC server class for a given type'''
class ManagerXMLRPCServer(xmlrpc.XMLRPC):
_ebRender = ebRender
ManagerXMLRPCServer.__name__ = '%sXMLRPCServer' % \
manager.__class__.__name__
ManagerXMLRPCServer.__doc__ = 'XMLRPC Server wrapper for %s' % \
manager.__class__.__name__
manager_server = ManagerXMLRPCServer()
#Now add instancemethods for all exposed methods
for attrname in dir(manager):
attr = getattr(manager, attrname)
if getattr(attr, XMLRPC_EXPOSE, False):
wrapped = generate_wrapped_method(attr, attrname)
if getattr(attr, XMLRPC_REQUIRE_AUTHENTICATION, False):
setattr(wrapped, XMLRPC_REQUIRE_AUTHENTICATION, True)
wrapped_name = wrapped.__name__
wrapped = new.instancemethod(wrapped, manager_server,
manager_server.__class__)
setattr(manager_server, wrapped_name, wrapped)
xmlrpc.addIntrospection(manager_server)
return manager_server
def setUp(self):
xmlrpc = Test()
addIntrospection(xmlrpc)
self.p = reactor.listenTCP(0,
server.Site(xmlrpc),
interface="127.0.0.1")
self.port = self.p.getHost().port
def __init__(self, main, *args, **kwargs):
self.main = main
xmlrpc.XMLRPC.__init__(self, *args, **kwargs)
self.putSubHandler('sync', RHTSSync(main))
self.putSubHandler('workflows', RHTSWorkflows(main))
self.putSubHandler('watchdog', RHTSWatchdog(main))
self.putSubHandler('results', RHTSResults(main))
self.putSubHandler('test', RHTSTest(main))
xmlrpc.addIntrospection(self)
def __init__(self, main, *args, **kwargs):
self.main = main
xmlrpc.XMLRPC.__init__(self, *args, **kwargs)
self.putSubHandler('sync', RHTSSync(main))
self.putSubHandler('workflows', RHTSWorkflows(main))
self.putSubHandler('watchdog', RHTSWatchdog(main))
self.putSubHandler('results', RHTSResults(main))
self.putSubHandler('test', RHTSTest(main))
xmlrpc.addIntrospection(self)
def serve(main, port=3880):
from twisted.internet import reactor
xmlrpc.addIntrospection(main)
web = static.File(params.webdir)
web.putChild('RPC', main)
site = server.Site(web)
addListeners(reactor, site, main, port=port, logf=main.log.info)
# reactor.run(installSignalHandlers=1)
p = multiprocessing.Process(target=reactor.run)
p.daemon = main._daemon_acquisition_process
return p, main
def main(port=4118, parentpid=None):
import os
os.environ['NO_GAIL'] = '1'
os.environ['NO_AT_BRIDGE'] = '1'
import twisted
gtkVersion = None
try:
from gi.repository import Gtk
gtkVersion = Gtk._version
except:
pass
if not gtkVersion or gtkVersion == '2.0':
# As per Ubuntu 11.10, twisted glib2reactor
# works with gtk2, which fails with gtk3
from twisted.internet import glib2reactor
glib2reactor.install()
elif gtkVersion >= '3.0':
try:
# Exist in Ubuntu 12.04, but not on
# Ubuntu 11.10 / Fedora 16
from twisted.internet import gtk3reactor
gtk3reactor.install()
except:
pass
from twisted.internet import reactor
from twisted.web import server, xmlrpc
from xmlrpc_daemon import XMLRPCLdtpd
import twisted.internet
import socket
import pyatspi
import traceback
_ldtp_debug = os.environ.get('LDTP_DEBUG', None)
_ldtp_debug_file = os.environ.get('LDTP_DEBUG_FILE', None)
try:
pyatspi.setCacheLevel(pyatspi.CACHE_PROPERTIES)
r = XMLRPCLdtpd()
xmlrpc.addIntrospection(r)
if parentpid:
reactor.callWhenRunning(SignalParent(parentpid).send_later)
reactor.listenTCP(port, server.Site(r))
reactor.run()
except twisted.internet.error.CannotListenError:
if _ldtp_debug:
print(traceback.format_exc())
except socket.error:
if _ldtp_debug:
print(traceback.format_exc())
if _ldtp_debug_file:
with open(_ldtp_debug_file, "a") as fp:
fp.write(traceback.format_exc())
def setup(port):
root = resource.Resource()
rpcInterface = XmlRpcInterface()
xmlrpc.addIntrospection(rpcInterface)
root.putChild('RPC2', rpcInterface)
root.putChild('peers', PeerLister())
root.putChild('list', ListQuery())
root.putChild('get', GetQuery())
#root.putChild('all', MassQuery())
factory = server.Site(root)
endpoint = TCP4ServerEndpoint(reactor, port)
endpoint.listen(factory)
def main(port=4118, parentpid=None):
import os
os.environ['NO_GAIL'] = '1'
os.environ['NO_AT_BRIDGE'] = '1'
import twisted
gtkVersion = None
try:
from gi.repository import Gtk
gtkVersion = Gtk._version
except:
pass
if not gtkVersion or gtkVersion == '2.0':
# As per Ubuntu 11.10, twisted glib2reactor
# works with gtk2, which fails with gtk3
from twisted.internet import glib2reactor
glib2reactor.install()
elif gtkVersion >= '3.0':
try:
# Exist in Ubuntu 12.04, but not on
# Ubuntu 11.10 / Fedora 16
from twisted.internet import gtk3reactor
gtk3reactor.install()
except:
pass
from twisted.internet import reactor
from twisted.web import server, xmlrpc
from xmlrpc_daemon import XMLRPCLdtpd
import twisted.internet
import socket
import pyatspi
import traceback
_ldtp_debug = os.environ.get('LDTP_DEBUG', None)
_ldtp_debug_file = os.environ.get('LDTP_DEBUG_FILE', None)
try:
pyatspi.setCacheLevel(pyatspi.CACHE_PROPERTIES)
r = XMLRPCLdtpd()
xmlrpc.addIntrospection(r)
if parentpid:
reactor.callWhenRunning(SignalParent(parentpid).send_later)
reactor.listenTCP(port, server.Site(r))
reactor.run()
except twisted.internet.error.CannotListenError:
if _ldtp_debug:
print(traceback.format_exc())
except socket.error:
if _ldtp_debug:
print(traceback.format_exc())
if _ldtp_debug_file:
with open(_ldtp_debug_file, "a") as fp:
fp.write(traceback.format_exc())
def _register_server(self):
'''Register the server on the Twisted reactor
This method is split-up for unit testing sake.
'''
root_server = RootServer(
authenticationHandler=self._authentication_handler)
xmlrpc.addIntrospection(root_server)
#Create all endpoints
for endpoint, manager_server in self._managers.itervalues():
root_server.putSubHandler(endpoint, manager_server)
#Run reactor
port = reactor.listenTCP(self._port, server.Site(root_server),
interface=self._interface)
return self._interface, port
def test_listMethods(self):
"""
A subclass of L{XMLRPC} can override C{listProcedures} to define
Overriding listProcedures should prevent introspection from being
broken.
"""
resource = TestListProcedures()
addIntrospection(resource)
self.createServer(resource)
d = self.proxy.callRemote("system.listMethods")
def listed(procedures):
# The list will also include other introspection procedures added by
# addIntrospection. We just want to see "foo" from our customized
# listProcedures.
self.assertIn('foo', procedures)
d.addCallback(listed)
return d
def makeService(self, options):
rpc = TriggerXMLRPCServer(allowNone=True, useDateTime=True)
xmlrpc.addIntrospection(rpc)
site_factory = server.Site(rpc)
# Try to setup SSL
if ssl is not None:
ctx = ssl.DefaultOpenSSLContextFactory(options['ssl-keyfile'],
options['ssl-certfile'])
xmlrpc_service = SSLServer(int(options['port']),
site_factory,
ctx,
interface=options['listen-address'])
# Or fallback to clear-text =(
else:
xmlrpc_service = TCPServer(int(options['port']),
site_factory,
interface=options['listen-address'])
# SSH Manhole service
console_service = makeConsoleService({
'sshPort':
'tcp:%s:interface=%s' %
(options['ssh-port'], options['listen-address']),
'sshKeyDir':
options['ssh-keydir'],
'sshKeyName':
options['ssh-keyname'],
'sshKeySize':
options['ssh-keysize'],
'telnetPort':
None,
'passwd':
options['ssh-users'],
'namespace': {
'service': rpc,
'rebuild': rebuild,
'factory': site_factory,
}
})
svc = MultiService()
xmlrpc_service.setServiceParent(svc)
console_service.setServiceParent(svc)
return svc
def main():
"""To daemonize as a twistd plugin! Except this doesn't work and these"""
from twisted.application.internet import TCPServer, SSLServer
from twisted.application.service import Application
from twisted.internet import ssl
rpc = TriggerXMLRPCServer()
xmlrpc.addIntrospection(rpc)
server_factory = server.Site(rpc)
application = Application('trigger_xmlrpc')
#xmlrpc_service = TCPServer(8000, server_factory)
ctx = ssl.DefaultOpenSSLContextFactory('server.key', 'cacert.pem')
xmlrpc_service = SSLServer(8000, server_factory, ctx)
xmlrpc_service.setServiceParent(application)
return application
def _register_server(self):
'''Register the server on the Twisted reactor
This method is split-up for unit testing sake.
'''
root_server = RootServer(
authenticationHandler=self._authentication_handler)
xmlrpc.addIntrospection(root_server)
#Create all endpoints
for endpoint, manager_server in self._managers.itervalues():
root_server.putSubHandler(endpoint, manager_server)
#Run reactor
port = reactor.listenTCP(self._port,
server.Site(root_server),
interface=self._interface)
return self._interface, port
def __init__(self, nagios_cfg):
xmlrpc.XMLRPC.__init__(self)
xmlrpc.addIntrospection(self)
cfg = nagios_objects.ConfigParser(nagios_cfg,
('object_cache_file', 'command_file',
'status_file', 'check_result_path'))
# object types we care about:
types = ('host', 'service', 'hostgroup', 'servicegroup')
rawobjs = nagios_objects.ObjectParser(cfg['object_cache_file'], types)
self._objects = dict([(x,{}) for x in types])
for obj in rawobjs['host']:
self._objects['host'][obj['host_name']] = obj
for obj in rawobjs['service']:
host_name = obj['host_name']
description = obj['service_description']
if host_name not in self._objects['service']:
self._objects['service'][host_name] = {}
self._objects['service'][host_name][description] = obj
for obj in rawobjs['hostgroup']:
if obj.get('members', None):
obj['members'] = obj['members'].split(',')
else:
obj['members'] = []
self._objects['hostgroup'][obj['hostgroup_name']] = obj
for obj in rawobjs['servicegroup']:
members = []
if obj.get('members', None):
members_list = obj['members'].split(',')
for i in xrange(0, len(members_list), 2):
members.append((members_list[i], members_list[i+1]))
obj['members'] = members
self._objects['servicegroup'][obj['servicegroup_name']] = obj
spool = spool_path(cfg['check_result_path'], 'xmlrpc')
self._cmdobj = NagiosCommander(cfg['command_file'], spool)
self._status_file = cfg['status_file']
def setMain(opt):
"""Create a MainServer class based on `opt` options"""
instanceName = opt['-n']
if not instanceName:
instanceName = ''
print 'setMain', opt
# Determine logfile path into datadir
log_filename = params.log_filename if not opt.has_key(
'-d') else os.path.join(opt['-d'], 'log', 'misura.log')
params.log_filename = log_filename
# Start the object sharing process
share.init(connect=False, log_filename=log_filename)
# Instantiate mainserver class
main = MainServer(instanceName=instanceName,
port=opt['-p'],
confdir=opt['-c'],
datadir=opt['-d'],
plug=opt['-e'],
manager=share.manager)
xmlrpc.addIntrospection(main)
mimetypes = {'.h5': 'application/x-hdf;subtype=bag'}
static.File.contentTypes.update(mimetypes)
web = static.File(params.webdir)
web.putChild('RPC', main)
web.putChild('data', static.File(params.datadir))
web.putChild('conf', static.File(params.confdir))
# StreamServer
mdir = MisuraDirectory(main)
web.putChild('stream', mdir)
# Further reading about auth stuff:
# http://www.tsheffler.com/blog/?p=502
realm = MisuraRealm()
realm.resource = web
# TODO: use also for FTP!
checker = UsersChecker(main.users)
portal = Portal(realm, [checker])
cred_methods = (DigestCredentialFactory("md5", "MISURA"),
BasicCredentialFactory('MISURA'))
wrapper = HTTPAuthSessionWrapper(portal, cred_methods)
site = server.Site(wrapper)
return main, web, site
def initXMLRPCServer():
""" Start the XML RPC server """
ensureXMLRPCOptions()
if Hellanzb.XMLRPC_PORT == None:
warn('Hellanzb.XMLRPC_PORT = None, not starting the XML-RPC server')
return
hxmlrpcs = HellaXMLRPCServer()
xmlrpc.addIntrospection(hxmlrpcs)
SECURE = True
try:
if SECURE:
secure = HtPasswdWrapper(hxmlrpcs, 'hellanzb', Hellanzb.XMLRPC_PASSWORD, 'hellanzb XML RPC')
reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(secure))
else:
reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(hxmlrpcs))
except CannotListenError, cle:
error(str(cle))
raise FatalError('Cannot bind to XML RPC port, is another hellanzb queue daemon already running?')
def run_siptrackd_twisted(listen_port, ssl_port,
ssl_private_key, ssl_certificate, storage, reload_interval,
searcher):
log.msg('Creating object store')
object_store = siptrackdlib.ObjectStore(storage, searcher = searcher)
session_handler = sessions.SessionHandler()
log.msg('Creating rpc interface')
siptrackd_rpc = SiptrackdRPC(object_store, session_handler)
xmlrpc.addIntrospection(siptrackd_rpc)
view_rpc = view.ViewRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('view', view_rpc)
view_tree_rpc = view.ViewTreeRPC(object_store, session_handler)
view_rpc.putSubHandler('tree', view_tree_rpc)
counter_rpc = counter.CounterRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('counter', counter_rpc)
counter_loop_rpc = counter.CounterLoopRPC(object_store, session_handler)
counter_rpc.putSubHandler('loop', counter_loop_rpc)
user_rpc = user.UserRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('user', user_rpc)
user_local_rpc = user.UserLocalRPC(object_store, session_handler)
user_rpc.putSubHandler('local', user_local_rpc)
user_ldap_rpc = user.UserLDAPRPC(object_store, session_handler)
user_rpc.putSubHandler('ldap', user_ldap_rpc)
user_active_directory_rpc = user.UserActiveDirectoryRPC(object_store, session_handler)
user_rpc.putSubHandler('activedirectory', user_active_directory_rpc)
user_rpc.putSubHandler('ad', user_active_directory_rpc)
user_manager_rpc = user.UserManagerRPC(object_store, session_handler)
user_rpc.putSubHandler('manager', user_manager_rpc)
user_manager_local_rpc = user.UserManagerLocalRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('local', user_manager_local_rpc)
user_manager_ldap_rpc = user.UserManagerLDAPRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('ldap', user_manager_ldap_rpc)
user_manager_active_directory_rpc = user.UserManagerActiveDirectoryRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('activedirectory', user_manager_active_directory_rpc)
user_manager_rpc.putSubHandler('ad', user_manager_active_directory_rpc)
user_group_rpc = user.UserGroupRPC(object_store, session_handler)
user_rpc.putSubHandler('group', user_group_rpc)
user_group_ldap_rpc = user.UserGroupLDAPRPC(object_store, session_handler)
user_group_rpc.putSubHandler('ldap', user_group_ldap_rpc)
user_group_active_directory_rpc = user.UserGroupActiveDirectoryRPC(object_store, session_handler)
user_group_rpc.putSubHandler('activedirectory', user_group_active_directory_rpc)
user_group_rpc.putSubHandler('ad', user_group_active_directory_rpc)
device_rpc = device.DeviceRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('device', device_rpc)
device_tree_rpc = device.DeviceTreeRPC(object_store, session_handler)
device_rpc.putSubHandler('tree', device_tree_rpc)
device_category_rpc = device.DeviceCategoryRPC(object_store, session_handler)
device_rpc.putSubHandler('category', device_category_rpc)
device_config_rpc = deviceconfig.DeviceConfigRPC(object_store, session_handler)
device_rpc.putSubHandler('config', device_config_rpc)
device_config_template_rpc = deviceconfig.DeviceConfigTemplateRPC(object_store, session_handler)
device_config_rpc.putSubHandler('template', device_config_template_rpc)
password_rpc = password.PasswordRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('password', password_rpc)
password_key_rpc = password.PasswordKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('key', password_key_rpc)
password_tree_rpc = password.PasswordTreeRPC(object_store, session_handler)
password_rpc.putSubHandler('tree', password_tree_rpc)
password_category_rpc = password.PasswordCategoryRPC(object_store, session_handler)
password_rpc.putSubHandler('category', password_category_rpc)
sub_key_rpc = password.SubKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('subkey', sub_key_rpc)
network_rpc = network.NetworkRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('network', network_rpc)
network_tree_rpc = network.NetworkTreeRPC(object_store, session_handler)
network_rpc.putSubHandler('tree', network_tree_rpc)
network_ipv4_rpc = network.NetworkIPV4RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv4', network_ipv4_rpc)
network_range_rpc = network.NetworkRangeRPC(object_store, session_handler)
network_rpc.putSubHandler('range', network_range_rpc)
network_range_ipv4_rpc = network.NetworkRangeIPV4RPC(object_store, session_handler)
network_range_rpc.putSubHandler('ipv4', network_range_ipv4_rpc)
network_ipv6_rpc = network.NetworkIPV6RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv6', network_ipv6_rpc)
network_range_ipv6_rpc = network.NetworkRangeIPV6RPC(object_store, session_handler)
network_range_rpc.putSubHandler('ipv6', network_range_ipv6_rpc)
container_rpc = container.ContainerRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('container', container_rpc)
container_tree_rpc = container.ContainerTreeRPC(object_store, session_handler)
container_rpc.putSubHandler('tree', container_tree_rpc)
attribute_rpc = attribute.AttributeRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('attribute', attribute_rpc)
versioned_attribute_rpc = attribute.VersionedAttributeRPC(object_store, session_handler)
attribute_rpc.putSubHandler('versioned', versioned_attribute_rpc)
encrypted_attribute_rpc = attribute.EncryptedAttributeRPC(
object_store,
session_handler
)
attribute_rpc.putSubHandler(
'encrypted',
encrypted_attribute_rpc
)
template_rpc = template.TemplateRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('template', template_rpc)
device_template_rpc = template.DeviceTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('device', device_template_rpc)
network_template_rpc = template.NetworkTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('network', network_template_rpc)
template_rule_rpc = template.TemplateRuleRPC(object_store, session_handler)
template_rpc.putSubHandler('rule', template_rule_rpc)
template_rule_password_rpc = template.TemplateRulePasswordRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('password', template_rule_password_rpc)
template_rule_assign_network_rpc = template.TemplateRuleAssignNetworkRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('assign_network', template_rule_assign_network_rpc)
template_rule_subdevice_rpc = template.TemplateRuleSubdeviceRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('subdevice', template_rule_subdevice_rpc)
template_rule_text_rpc = template.TemplateRuleTextRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('text', template_rule_text_rpc)
template_rule_fixed_rpc = template.TemplateRuleFixedRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('fixed', template_rule_fixed_rpc)
template_rule_regmatch_rpc = template.TemplateRuleRegmatchRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('regmatch', template_rule_regmatch_rpc)
template_rule_bool_rpc = template.TemplateRuleBoolRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('bool', template_rule_bool_rpc)
template_rule_int_rpc = template.TemplateRuleIntRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('int', template_rule_int_rpc)
template_rule_delete_attribute_rpc = template.TemplateRuleDeleteAttributeRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('delete_attribute', template_rule_delete_attribute_rpc)
template_rule_flush_nodes_rpc = template.TemplateRuleFlushNodesRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('flush_nodes', template_rule_flush_nodes_rpc)
template_rule_flush_associations_rpc = template.TemplateRuleFlushAssociationsRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('flush_associations', template_rule_flush_associations_rpc)
config_rpc = config.ConfigRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('config', config_rpc)
config_network_autoassign_rpc = config.ConfigNetworkAutoassignRPC(object_store, session_handler)
config_rpc.putSubHandler('network_autoassign', config_network_autoassign_rpc)
config_value_rpc = config.ConfigValueRPC(object_store, session_handler)
config_rpc.putSubHandler('value', config_value_rpc)
simple_rpc = simple.SimpleRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('simple', simple_rpc)
permission_rpc = permission.PermissionRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('permission', permission_rpc)
command_rpc = event.CommandRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('command', command_rpc)
command_queue_rpc = event.CommandQueueRPC(object_store, session_handler)
command_rpc.putSubHandler('queue', command_queue_rpc)
event_rpc = event.EventRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('event', event_rpc)
event_trigger_rpc = event.EventTriggerRPC(object_store, session_handler)
event_rpc.putSubHandler('trigger', event_trigger_rpc)
event_trigger_rule_rpc = event.EventTriggerRuleRPC(object_store, session_handler)
event_trigger_rpc.putSubHandler('rule', event_trigger_rule_rpc)
event_trigger_rule_python_rpc = event.EventTriggerRulePythonRPC(object_store, session_handler)
event_trigger_rule_rpc.putSubHandler('python', event_trigger_rule_python_rpc)
root_service = service.MultiService()
if listen_port:
siptrackd_xmlrpc_service = internet.TCPServer(listen_port,
server.Site(siptrackd_rpc))
siptrackd_xmlrpc_service.setServiceParent(root_service)
if ssl_port:
ssl_context = SiptrackOpenSSLContextFactory(ssl_private_key,
ssl_certificate)
siptrackd_ssl_xmlrpc_service = internet.SSLServer(ssl_port,
server.Site(siptrackd_rpc), ssl_context)
siptrackd_ssl_xmlrpc_service.setServiceParent(root_service)
application = service.Application('siptrackd')
root_service.setServiceParent(application)
reactor.callWhenRunning(siptrackd_twisted_init, object_store, application)
if reload_interval:
reactor.callLater(reload_interval, object_store_reloader, session_handler, object_store, reload_interval)
reactor.run()
log.msg('Shutting down siptrackd server.')
return 0
if __name__ == '__main__':
import datetime
import random
import ConfigParser
config = ConfigParser.RawConfigParser(allow_no_value=True)
config.read('config.ini')
if not config.get('log', 'filename'):
log.startLogging(sys.stdout)
else:
log.startLogging(logfile.DailyLogFile(
config.get('log', 'filename'), config.get('log', 'path')))
log.msg("try to connect sqlite")
dbpool = adbapi.ConnectionPool(
'sqlite3',
config.get('sqlite',
'db_file'),
check_same_thread=False)
dbpool.runInteraction(initTables)
log.msg("try to init service")
from twisted.internet import reactor
root = resource.Resource()
rpc = MyServer()
xmlrpc.addIntrospection(rpc)
root.putChild(config.get('service', 'mount_point'), rpc)
reactor.listenTCP(config.getint('service', 'port'), server.Site(root))
log.msg(
"service listened on port http://0.0.0.0:%s/%s" %
(config.getint('service', 'port'), config.get('service', 'mount_point')))
reactor.run()
)
# except:
if 1 == 2:
cb.complete(
["Error", "query_bars(%s) failed!" % repr((bar_symbol, bar_period, bar_start, bar_end)), "Count: 0"]
)
def handle_historical_data(self, msg):
for cb in self.bardata_callbacks:
if cb.id == msg.reqId:
if not cb.data:
cb.data = []
if msg.date.startswith("finished"):
cb.complete(["OK", cb.data])
else:
cb.data.append(dict(msg.items()))
# self.output('historical_data: %s' % msg) #repr((id, start_date, bar_open, bar_high, bar_low, bar_close, bar_volume, count, WAP, hasGaps)))
def query_connection_status(self):
return self.connection_status
if __name__ == "__main__":
log.startLogging(sys.stdout)
tws = TWS()
reactor.listenTCP(tws.tcp_port, serverFactory(tws))
xmlsvr = xmlserver(tws)
xmlrpc.addIntrospection(xmlsvr)
reactor.listenTCP(tws.xmlrpc_port, server.Site(xmlsvr))
reactor.run()
def getClientConnectionService():
global client_connection_manager
xmlrpc.addIntrospection(client_connection_manager)
site = server.Site(client_connection_manager)
return internet.TCPServer(9090, site, interface="127.0.0.1")
def run_siptrackd_twisted(listen_port, ssl_port, ssl_private_key,
ssl_certificate, storage, reload_interval, searcher):
log.msg('Creating object store')
object_store = siptrackdlib.ObjectStore(storage, searcher=searcher)
session_handler = sessions.SessionHandler()
log.msg('Creating rpc interface')
siptrackd_rpc = SiptrackdRPC(object_store, session_handler)
xmlrpc.addIntrospection(siptrackd_rpc)
view_rpc = view.ViewRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('view', view_rpc)
view_tree_rpc = view.ViewTreeRPC(object_store, session_handler)
view_rpc.putSubHandler('tree', view_tree_rpc)
counter_rpc = counter.CounterRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('counter', counter_rpc)
counter_loop_rpc = counter.CounterLoopRPC(object_store, session_handler)
counter_rpc.putSubHandler('loop', counter_loop_rpc)
user_rpc = user.UserRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('user', user_rpc)
user_local_rpc = user.UserLocalRPC(object_store, session_handler)
user_rpc.putSubHandler('local', user_local_rpc)
user_ldap_rpc = user.UserLDAPRPC(object_store, session_handler)
user_rpc.putSubHandler('ldap', user_ldap_rpc)
user_active_directory_rpc = user.UserActiveDirectoryRPC(
object_store, session_handler)
user_rpc.putSubHandler('activedirectory', user_active_directory_rpc)
user_rpc.putSubHandler('ad', user_active_directory_rpc)
user_manager_rpc = user.UserManagerRPC(object_store, session_handler)
user_rpc.putSubHandler('manager', user_manager_rpc)
user_manager_local_rpc = user.UserManagerLocalRPC(object_store,
session_handler)
user_manager_rpc.putSubHandler('local', user_manager_local_rpc)
user_manager_ldap_rpc = user.UserManagerLDAPRPC(object_store,
session_handler)
user_manager_rpc.putSubHandler('ldap', user_manager_ldap_rpc)
user_manager_active_directory_rpc = user.UserManagerActiveDirectoryRPC(
object_store, session_handler)
user_manager_rpc.putSubHandler('activedirectory',
user_manager_active_directory_rpc)
user_manager_rpc.putSubHandler('ad', user_manager_active_directory_rpc)
user_group_rpc = user.UserGroupRPC(object_store, session_handler)
user_rpc.putSubHandler('group', user_group_rpc)
user_group_ldap_rpc = user.UserGroupLDAPRPC(object_store, session_handler)
user_group_rpc.putSubHandler('ldap', user_group_ldap_rpc)
user_group_active_directory_rpc = user.UserGroupActiveDirectoryRPC(
object_store, session_handler)
user_group_rpc.putSubHandler('activedirectory',
user_group_active_directory_rpc)
user_group_rpc.putSubHandler('ad', user_group_active_directory_rpc)
device_rpc = device.DeviceRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('device', device_rpc)
device_tree_rpc = device.DeviceTreeRPC(object_store, session_handler)
device_rpc.putSubHandler('tree', device_tree_rpc)
device_category_rpc = device.DeviceCategoryRPC(object_store,
session_handler)
device_rpc.putSubHandler('category', device_category_rpc)
device_config_rpc = deviceconfig.DeviceConfigRPC(object_store,
session_handler)
device_rpc.putSubHandler('config', device_config_rpc)
device_config_template_rpc = deviceconfig.DeviceConfigTemplateRPC(
object_store, session_handler)
device_config_rpc.putSubHandler('template', device_config_template_rpc)
password_rpc = password.PasswordRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('password', password_rpc)
password_key_rpc = password.PasswordKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('key', password_key_rpc)
password_tree_rpc = password.PasswordTreeRPC(object_store, session_handler)
password_rpc.putSubHandler('tree', password_tree_rpc)
password_category_rpc = password.PasswordCategoryRPC(
object_store, session_handler)
password_rpc.putSubHandler('category', password_category_rpc)
sub_key_rpc = password.SubKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('subkey', sub_key_rpc)
network_rpc = network.NetworkRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('network', network_rpc)
network_tree_rpc = network.NetworkTreeRPC(object_store, session_handler)
network_rpc.putSubHandler('tree', network_tree_rpc)
network_ipv4_rpc = network.NetworkIPV4RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv4', network_ipv4_rpc)
network_range_rpc = network.NetworkRangeRPC(object_store, session_handler)
network_rpc.putSubHandler('range', network_range_rpc)
network_range_ipv4_rpc = network.NetworkRangeIPV4RPC(
object_store, session_handler)
network_range_rpc.putSubHandler('ipv4', network_range_ipv4_rpc)
network_ipv6_rpc = network.NetworkIPV6RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv6', network_ipv6_rpc)
network_range_ipv6_rpc = network.NetworkRangeIPV6RPC(
object_store, session_handler)
network_range_rpc.putSubHandler('ipv6', network_range_ipv6_rpc)
container_rpc = container.ContainerRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('container', container_rpc)
container_tree_rpc = container.ContainerTreeRPC(object_store,
session_handler)
container_rpc.putSubHandler('tree', container_tree_rpc)
attribute_rpc = attribute.AttributeRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('attribute', attribute_rpc)
versioned_attribute_rpc = attribute.VersionedAttributeRPC(
object_store, session_handler)
attribute_rpc.putSubHandler('versioned', versioned_attribute_rpc)
encrypted_attribute_rpc = attribute.EncryptedAttributeRPC(
object_store, session_handler)
attribute_rpc.putSubHandler('encrypted', encrypted_attribute_rpc)
template_rpc = template.TemplateRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('template', template_rpc)
device_template_rpc = template.DeviceTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('device', device_template_rpc)
network_template_rpc = template.NetworkTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('network', network_template_rpc)
template_rule_rpc = template.TemplateRuleRPC(object_store, session_handler)
template_rpc.putSubHandler('rule', template_rule_rpc)
template_rule_password_rpc = template.TemplateRulePasswordRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('password', template_rule_password_rpc)
template_rule_assign_network_rpc = template.TemplateRuleAssignNetworkRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('assign_network',
template_rule_assign_network_rpc)
template_rule_subdevice_rpc = template.TemplateRuleSubdeviceRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('subdevice', template_rule_subdevice_rpc)
template_rule_text_rpc = template.TemplateRuleTextRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('text', template_rule_text_rpc)
template_rule_fixed_rpc = template.TemplateRuleFixedRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('fixed', template_rule_fixed_rpc)
template_rule_regmatch_rpc = template.TemplateRuleRegmatchRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('regmatch', template_rule_regmatch_rpc)
template_rule_bool_rpc = template.TemplateRuleBoolRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('bool', template_rule_bool_rpc)
template_rule_int_rpc = template.TemplateRuleIntRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('int', template_rule_int_rpc)
template_rule_delete_attribute_rpc = template.TemplateRuleDeleteAttributeRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('delete_attribute',
template_rule_delete_attribute_rpc)
template_rule_flush_nodes_rpc = template.TemplateRuleFlushNodesRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('flush_nodes',
template_rule_flush_nodes_rpc)
template_rule_flush_associations_rpc = template.TemplateRuleFlushAssociationsRPC(
object_store, session_handler)
template_rule_rpc.putSubHandler('flush_associations',
template_rule_flush_associations_rpc)
config_rpc = config.ConfigRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('config', config_rpc)
config_network_autoassign_rpc = config.ConfigNetworkAutoassignRPC(
object_store, session_handler)
config_rpc.putSubHandler('network_autoassign',
config_network_autoassign_rpc)
config_value_rpc = config.ConfigValueRPC(object_store, session_handler)
config_rpc.putSubHandler('value', config_value_rpc)
simple_rpc = simple.SimpleRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('simple', simple_rpc)
permission_rpc = permission.PermissionRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('permission', permission_rpc)
command_rpc = event.CommandRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('command', command_rpc)
command_queue_rpc = event.CommandQueueRPC(object_store, session_handler)
command_rpc.putSubHandler('queue', command_queue_rpc)
event_rpc = event.EventRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('event', event_rpc)
event_trigger_rpc = event.EventTriggerRPC(object_store, session_handler)
event_rpc.putSubHandler('trigger', event_trigger_rpc)
event_trigger_rule_rpc = event.EventTriggerRuleRPC(object_store,
session_handler)
event_trigger_rpc.putSubHandler('rule', event_trigger_rule_rpc)
event_trigger_rule_python_rpc = event.EventTriggerRulePythonRPC(
object_store, session_handler)
event_trigger_rule_rpc.putSubHandler('python',
event_trigger_rule_python_rpc)
root_service = service.MultiService()
if listen_port:
siptrackd_xmlrpc_service = internet.TCPServer(
listen_port, server.Site(siptrackd_rpc))
siptrackd_xmlrpc_service.setServiceParent(root_service)
if ssl_port:
ssl_context = SiptrackOpenSSLContextFactory(ssl_private_key,
ssl_certificate)
siptrackd_ssl_xmlrpc_service = internet.SSLServer(
ssl_port, server.Site(siptrackd_rpc), ssl_context)
siptrackd_ssl_xmlrpc_service.setServiceParent(root_service)
application = service.Application('siptrackd')
root_service.setServiceParent(application)
reactor.callWhenRunning(siptrackd_twisted_init, object_store, application)
if reload_interval:
reactor.callLater(reload_interval, object_store_reloader,
session_handler, object_store, reload_interval)
reactor.run()
log.msg('Shutting down siptrackd server.')
return 0
self.loop.start(0.1)
def scan_exi(self):
"""
First scan the EXI
Check answers to make sure we do not use an EXIID
that is already used by a real EXI
"""
self.exid = defer.Deferred()
self.exi = 1
def scanNext():
if self.exi >= 16:
self.exiloop.stop()
self.exid.callback(None)
packet = [35, 00, 11, 2, CMD['EXI_ECHO_REQUEST']]
packet[1] = self.exi + EXIOFFSET
self.send_command(self.exi + EXIOFFSET, CMD['EXI_ECHO_REQUEST'])
self.exi += 1
self.exiloop = LoopingCall(scanNext)
self.exiloop.start(0.1)
if __name__ == '__main__':
from twisted.internet import reactor
morbidq_factory = MorbidQClientFactory()
ws = WebService()
ws.morbidq_factory = morbidq_factory
xmlrpc.addIntrospection(ws)
reactor.listenTCP( 8000, server.Site(ws) )
reactor.connectTCP(MORBIDQ_HOST, MORBIDQ_PORT, morbidq_factory)
reactor.run()
if 1 == 2:
cb.complete([
'Error',
'query_bars(%s) failed!' % repr(
(bar_symbol, bar_period, bar_start, bar_end)), 'Count: 0'
])
def handle_historical_data(self, msg):
for cb in self.bardata_callbacks:
if cb.id == msg.reqId:
if not cb.data:
cb.data = []
if msg.date.startswith('finished'):
cb.complete(['OK', cb.data])
else:
cb.data.append(dict(msg.items()))
#self.output('historical_data: %s' % msg) #repr((id, start_date, bar_open, bar_high, bar_low, bar_close, bar_volume, count, WAP, hasGaps)))
def query_connection_status(self):
return self.connection_status
if __name__ == '__main__':
log.startLogging(sys.stdout)
tws = TWS()
reactor.listenTCP(tws.tcp_port, serverFactory(tws))
xmlsvr = xmlserver(tws)
xmlrpc.addIntrospection(xmlsvr)
reactor.listenTCP(tws.xmlrpc_port, server.Site(xmlsvr))
reactor.run()
from twisted.application import internet, service
from twisted.web import xmlrpc, server
from twisted.internet import reactor
from txtrader.tws import TWS
from txtrader.xmlserver import xmlserver
from txtrader.tcpserver import serverFactory
msvc = service.MultiService()
api=TWS()
xrs = xmlserver(api)
xmlrpc.addIntrospection(xrs)
internet.TCPServer(api.xmlrpc_port, server.Site(xrs)).setServiceParent(msvc)
internet.TCPServer(api.tcp_port, serverFactory(api)).setServiceParent(msvc)
application = service.Application('txtrader')
msvc.setServiceParent(application)
reactor.run()
# file: xmlrpcserver.py
from twisted.web import server, resource, xmlrpc #1
from twisted.internet import reactor
import plain_pi #2
class PiMaker(xmlrpc.XMLRPC): #3
def xmlrpc_pi(self, n): #4
return plain_pi.piPlain(n)
xmlrpc_pi.signature = [['int'], ['double']] #5
xmlrpc_pi.help = 'Calculate pi with Monte ' \
'Carlo method.' #6
pimaker = PiMaker() #7
xmlrpc.addIntrospection(pimaker) #8
siteRoot = resource.Resource() #9
siteRoot.putChild('', pimaker) #10
reactor.listenTCP(8888, server.Site(siteRoot)) #11
reactor.run()
# ---------------------------------------------------------------------------
from twisted.web import xmlrpc, server
class Example(xmlrpc.XMLRPC):
"""An example object to be published."""
def xmlrpc_echo(self, x):
"""Return all passed args."""
return x
##xmlrpc_echo.signature = [['string', 'string'],
##['int', 'int'],
##['double', 'double'],
##['array', 'array'],
##['struct', 'struct']]
def xmlrpc_add(self, a, b):
"""Return sum of arguments."""
return a + b
##xmlrpc_add.signature = [['int', 'int', 'int'],
##['double', 'double', 'double']]
##xmlrpc_add.help = "Add the arguments and return the sum."
if __name__ == '__main__':
from twisted.internet import reactor
r = Example()
xmlrpc.addIntrospection(r)
reactor.listenTCP(7080, server.Site(r))
reactor.run()
def setUp(self):
xmlrpc = Test()
addIntrospection(xmlrpc)
self.p = reactor.listenTCP(0, server.Site(xmlrpc),interface="127.0.0.1")
self.port = self.p.getHost().port
self.factories = []
def put_child(self, folder, rpc, add_introspection=False):
if add_introspection:
self.sub_services.append([folder, rpc])
xmlrpc.addIntrospection(rpc)
self.putChild(folder, rpc)
