def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.pfcIp = '192.168.1.52'
self.modbusTcpPort = '502'
self.client = ModbusClient(self.pfcIp, self.modbusTcpPort)
self.oldState = {}
self.elapsedTime = 0
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.connection = mysql.connector.connect(**mysqlConfig)
#==============================================================================
# A notification email will be send every errorNotificationInterval hours
#==============================================================================
self.pfc = 'SWITCH_Relays'
self.errorNotificationInterval = 12 # hours'
self.timestampOld = 0 # need for initial comparison
#=====================is=========================================================
# mySQLStructure defined since the readout is published as dict-objects and those are not ordered in Python
#==============================================================================
self.mySQLStructure = ['TimestampSYS',
'TimestampPFC',
'K_001',
'K_002',
'K_003',
'K_004',
'K_005',
'K_006',
'K_007',
'K_008',
'K_009',
'K_010',
'K_011',
'K_012',
'K_013',
'K_014',
'K_015',
'Frei_001',
'Frei_002',
'Frei_003']
def test_server_abort(self):
handler = ApplicationSession()
MockTransport(handler)
# this should not raise an exception, but did when this
# test-case was written
handler.onClose(False)
def test_invoke_user_raises(self):
handler = ApplicationSession()
handler.traceback_app = True
MockTransport(handler)
errors = []
def log_error(e, msg):
errors.append((e.value, msg))
handler.onUserError = log_error
name_error = NameError('foo')
def bing():
raise name_error
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(bing, u'com.myapp.myproc99')
try:
yield handler.call(u'com.myapp.myproc99')
self.fail("Expected an error")
except Exception as e:
# XXX should/could we export all the builtin types?
# right now, we always get ApplicationError
# self.assertTrue(isinstance(e, NameError))
self.assertTrue(isinstance(e, RuntimeError))
# also, we should have logged the real NameError to
# Twisted.
self.assertEqual(1, len(errors))
self.assertEqual(name_error, errors[0][0])
def test_invoke_progressive_result(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
for i in range(10):
details.progress(i)
yield succeed(i)
returnValue(42)
progressive = list(map(lambda _: Deferred(), range(10)))
def progress(arg):
progressive[arg].callback(arg)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
# make sure we got *all* our progressive results
for i in range(10):
self.assertTrue(progressive[i].called)
self.assertEqual(i, progressive[i].result)
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.vtkWebProtocols = []
self.authdb = None
self.secret = None
self.Application = self.initApplication()
self.initialize()
def test_invoke_progressive_result_just_kwargs(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
details.progress(key='word')
yield succeed(True)
returnValue(42)
got_progress = Deferred()
def progress(key=None):
got_progress.callback(key)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
self.assertTrue(got_progress.called)
self.assertEqual('word', got_progress.result)
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
global live
live = self
self.logger = logging.getLogger('Live')
self.logger.info("Config: %s", config)
self.account_id = config.extra['authid']
self.secret = config.extra['secret']
if '-' not in self.account_id:
self.account_id = "local-%s" % self.account_id
self.authid = '%s:%s' % (self.account_id, self.secret[-7:])
self.joined = False
self.lock = DeferredLock()
self.checks = {}
self.workers = {}
self.CallOptions = CallOptions()
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.connection = mysql.connector.connect(mysqlConfig)
self.oldState = {}
self.elapsedTime = 0
self.errorNotificationInterval = 12 # hours'
self.timestampOld = 0
def __init__(self, config=None):
ApplicationSession.__init__(self, config=config)
self.node = config.extra['node']
if 'domain' in config.extra:
self.domain = config.extra['domain']
else:
# TODO deprecate pdid
self.domain = config.extra['pdid']
self.pdid = config.extra['pdid']
self.authid = config.extra.get('authid', self.pdid)
# Need some idea of top level domain so we know which bouncer to call
self.topLevelDomain = config.extra.get('topLevelDomain', 'xs.demo')
# extra overrides the environment variable
self.token = config.extra.get('token', None)
if self.token is None:
self.token = EXIS_TOKEN
keySource = config.extra.get('key', None)
if keySource is None:
keySource = EXIS_KEY
if keySource is None:
self.key = None
else:
self.key = getPrivateKey(keySource)
# Set by the start class method.
self.dee = None
def __init__(self, config=None):
print("__init__(config={})".format(config))
ApplicationSession.__init__(self, config)
# load the client private key (raw format)
self._key = cryptosign.Key.from_raw(config.extra[u'key'])
print("Client public key loaded: {}".format(self._key.public_key()))
def __init__(self, config):
ApplicationSession.__init__(self)
self.t_account = config.extra["twilio-account"]
self.t_token = config.extra["twilio-token"]
self.t_number = config.extra["twilio-number"]
urltmpl = "https://api.twilio.com/2010-04-01/Accounts/%s/Messages"
self.t_url = (urltmpl % self.t_account).encode("utf-8")
def __init__(self, node):
ApplicationSession.__init__(self)
self.debug = False
self._node = node
self._node_name = node._node_name
self._management_session = None
self._processes = {}
def __init__(self, config = None):
"""
Constructor.
"""
conn = sqlite3.connect(CONFIG_FILE)
cur = conn.cursor()
cur.execute("""SELECT value FROM Frequency""")
row = cur.fetchone()
if row != None:
frequency = row[0]
if frequency == 0:
self.delta = datetime.timedelta(days=1)
elif frequency == 1:
self.delta = datetime.timedelta(hours=1)
elif frequency == 2:
self.delta = datetime.timedelta(minutes=1)
else:
## If a measurement is not found, default to hours
self.delta = datetime.timedelta(hours=1)
conn.close()
self.networkDevices = [socket.gethostname() + ".local"]
ApplicationSession.__init__(self, config)
def test_publish_undefined_exception(self):
handler = ApplicationSession()
MockTransport(handler)
options = types.PublishOptions(acknowledge=True)
yield self.assertFailure(handler.publish(u'de.myapp.topic1', options=options), ApplicationError)
yield self.assertFailure(handler.publish(u'', options=options), ApplicationError)
def test_reject_pending(self):
handler = ApplicationSession()
MockTransport(handler)
# This could happen if the task waiting on a request gets cancelled
deferred = fail(Exception())
handler._call_reqs[1] = CallRequest(1, 'foo', deferred, {})
handler.onLeave(CloseDetails())
def onLeave(self, details):
print("Realm left (WAMP session ended).")
self.count += 1
if self.count < 3:
self.join("kotori-realm")
else:
self.disconnect()
ApplicationSession.onLeave(self, details)
def __init__(self, config):
# Cannot use super() here.
# We must explicitly call both parent constructors.
ApplicationSession.__init__(self)
service.AsyncMultiService.__init__(self)
self.config = config
self.leaving = False
self.setServiceParent(config.extra['parent'])
def test_unregister(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
yield registration.unregister()
def test_unsubscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, u'com.myapp.topic1')
yield subscription.unsubscribe()
def onJoin(self, details):
ApplicationSession.onJoin(self, details)
print("session ready")
self.register(self.toggleSwitch, u'eshl.wago.v1.switch.toggle')
self.register(self.switchOn, u'eshl.wago.v1.switch.on')
self.register(self.switchOff, u'eshl.wago.v1.switch.off')
self._loop = task.LoopingCall(self.requestLoop)
self._requestLoopHandle = self._loop.start(1.0)
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.cluster_state = ClusterState(self)
try:
self.node_id = (open('/cygnus/node', 'r')).read()
except IOError:
self.node_id = str(uuid.uuid1())
f = open('/cygnus/node', 'w')
f.write(self.node_id)
f.close()
def onDisconnect(self, *args, **kwargs):
ApplicationSession.onDisconnect(self, *args, **kwargs)
if not self.joined:
self.logger.error("Impossible to join realm")
if reactor.running:
reactor.stop()
self.logger.info("Disconnected")
def __init__(self, config):
ApplicationSession.__init__(self, config)
self._manager = None
self._management_realm = None
self._node_id = None
self._regs = {}
self._authrole = u'trusted'
self._authmethod = u'trusted'
self._sub_on_mgmt = None
self._sub_on_reg_create = None
self._sub_on_reg_delete = None
def __init__(self, config, management_session):
"""
:param config: Session configuration.
:type config: instance of `autobahn.wamp.types.ComponentConfig`
:param management_session: uplink session.
:type management_session: instance of `autobahn.wamp.protocol.ApplicationSession`
"""
ApplicationSession.__init__(self, config)
self._management_session = management_session
self._regs = {}
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.connection = mysql.connector.connect(**mysqlConfig)
#==============================================================================
# A notification email will be send every errorNotificationInterval hours
#==============================================================================
self.pfc = 'SWITCH_DI'
self.errorNotificationInterval = 12 # hours'
self.timestampOld = 0 # need for initial comparison
def test_unregister_log(self):
handler = ApplicationSession()
transport = MockTransport(handler)
def on_call(*args, **kwargs):
on_call.called = True
on_call.called = False
registration = yield handler.register(on_call, u'com.myapp.procedure1')
transport.drop_registration(registration.id)
self.assertFalse(on_call.called)
def test_invoke(self):
handler = ApplicationSession()
MockTransport(handler)
def myproc1():
return 23
yield handler.register(myproc1, u'com.myapp.myproc1')
res = yield handler.call(u'com.myapp.myproc1')
self.assertEqual(res, 23)
def test_subscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, 'com.myapp.topic1')
self.assertTrue(type(subscription.id) in (int, long))
subscription = yield handler.subscribe(on_event, 'com.myapp.topic1', options = types.SubscribeOptions(match = 'wildcard'))
self.assertTrue(type(subscription.id) in (int, long))
def test_register(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
self.assertTrue(type(registration.id) in (int, long))
registration = yield handler.register(on_call, u'com.myapp.procedure1', options=types.RegisterOptions(match=u'prefix'))
self.assertTrue(type(registration.id) in (int, long))
def test_failure(self):
"""
A failed call returns the error to the client.
"""
session = TestSession(types.ComponentConfig(u'realm1'))
self.session_factory.add(session, authrole=u"test_role")
session2 = ApplicationSession(types.ComponentConfig(u'realm1'))
self.session_factory.add(session2, authrole=u"test_role")
resource = CallerResource({}, session2)
tests = [
(u"com.myapp.sqrt", (0,),
{u"error": u"wamp.error.runtime_error", u"args": [u"don't ask foolish questions ;)"], u"kwargs": {}}),
(u"com.myapp.checkname", ("foo",),
{u"error": u"com.myapp.error.reserved", u"args": [], u"kwargs": {}}),
(u"com.myapp.checkname", ("*",),
{u"error": u"com.myapp.error.invalid_length", u"args": [], u"kwargs": {"min": 3, "max": 10}}),
(u"com.myapp.checkname", ("hello",),
{u"error": u"com.myapp.error.mixed_case", u"args": ["hello", "HELLO"], u"kwargs": {}}),
(u"com.myapp.compare", (1, 10),
{u"error": u"com.myapp.error1", u"args": [9], u"kwargs": {}}),
]
for procedure, args, err in tests:
with LogCapturer() as l:
request = yield renderResource(
resource, b"/",
method=b"POST",
headers={b"Content-Type": [b"application/json"]},
body=dump_json({"procedure": procedure, "args": args}).encode('utf8'))
self.assertEqual(request.code, 200)
self.assertEqual(json.loads(native_string(request.get_written_data())),
err)
logs = l.get_category("AR458")
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0]["code"], 200)
# We manually logged the errors; we can flush them from the log
self.flushLoggedErrors()
def test_publish_acknowledged(self):
handler = ApplicationSession()
MockTransport(handler)
publication = yield handler.publish(u'com.myapp.topic1', options=types.PublishOptions(acknowledge=True))
self.assertTrue(type(publication.id) in (int, long))
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3, options=types.PublishOptions(acknowledge=True))
self.assertTrue(type(publication.id) in (int, long))
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3, foo=23, bar='hello', options=types.PublishOptions(acknowledge=True))
self.assertTrue(type(publication.id) in (int, long))
publication = yield handler.publish(u'com.myapp.topic1', options=types.PublishOptions(exclude_me=False, acknowledge=True))
self.assertTrue(type(publication.id) in (int, long))
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3, foo=23, bar='hello', options=types.PublishOptions(exclude_me=False, exclude=[100, 200, 300], acknowledge=True))
self.assertTrue(type(publication.id) in (int, long))
def test_publish(self):
handler = ApplicationSession()
MockTransport(handler)
publication = yield handler.publish(u'com.myapp.topic1')
self.assertEqual(publication, None)
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3)
self.assertEqual(publication, None)
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3, foo=23, bar='hello')
self.assertEqual(publication, None)
publication = yield handler.publish(u'com.myapp.topic1', options=types.PublishOptions(exclude_me=False))
self.assertEqual(publication, None)
publication = yield handler.publish(u'com.myapp.topic1', 1, 2, 3, foo=23, bar='hello', options=types.PublishOptions(exclude_me=False, exclude=[100, 200, 300]))
self.assertEqual(publication, None)
def test_call(self):
handler = ApplicationSession()
MockTransport(handler)
res = yield handler.call(u'com.myapp.procedure1')
self.assertEqual(res, 100)
res = yield handler.call(u'com.myapp.procedure1', 1, 2, 3)
self.assertEqual(res, 100)
res = yield handler.call(u'com.myapp.procedure1', 1, 2, 3, foo = 23, bar = 'hello')
self.assertEqual(res, 100)
res = yield handler.call(u'com.myapp.procedure1', options = types.CallOptions(timeout = 10000))
self.assertEqual(res, 100)
res = yield handler.call(u'com.myapp.procedure1', 1, 2, 3, foo = 23, bar = 'hello', options = types.CallOptions(timeout = 10000))
self.assertEqual(res, 100)
def __init__(self, handler):
self._log = False
self._handler = handler
self._serializer = serializer.JsonSerializer()
self._registrations = {}
self._invocations = {}
#: str -> ID
self._subscription_topics = {}
self._handler.onOpen(self)
self._my_session_id = util.id()
roles = {'broker': role.RoleBrokerFeatures(), 'dealer': role.RoleDealerFeatures()}
msg = message.Welcome(self._my_session_id, roles)
self._handler.onMessage(msg)
self._fake_router_session = ApplicationSession()
self._transport_details = TransportDetails()
def create(transport, path, config):
personality = transport.worker.personality
personality.WEB_SERVICE_CHECKERS['webhook'](personality, config)
# create a vanilla session: the webhook will use this to inject events
#
webhook_session_config = ComponentConfig(realm=config['realm'],
extra=None)
webhook_session = ApplicationSession(webhook_session_config)
# add the webhook session to the router
#
transport._worker._router_session_factory.add(webhook_session,
authrole=config.get(
'role', 'anonymous'))
# now create the webhook Twisted Web resource
#
resource = WebhookResource(config.get('options', {}), webhook_session)
return RouterWebServiceWebhook(transport, path, config, resource)
def create(transport, path, config):
personality = transport.worker.personality
personality.WEB_SERVICE_CHECKERS['caller'](personality, config)
# create a vanilla session: the caller will use this to inject calls
#
caller_session_config = ComponentConfig(realm=config['realm'],
extra=None)
caller_session = ApplicationSession(caller_session_config)
# add the calling session to the router
#
transport._worker._router_session_factory.add(caller_session,
authrole=config.get(
'role', 'anonymous'))
# now create the caller Twisted Web resource
#
resource = CallerResource(config.get('options', {}), caller_session)
return RouterWebServiceRestCaller(transport, path, config, resource)
def test_publish_callback_exception(self):
"""
Ensure we handle an exception from the user code.
"""
handler = ApplicationSession()
MockTransport(handler)
error_instance = RuntimeError("we have a problem")
got_err_d = Deferred()
def observer(kw):
if kw['isError'] and 'failure' in kw:
fail = kw['failure']
fail.trap(RuntimeError)
if error_instance == fail.value:
got_err_d.callback(True)
log.addObserver(observer)
def boom():
raise error_instance
try:
sub = yield handler.subscribe(boom, u'com.myapp.topic1')
# MockTransport gives us the ack reply and then we do our
# own event message
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
msg = message.Event(sub.id, publish.id)
handler.onMessage(msg)
# we know it worked if our observer worked and did
# .callback on our Deferred above.
self.assertTrue(got_err_d.called)
# ...otherwise trial will fail the test anyway
self.flushLoggedErrors()
finally:
log.removeObserver(observer)
def __init__(self, config):
ApplicationSession.__init__(self, config)
self._countdown = 5
def __init__(self, config):
self.log.info('MySession.__init__(config={config})',
config=pformat(config))
ApplicationSession.__init__(self, config)
def __init__(self, config):
ApplicationSession.__init__(self)
service.AsyncMultiService.__init__(self)
self.config = config
self.leaving = False
self.setServiceParent(config.extra['parent'])
def __init__(self, *args, **kw):
ApplicationSession.__init__(self, *args, **kw)
self.errors = []
self._realm = 'dummy'
self._transport = MockTransport()
def onLeave(self, details):
self.log.info('session left: {details}', details=details)
ApplicationSession.onLeave(self, details)
def start_router_transport(self, id, config, details=None):
"""
Start a transport on this router and return when the transport has started.
**Usage:**
This procedure is registered under
* ``crossbar.node.<node_id>.worker.<worker_id>.start_router_transport``
The procedure takes a WAMP transport configuration with a listening endpoint, e.g.
.. code-block:: javascript
{
"type": "websocket",
"endpoint": {
"type": "tcp",
"port": 8080
}
}
**Errors:**
The procedure may raise the following errors:
* ``crossbar.error.invalid_configuration`` - the provided transport configuration is invalid
* ``crossbar.error.already_running`` - a transport with the given ID is already running (or starting)
* ``crossbar.error.cannot_listen`` - could not listen on the configured listening endpoint of the transport
* ``crossbar.error.class_import_failed`` - a side-by-side component could not be instantiated
**Events:**
The procedure will publish an event when the transport **is starting** to
* ``crossbar.node.<node_id>.worker.<worker_id>.on_router_transport_starting``
and publish an event when the transport **has started** to
* ``crossbar.node.<node_id>.worker.<worker_id>.on_router_transport_started``
:param id: The ID of the transport to start.
:type id: unicode
:param config: The transport configuration.
:type config: dict
"""
self.log.debug("{}.start_router_transport".format(self.__class__.__name__),
id=id, config=config)
# prohibit starting a transport twice
#
if id in self.transports:
emsg = "Could not start transport: a transport with ID '{}' is already running (or starting)".format(id)
self.log.error(emsg)
raise ApplicationError(u'crossbar.error.already_running', emsg)
# check configuration
#
try:
checkconfig.check_router_transport(config)
except Exception as e:
emsg = "Invalid router transport configuration: {}".format(e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
self.log.debug("Starting {}-transport on router.".format(config['type']))
# standalone WAMP-RawSocket transport
#
if config['type'] == 'rawsocket':
transport_factory = WampRawSocketServerFactory(self._router_session_factory, config)
transport_factory.noisy = False
# standalone WAMP-WebSocket transport
#
elif config['type'] == 'websocket':
transport_factory = WampWebSocketServerFactory(self._router_session_factory, self.config.extra.cbdir, config, self._templates)
transport_factory.noisy = False
# Flash-policy file server pseudo transport
#
elif config['type'] == 'flashpolicy':
transport_factory = FlashPolicyFactory(config.get('allowed_domain', None), config.get('allowed_ports', None))
# WebSocket testee pseudo transport
#
elif config['type'] == 'websocket.testee':
transport_factory = WebSocketTesteeServerFactory(config, self._templates)
# Stream testee pseudo transport
#
elif config['type'] == 'stream.testee':
transport_factory = StreamTesteeServerFactory()
# Twisted Web based transport
#
elif config['type'] == 'web':
options = config.get('options', {})
# create Twisted Web root resource
#
root_config = config['paths']['/']
root_type = root_config['type']
root_options = root_config.get('options', {})
# Static file hierarchy root resource
#
if root_type == 'static':
if 'directory' in root_config:
root_dir = os.path.abspath(os.path.join(self.config.extra.cbdir, root_config['directory']))
elif 'package' in root_config:
if 'resource' not in root_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing resource")
try:
mod = importlib.import_module(root_config['package'])
except ImportError as e:
emsg = "Could not import resource {} from package {}: {}".format(root_config['resource'], root_config['package'], e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
try:
root_dir = os.path.abspath(pkg_resources.resource_filename(root_config['package'], root_config['resource']))
except Exception as e:
emsg = "Could not import resource {} from package {}: {}".format(root_config['resource'], root_config['package'], e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
mod_version = getattr(mod, '__version__', '?.?.?')
self.log.info("Loaded static Web resource '{}' from package '{} {}' (filesystem path {})".format(root_config['resource'], root_config['package'], mod_version, root_dir))
else:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing web spec")
root_dir = root_dir.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770
self.log.debug("Starting Web service at root directory {}".format(root_dir))
# create resource for file system hierarchy
#
if root_options.get('enable_directory_listing', False):
static_resource_class = StaticResource
else:
static_resource_class = StaticResourceNoListing
cache_timeout = root_options.get('cache_timeout', DEFAULT_CACHE_TIMEOUT)
root = static_resource_class(root_dir, cache_timeout=cache_timeout)
# set extra MIME types
#
root.contentTypes.update(EXTRA_MIME_TYPES)
if 'mime_types' in root_options:
root.contentTypes.update(root_options['mime_types'])
patchFileContentTypes(root)
# render 404 page on any concrete path not found
#
root.childNotFound = Resource404(self._templates, root_dir)
# WSGI root resource
#
elif root_type == 'wsgi':
if not _HAS_WSGI:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI unsupported")
# wsgi_options = root_config.get('options', {})
if 'module' not in root_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing WSGI app module")
if 'object' not in root_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing WSGI app object")
# import WSGI app module and object
mod_name = root_config['module']
try:
mod = importlib.import_module(mod_name)
except ImportError as e:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI app module '{}' import failed: {} - Python search path was {}".format(mod_name, e, sys.path))
else:
obj_name = root_config['object']
if obj_name not in mod.__dict__:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI app object '{}' not in module '{}'".format(obj_name, mod_name))
else:
app = getattr(mod, obj_name)
# create a Twisted Web WSGI resource from the user's WSGI application object
try:
wsgi_resource = WSGIResource(self._reactor, self._reactor.getThreadPool(), app)
except Exception as e:
raise ApplicationError(u"crossbar.error.invalid_configuration", "could not instantiate WSGI resource: {}".format(e))
else:
# create a root resource serving everything via WSGI
root = WSGIRootResource(wsgi_resource, {})
# Redirecting root resource
#
elif root_type == 'redirect':
redirect_url = root_config['url'].encode('ascii', 'ignore')
root = RedirectResource(redirect_url)
# Publisher resource (part of REST-bridge)
#
elif root_type == 'publisher':
# create a vanilla session: the publisher will use this to inject events
#
publisher_session_config = ComponentConfig(realm=root_config['realm'], extra=None)
publisher_session = ApplicationSession(publisher_session_config)
# add the publishing session to the router
#
self._router_session_factory.add(publisher_session, authrole=root_config.get('role', 'anonymous'))
# now create the publisher Twisted Web resource and add it to resource tree
#
root = PublisherResource(root_config.get('options', {}), publisher_session)
# Webhook resource (part of REST-bridge)
#
elif root_type == 'webhook':
# create a vanilla session: the webhook will use this to inject events
#
webhook_session_config = ComponentConfig(realm=root_config['realm'], extra=None)
webhook_session = ApplicationSession(webhook_session_config)
# add the publishing session to the router
#
self._router_session_factory.add(webhook_session, authrole=root_config.get('role', 'anonymous'))
# now create the webhook Twisted Web resource and add it to resource tree
#
root = WebhookResource(root_config.get('options', {}), webhook_session)
# Caller resource (part of REST-bridge)
#
elif root_type == 'caller':
# create a vanilla session: the caller will use this to inject calls
#
caller_session_config = ComponentConfig(realm=root_config['realm'], extra=None)
caller_session = ApplicationSession(caller_session_config)
# add the calling session to the router
#
self._router_session_factory.add(caller_session, authrole=root_config.get('role', 'anonymous'))
# now create the caller Twisted Web resource and add it to resource tree
#
root = CallerResource(root_config.get('options', {}), caller_session)
# Generic Twisted Web resource
#
elif root_type == 'resource':
try:
klassname = root_config['classname']
self.log.debug("Starting class '{}'".format(klassname))
c = klassname.split('.')
module_name, klass_name = '.'.join(c[:-1]), c[-1]
module = importlib.import_module(module_name)
make = getattr(module, klass_name)
root = make(root_config.get('extra', {}))
except Exception as e:
emsg = "Failed to import class '{}' - {}".format(klassname, e)
self.log.error(emsg)
self.log.error("PYTHONPATH: {pythonpath}",
pythonpath=sys.path)
raise ApplicationError(u"crossbar.error.class_import_failed", emsg)
# Invalid root resource
#
else:
raise ApplicationError(u"crossbar.error.invalid_configuration", "invalid Web root path type '{}'".format(root_type))
# create Twisted Web resources on all non-root paths configured
#
self.add_paths(root, config.get('paths', {}))
# create the actual transport factory
#
transport_factory = Site(root)
transport_factory.noisy = False
# Web access logging
#
if not options.get('access_log', False):
transport_factory.log = lambda _: None
# Traceback rendering
#
transport_factory.displayTracebacks = options.get('display_tracebacks', False)
# HSTS
#
if options.get('hsts', False):
if 'tls' in config['endpoint']:
hsts_max_age = int(options.get('hsts_max_age', 31536000))
transport_factory.requestFactory = createHSTSRequestFactory(transport_factory.requestFactory, hsts_max_age)
else:
self.log.warn("Warning: HSTS requested, but running on non-TLS - skipping HSTS")
# Unknown transport type
#
else:
# should not arrive here, since we did check_transport() in the beginning
raise Exception("logic error")
# create transport endpoint / listening port from transport factory
#
d = create_listening_port_from_config(config['endpoint'], transport_factory, self.config.extra.cbdir, self._reactor)
def ok(port):
self.transports[id] = RouterTransport(id, config, transport_factory, port)
self.log.debug("Router transport '{}'' started and listening".format(id))
return
def fail(err):
emsg = "Cannot listen on transport endpoint: {}".format(err.value)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.cannot_listen", emsg)
d.addCallbacks(ok, fail)
return d
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.payload = {}
self.user = User()
self.device = Device()
self.statusDevice = {}
def __init__(self, runner, config=None):
ApplicationSession.__init__(self, config)
self._runner = runner
def create_resource(self, path_config):
"""
Creates child resource to be added to the parent.
:param path_config: Configuration for the new child resource.
:type path_config: dict
:returns: Resource -- the new child resource
"""
# WAMP-WebSocket resource
#
if path_config['type'] == 'websocket':
ws_factory = WampWebSocketServerFactory(self._router_session_factory, self.config.extra.cbdir, path_config, self._templates)
# FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
ws_factory.startFactory()
return WebSocketResource(ws_factory)
# Static file hierarchy resource
#
elif path_config['type'] == 'static':
static_options = path_config.get('options', {})
if 'directory' in path_config:
static_dir = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['directory']))
elif 'package' in path_config:
if 'resource' not in path_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing resource")
try:
mod = importlib.import_module(path_config['package'])
except ImportError as e:
emsg = "Could not import resource {} from package {}: {}".format(path_config['resource'], path_config['package'], e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
try:
static_dir = os.path.abspath(pkg_resources.resource_filename(path_config['package'], path_config['resource']))
except Exception as e:
emsg = "Could not import resource {} from package {}: {}".format(path_config['resource'], path_config['package'], e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing web spec")
static_dir = static_dir.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770
# create resource for file system hierarchy
#
if static_options.get('enable_directory_listing', False):
static_resource_class = StaticResource
else:
static_resource_class = StaticResourceNoListing
cache_timeout = static_options.get('cache_timeout', DEFAULT_CACHE_TIMEOUT)
static_resource = static_resource_class(static_dir, cache_timeout=cache_timeout)
# set extra MIME types
#
static_resource.contentTypes.update(EXTRA_MIME_TYPES)
if 'mime_types' in static_options:
static_resource.contentTypes.update(static_options['mime_types'])
patchFileContentTypes(static_resource)
# render 404 page on any concrete path not found
#
static_resource.childNotFound = Resource404(self._templates, static_dir)
return static_resource
# WSGI resource
#
elif path_config['type'] == 'wsgi':
if not _HAS_WSGI:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI unsupported")
# wsgi_options = path_config.get('options', {})
if 'module' not in path_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing WSGI app module")
if 'object' not in path_config:
raise ApplicationError(u"crossbar.error.invalid_configuration", "missing WSGI app object")
# import WSGI app module and object
mod_name = path_config['module']
try:
mod = importlib.import_module(mod_name)
except ImportError as e:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI app module '{}' import failed: {} - Python search path was {}".format(mod_name, e, sys.path))
else:
obj_name = path_config['object']
if obj_name not in mod.__dict__:
raise ApplicationError(u"crossbar.error.invalid_configuration", "WSGI app object '{}' not in module '{}'".format(obj_name, mod_name))
else:
app = getattr(mod, obj_name)
# create a Twisted Web WSGI resource from the user's WSGI application object
try:
wsgi_resource = WSGIResource(self._reactor, self._reactor.getThreadPool(), app)
except Exception as e:
raise ApplicationError(u"crossbar.error.invalid_configuration", "could not instantiate WSGI resource: {}".format(e))
else:
return wsgi_resource
# Redirecting resource
#
elif path_config['type'] == 'redirect':
redirect_url = path_config['url'].encode('ascii', 'ignore')
return RedirectResource(redirect_url)
# JSON value resource
#
elif path_config['type'] == 'json':
value = path_config['value']
return JsonResource(value)
# CGI script resource
#
elif path_config['type'] == 'cgi':
cgi_processor = path_config['processor']
cgi_directory = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['directory']))
cgi_directory = cgi_directory.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770
return CgiDirectory(cgi_directory, cgi_processor, Resource404(self._templates, cgi_directory))
# WAMP-Longpoll transport resource
#
elif path_config['type'] == 'longpoll':
path_options = path_config.get('options', {})
lp_resource = WampLongPollResource(self._router_session_factory,
timeout=path_options.get('request_timeout', 10),
killAfter=path_options.get('session_timeout', 30),
queueLimitBytes=path_options.get('queue_limit_bytes', 128 * 1024),
queueLimitMessages=path_options.get('queue_limit_messages', 100),
debug=path_options.get('debug', False),
debug_transport_id=path_options.get('debug_transport_id', None)
)
lp_resource._templates = self._templates
return lp_resource
# Publisher resource (part of REST-bridge)
#
elif path_config['type'] == 'publisher':
# create a vanilla session: the publisher will use this to inject events
#
publisher_session_config = ComponentConfig(realm=path_config['realm'], extra=None)
publisher_session = ApplicationSession(publisher_session_config)
# add the publisher session to the router
#
self._router_session_factory.add(publisher_session, authrole=path_config.get('role', 'anonymous'))
# now create the publisher Twisted Web resource
#
return PublisherResource(path_config.get('options', {}), publisher_session)
# Webhook resource (part of REST-bridge)
#
elif path_config['type'] == 'webhook':
# create a vanilla session: the webhook will use this to inject events
#
webhook_session_config = ComponentConfig(realm=path_config['realm'], extra=None)
webhook_session = ApplicationSession(webhook_session_config)
# add the webhook session to the router
#
self._router_session_factory.add(webhook_session, authrole=path_config.get('role', 'anonymous'))
# now create the webhook Twisted Web resource
#
return WebhookResource(path_config.get('options', {}), webhook_session)
# Caller resource (part of REST-bridge)
#
elif path_config['type'] == 'caller':
# create a vanilla session: the caller will use this to inject calls
#
caller_session_config = ComponentConfig(realm=path_config['realm'], extra=None)
caller_session = ApplicationSession(caller_session_config)
# add the calling session to the router
#
self._router_session_factory.add(caller_session, authrole=path_config.get('role', 'anonymous'))
# now create the caller Twisted Web resource
#
return CallerResource(path_config.get('options', {}), caller_session)
# File Upload resource
#
elif path_config['type'] == 'upload':
upload_directory = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['directory']))
upload_directory = upload_directory.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770
if not os.path.isdir(upload_directory):
emsg = "configured upload directory '{}' in file upload resource isn't a directory".format(upload_directory)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
if 'temp_directory' in path_config:
temp_directory = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['temp_directory']))
temp_directory = temp_directory.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770
else:
temp_directory = os.path.abspath(tempfile.gettempdir())
temp_directory = os.path.join(temp_directory, 'crossbar-uploads')
if not os.path.exists(temp_directory):
os.makedirs(temp_directory)
if not os.path.isdir(temp_directory):
emsg = "configured temp directory '{}' in file upload resource isn't a directory".format(temp_directory)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
# file upload progress and finish events are published via this session
#
upload_session_config = ComponentConfig(realm=path_config['realm'], extra=None)
upload_session = ApplicationSession(upload_session_config)
self._router_session_factory.add(upload_session, authrole=path_config.get('role', 'anonymous'))
self.log.info("File upload resource started. Uploads to {upl} using temp folder {tmp}.", upl=upload_directory, tmp=temp_directory)
return FileUploadResource(upload_directory, temp_directory, path_config['form_fields'], upload_session, path_config.get('options', {}))
# Generic Twisted Web resource
#
elif path_config['type'] == 'resource':
try:
klassname = path_config['classname']
self.log.debug("Starting class '{}'".format(klassname))
c = klassname.split('.')
module_name, klass_name = '.'.join(c[:-1]), c[-1]
module = importlib.import_module(module_name)
make = getattr(module, klass_name)
return make(path_config.get('extra', {}))
except Exception as e:
emsg = "Failed to import class '{}' - {}".format(klassname, e)
self.log.error(emsg)
self.log.error("PYTHONPATH: {pythonpath}", pythonpath=sys.path)
raise ApplicationError(u"crossbar.error.class_import_failed", emsg)
# Schema Docs resource
#
elif path_config['type'] == 'schemadoc':
realm = path_config['realm']
if realm not in self.realm_to_id:
raise ApplicationError(u"crossbar.error.no_such_object", "No realm with URI '{}' configured".format(realm))
realm_id = self.realm_to_id[realm]
realm_schemas = self.realms[realm_id].session._schemas
return SchemaDocResource(self._templates, realm, realm_schemas)
# Nested subpath resource
#
elif path_config['type'] == 'path':
nested_paths = path_config.get('paths', {})
if '/' in nested_paths:
nested_resource = self.create_resource(nested_paths['/'])
else:
nested_resource = Resource()
# nest subpaths under the current entry
#
self.add_paths(nested_resource, nested_paths)
return nested_resource
else:
raise ApplicationError(u"crossbar.error.invalid_configuration", "invalid Web path type '{}'".format(path_config['type']))
def onMessage(msg):
assert not isinstance(msg, message.Unsubscribed)
return ApplicationSession.onMessage(handler, msg)
def __init__(self, config):
self.log.info('Backend.__init__(config={config})', config=config)
ApplicationSession.__init__(self, config)
def onDisconnect(self):
ApplicationSession.onDisconnect(self)
from twisted.internet import reactor
reactor.stop()
def __init__(self, config):
ApplicationSession.__init__(self)
self.config = config
self._bots = {}
self._bot_no = 0
def onMessage(msg):
if isinstance(msg, message.Unsubscribed):
unsubscribed_d.callback(msg)
return ApplicationSession.onMessage(handler, msg)
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.server_protocol = ServerProtocol(self)
def start_router_transport(self, id, config, details=None):
"""
Start a transport on this router.
:param id: The ID of the transport to start.
:type id: str
:param config: The transport configuration.
:type config: dict
"""
if self.debug:
log.msg(
"{}.start_router_transport".format(self.__class__.__name__),
id, config)
## prohibit starting a transport twice
##
if id in self.transports:
emsg = "ERROR: could not start transport - a transport with ID '{}'' is already running (or starting)".format(
id)
log.msg(emsg)
raise ApplicationError('crossbar.error.already_running', emsg)
## check configuration
##
try:
checkconfig.check_router_transport(config)
except Exception as e:
emsg = "ERROR: invalid router transport configuration ({})".format(
e)
log.msg(emsg)
raise ApplicationError("crossbar.error.invalid_configuration",
emsg)
else:
if self.debug:
log.msg("Starting {}-transport on router.".format(
config['type']))
## standalone WAMP-RawSocket transport
##
if config['type'] == 'rawsocket':
transport_factory = CrossbarWampRawSocketServerFactory(
self.session_factory, config)
transport_factory.noisy = False
## standalone WAMP-WebSocket transport
##
elif config['type'] == 'websocket':
transport_factory = CrossbarWampWebSocketServerFactory(
self.session_factory, self.config.extra.cbdir, config,
self._templates)
transport_factory.noisy = False
## Flash-policy file server pseudo transport
##
elif config['type'] == 'flashpolicy':
transport_factory = FlashPolicyFactory(
config.get('allowed_domain', None),
config.get('allowed_ports', None))
## WebSocket testee pseudo transport
##
elif config['type'] == 'websocket.testee':
transport_factory = WebSocketTesteeServerFactory(
config, self._templates)
## Stream testee pseudo transport
##
elif config['type'] == 'stream.testee':
transport_factory = StreamTesteeServerFactory()
## Twisted Web based transport
##
elif config['type'] == 'web':
options = config.get('options', {})
## create Twisted Web root resource
##
root_config = config['paths']['/']
root_type = root_config['type']
root_options = root_config.get('options', {})
## Static file hierarchy root resource
##
if root_type == 'static':
if 'directory' in root_config:
root_dir = os.path.abspath(
os.path.join(self.config.extra.cbdir,
root_config['directory']))
elif 'package' in root_config:
if not 'resource' in root_config:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"missing resource")
try:
mod = importlib.import_module(root_config['package'])
except ImportError as e:
emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(
root_config['resource'], root_config['package'], e)
log.msg(emsg)
raise ApplicationError(
"crossbar.error.invalid_configuration", emsg)
else:
try:
root_dir = os.path.abspath(
pkg_resources.resource_filename(
root_config['package'],
root_config['resource']))
except Exception as e:
emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(
root_config['resource'],
root_config['package'], e)
log.msg(emsg)
raise ApplicationError(
"crossbar.error.invalid_configuration", emsg)
else:
mod_version = getattr(mod, '__version__', '?.?.?')
log.msg(
"Loaded static Web resource '{}' from package '{} {}' (filesystem path {})"
.format(root_config['resource'],
root_config['package'], mod_version,
root_dir))
else:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"missing web spec")
root_dir = root_dir.encode(
'ascii',
'ignore') # http://stackoverflow.com/a/20433918/884770
if self.debug:
log.msg("Starting Web service at root directory {}".format(
root_dir))
## create resource for file system hierarchy
##
if root_options.get('enable_directory_listing', False):
root = File(root_dir)
else:
root = FileNoListing(root_dir)
## set extra MIME types
##
root.contentTypes.update(EXTRA_MIME_TYPES)
if 'mime_types' in root_options:
root.contentTypes.update(root_options['mime_types'])
patchFileContentTypes(root)
## render 404 page on any concrete path not found
##
root.childNotFound = Resource404(self._templates, root_dir)
## WSGI root resource
##
elif root_type == 'wsgi':
if not _HAS_WSGI:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"WSGI unsupported")
wsgi_options = root_config.get('options', {})
if not 'module' in root_config:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"missing module")
if not 'object' in root_config:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"missing object")
try:
mod = importlib.import_module(root_config['module'])
except ImportError:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"module import failed")
else:
if not root_config['object'] in mod.__dict__:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"object not in module")
else:
app = getattr(mod, root_config['object'])
## create a Twisted Web WSGI resource from the user's WSGI application object
try:
wsgi_resource = WSGIResource(reactor,
reactor.getThreadPool(), app)
except Exception as e:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"could not instantiate WSGI resource: {}".format(e))
else:
## create a root resource serving everything via WSGI
root = WSGIRootResource(wsgi_resource, {})
## Redirecting root resource
##
elif root_type == 'redirect':
redirect_url = root_config['url'].encode('ascii', 'ignore')
root = RedirectResource(redirect_url)
## Pusher resource
##
elif root_type == 'pusher':
## create a vanilla session: the pusher will use this to inject events
##
pusher_session_config = ComponentConfig(
realm=root_config['realm'], extra=None)
pusher_session = ApplicationSession(pusher_session_config)
## add the pushing session to the router
##
self.session_factory.add(pusher_session,
authrole=root_config.get(
'role', 'anonymous'))
## now create the pusher Twisted Web resource and add it to resource tree
##
root = PusherResource(root_config.get('options', {}),
pusher_session)
## Invalid root resource
##
else:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"invalid Web root path type '{}'".format(root_type))
## create Twisted Web resources on all non-root paths configured
##
self.add_paths(root, config.get('paths', {}))
## create the actual transport factory
##
transport_factory = Site(root)
transport_factory.noisy = False
## Web access logging
##
if not options.get('access_log', False):
transport_factory.log = lambda _: None
## Traceback rendering
##
transport_factory.displayTracebacks = options.get(
'display_tracebacks', False)
## HSTS
##
if options.get('hsts', False):
if 'tls' in config['endpoint']:
hsts_max_age = int(options.get('hsts_max_age', 31536000))
transport_factory.requestFactory = createHSTSRequestFactory(
transport_factory.requestFactory, hsts_max_age)
else:
log.msg(
"Warning: HSTS requested, but running on non-TLS - skipping HSTS"
)
## enable Hixie-76 on Twisted Web
##
if options.get('hixie76_aware', False):
transport_factory.protocol = HTTPChannelHixie76Aware # needed if Hixie76 is to be supported
## Unknown transport type
##
else:
## should not arrive here, since we did check_transport() in the beginning
raise Exception("logic error")
## create transport endpoint / listening port from transport factory
##
d = create_listening_port_from_config(config['endpoint'],
transport_factory,
self.config.extra.cbdir, reactor)
def ok(port):
self.transports[id] = RouterTransport(id, config,
transport_factory, port)
if self.debug:
log.msg(
"Router transport '{}'' started and listening".format(id))
return
def fail(err):
emsg = "ERROR: cannot listen on transport endpoint ({})".format(
err.value)
log.msg(emsg)
raise ApplicationError("crossbar.error.cannot_listen", emsg)
d.addCallbacks(ok, fail)
return d
def __init__(self, signup, *args):
self.signup = signup
ApplicationSession.__init__(self, *args)
def create_resource(self, path_config):
"""
Creates child resource to be added to the parent.
:param path_config: Configuration for the new child resource.
:type path_config: dict
:returns: Resource -- the new child resource
"""
## WAMP-WebSocket resource
##
if path_config['type'] == 'websocket':
ws_factory = CrossbarWampWebSocketServerFactory(
self.session_factory, self.config.extra.cbdir, path_config,
self._templates)
## FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
ws_factory.startFactory()
return WebSocketResource(ws_factory)
## Static file hierarchy resource
##
elif path_config['type'] == 'static':
static_options = path_config.get('options', {})
if 'directory' in path_config:
static_dir = os.path.abspath(
os.path.join(self.config.extra.cbdir,
path_config['directory']))
elif 'package' in path_config:
if not 'resource' in path_config:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"missing resource")
try:
mod = importlib.import_module(path_config['package'])
except ImportError as e:
emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(
path_config['resource'], path_config['package'], e)
log.msg(emsg)
raise ApplicationError(
"crossbar.error.invalid_configuration", emsg)
else:
try:
static_dir = os.path.abspath(
pkg_resources.resource_filename(
path_config['package'],
path_config['resource']))
except Exception as e:
emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(
path_config['resource'], path_config['package'], e)
log.msg(emsg)
raise ApplicationError(
"crossbar.error.invalid_configuration", emsg)
else:
raise ApplicationError("crossbar.error.invalid_configuration",
"missing web spec")
static_dir = static_dir.encode(
'ascii',
'ignore') # http://stackoverflow.com/a/20433918/884770
## create resource for file system hierarchy
##
if static_options.get('enable_directory_listing', False):
static_resource = File(static_dir)
else:
static_resource = FileNoListing(static_dir)
## set extra MIME types
##
static_resource.contentTypes.update(EXTRA_MIME_TYPES)
if 'mime_types' in static_options:
static_resource.contentTypes.update(
static_options['mime_types'])
patchFileContentTypes(static_resource)
## render 404 page on any concrete path not found
##
static_resource.childNotFound = Resource404(
self._templates, static_dir)
return static_resource
## WSGI resource
##
elif path_config['type'] == 'wsgi':
if not _HAS_WSGI:
raise ApplicationError("crossbar.error.invalid_configuration",
"WSGI unsupported")
wsgi_options = path_config.get('options', {})
if not 'module' in path_config:
raise ApplicationError("crossbar.error.invalid_configuration",
"missing module")
if not 'object' in path_config:
raise ApplicationError("crossbar.error.invalid_configuration",
"missing object")
try:
mod = importlib.import_module(path_config['module'])
except ImportError as e:
raise ApplicationError("crossbar.error.invalid_configuration",
"module import failed - {}".format(e))
else:
if not path_config['object'] in mod.__dict__:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"object not in module")
else:
app = getattr(mod, path_config['object'])
## create a Twisted Web WSGI resource from the user's WSGI application object
try:
wsgi_resource = WSGIResource(reactor, reactor.getThreadPool(),
app)
except Exception as e:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"could not instantiate WSGI resource: {}".format(e))
else:
return wsgi_resource
## Redirecting resource
##
elif path_config['type'] == 'redirect':
redirect_url = path_config['url'].encode('ascii', 'ignore')
return RedirectResource(redirect_url)
## JSON value resource
##
elif path_config['type'] == 'json':
value = path_config['value']
return JsonResource(value)
## CGI script resource
##
elif path_config['type'] == 'cgi':
cgi_processor = path_config['processor']
cgi_directory = os.path.abspath(
os.path.join(self.config.extra.cbdir,
path_config['directory']))
cgi_directory = cgi_directory.encode(
'ascii',
'ignore') # http://stackoverflow.com/a/20433918/884770
return CgiDirectory(cgi_directory, cgi_processor,
Resource404(self._templates, cgi_directory))
## WAMP-Longpoll transport resource
##
elif path_config['type'] == 'longpoll':
path_options = path_config.get('options', {})
lp_resource = WampLongPollResource(
self.session_factory,
timeout=path_options.get('request_timeout', 10),
killAfter=path_options.get('session_timeout', 30),
queueLimitBytes=path_options.get('queue_limit_bytes',
128 * 1024),
queueLimitMessages=path_options.get('queue_limit_messages',
100),
debug=path_options.get('debug', False),
debug_transport_id=path_options.get('debug_transport_id',
None))
lp_resource._templates = self._templates
return lp_resource
## Pusher resource
##
elif path_config['type'] == 'pusher':
## create a vanilla session: the pusher will use this to inject events
##
pusher_session_config = ComponentConfig(realm=path_config['realm'],
extra=None)
pusher_session = ApplicationSession(pusher_session_config)
## add the pushing session to the router
##
self.session_factory.add(pusher_session,
authrole=path_config.get(
'role', 'anonymous'))
## now create the pusher Twisted Web resource
##
return PusherResource(path_config.get('options', {}),
pusher_session)
## Schema Docs resource
##
elif path_config['type'] == 'schemadoc':
realm = path_config['realm']
if not realm in self.realm_to_id:
raise ApplicationError(
"crossbar.error.no_such_object",
"No realm with URI '{}' configured".format(realm))
realm_id = self.realm_to_id[realm]
realm_schemas = self.realms[realm_id].session._schemas
return SchemaDocResource(self._templates, realm, realm_schemas)
## Nested subpath resource
##
elif path_config['type'] == 'path':
nested_paths = path_config.get('paths', {})
if '/' in nested_paths:
nested_resource = self.create_resource(nested_paths['/'])
else:
nested_resource = Resource()
## nest subpaths under the current entry
##
self.add_paths(nested_resource, nested_paths)
return nested_resource
else:
raise ApplicationError(
"crossbar.error.invalid_configuration",
"invalid Web path type '{}'".format(path_config['type']))
def __init__(self):
ApplicationSession.__init__(self)
def __init__(self, realm="realm1"):
ApplicationSession.__init__(self)
self._realm = realm
self.received = 0
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.init()
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.init()
self.games = MultiplayerGames()