def start_from_config(self, config):
controller_config = config.get('controller', {})
controller_options = controller_config.get('options', {})
controller_title = controller_options.get('title',
'crossbar-controller')
try:
import setproctitle
except ImportError:
log.msg(
"Warning, could not set process title (setproctitle not installed)"
)
else:
setproctitle.setproctitle(controller_title)
## the node's name (must be unique within the management realm)
if 'id' in controller_config:
self._node_id = controller_config['id']
else:
self._node_id = socket.gethostname()
## the node's management realm
self._realm = controller_config.get('realm', 'crossbar')
## the node controller singleton WAMP application session
##
#session_config = ComponentConfig(realm = options.realm, extra = options)
self._controller = NodeControllerSession(self)
## router and factory that creates router sessions
##
self._router_factory = RouterFactory(options=wamp.types.RouterOptions(
uri_check=wamp.types.RouterOptions.URI_CHECK_LOOSE),
debug=False)
self._router_session_factory = RouterSessionFactory(
self._router_factory)
## add the node controller singleton session to the router
##
self._router_session_factory.add(self._controller)
## Detect WAMPlets
##
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
log.msg("Detected {} WAMPlets in environment:".format(
len(wamplets)))
for wpl in wamplets:
log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name']))
else:
log.msg("No WAMPlets detected in enviroment.")
self.run_node_config(config)
def setUp(self):
"""
Setup router and router session factories.
"""
if USE_ASYNCIO:
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.router_factory = RouterFactory()
self.session_factory = RouterSessionFactory(self.router_factory)
def wampServ(wampAddress, wampPort, wampDebug = False):
"""
Sets up an Autobahn|Python WAMPv2 server.
Code modified from WAMP documentation.
"""
from twisted.internet.endpoints import serverFromString
from autobahn.wamp.router import RouterFactory
from autobahn.twisted.wamp import RouterSessionFactory
from autobahn.twisted.websocket import WampWebSocketServerFactory
## create a WAMP router factory
router_factory = RouterFactory()
## create a WAMP router session factory
session_factory = RouterSessionFactory(router_factory)
## create a WAMP-over-WebSocket transport server factory
transport_factory = WampWebSocketServerFactory(session_factory, wampAddress, debug = wampDebug)
transport_factory.setProtocolOptions(failByDrop = False)
## Start websocket server
server = serverFromString(reactor, wampPort)
server.listen(transport_factory)
## we use an Autobahn utility to install the "best" available Twisted reactor
##
from autobahn.twisted.choosereactor import install_reactor
reactor = install_reactor()
print("Running on reactor {}".format(reactor))
## create a WAMP router factory
##
from autobahn.twisted.wamp import RouterFactory
router_factory = RouterFactory()
## create a WAMP router session factory
##
from autobahn.twisted.wamp import RouterSessionFactory
session_factory = RouterSessionFactory(router_factory)
## create a WAMP-over-WebSocket transport server factory
##
from autobahn.twisted.websocket import WampWebSocketServerFactory
transport_factory = WampWebSocketServerFactory(session_factory,
debug=args.debug)
transport_factory.setProtocolOptions(failByDrop=False)
## start the server from an endpoint
##
server = serverFromString(reactor, args.endpoint)
server.listen(transport_factory)
## now enter the Twisted reactor loop
##
def test_minimal(self):
embedded_components, client_components = [], [
Case2_Backend, Case2_Frontend
]
## create a WAMP router factory
##
router_factory = RouterFactory()
## create a WAMP router session factory
##
session_factory = RouterSessionFactory(router_factory)
## .. and create and add an WAMP application session to
## run next to the router
##
config = types.ComponentConfig(realm=self.realm,
extra={'caselog': 'case1.log'})
try:
log = io.open('caselog.log', 'w')
except Exception as e:
print(e)
return
# log = io.open(config.extra['caselog'], 'w')
config.log = log
config.dlog = []
config.components = []
config.all_done = []
for C in embedded_components:
one_done = Deferred()
config.all_done.append(one_done)
c = C(config, one_done)
config.components.append(c)
session_factory.add(c)
if self.transport == "websocket":
## create a WAMP-over-WebSocket transport server factory
##
transport_factory = WampWebSocketServerFactory(
session_factory, debug_wamp=self.debug)
transport_factory.setProtocolOptions(failByDrop=False,
openHandshakeTimeout=0,
closeHandshakeTimeout=0)
elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']:
## create a WAMP-over-RawSocket transport server factory
##
if self.transport == 'rawsocket-msgpack':
serializer = MsgPackSerializer()
elif self.transport == 'rawsocket-json':
serializer = JsonSerializer()
else:
raise Exception("should not arrive here")
transport_factory = WampRawSocketServerFactory(
session_factory, serializer, debug=self.debug)
else:
raise Exception("should not arrive here")
## start the server from an endpoint
##
from twisted.internet import reactor
server = serverFromString(reactor, self.server)
d = server.listen(transport_factory)
def onlisten(port):
config.port = port
d.addCallback(onlisten)
clients = []
clients_d = []
for C in client_components:
## create a WAMP application session factory
##
session_factory = ApplicationSessionFactory(config)
one_done = Deferred()
config.all_done.append(one_done)
def make_make(Klass, done):
def make(config):
c = Klass(config, done)
config.components.append(c)
return c
return make
## .. and set the session class on the factory
##
session_factory.session = make_make(C, one_done)
if self.transport == "websocket":
serializers = [JsonSerializer()]
## create a WAMP-over-WebSocket transport client factory
##
transport_factory = WampWebSocketClientFactory(
session_factory,
serializers=serializers,
url=self.url,
debug_wamp=self.debug)
if True:
def maker(Klass):
class TestClientProtocol(
WampWebSocketClientProtocol):
def onOpen(self):
self.txcnt = 0
self.rxcnt = 0
WampWebSocketClientProtocol.onOpen(self)
def sendMessage(self, bytes, isBinary):
self.txcnt += 1
print("> : {:>3} : {:<20} : {}".format(
self.txcnt, Klass.__name__, bytes))
WampWebSocketClientProtocol.sendMessage(
self, bytes, isBinary)
def onMessage(self, bytes, isBinary):
self.rxcnt += 1
print("< : {:>3} : {:<20} : {}".format(
self.rxcnt, Klass.__name__, bytes))
WampWebSocketClientProtocol.onMessage(
self, bytes, isBinary)
return TestClientProtocol
transport_factory.protocol = maker(C)
else:
transport_factory.protocol = WampWebSocketClientProtocol
transport_factory.setProtocolOptions(
failByDrop=False,
openHandshakeTimeout=0,
closeHandshakeTimeout=0)
elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']:
## create a WAMP-over-RawSocket transport client factory
##
if self.transport == 'rawsocket-msgpack':
serializer = MsgPackSerializer()
elif self.transport == 'rawsocket-json':
serializer = JsonSerializer()
else:
raise Exception("should not arrive here")
transport_factory = WampRawSocketClientFactory(
session_factory, serializer, debug=self.debug)
## start the client from an endpoint
##
cl = clientFromString(reactor, self.client)
clients_d.append(cl.connect(transport_factory))
clients.append(cl)
config.connected_clients = None
def client_connected(res):
config.connected_clients = [
proto for success, proto in res if success
]
DeferredList(clients_d).addCallback(client_connected)
d = DeferredList(config.all_done, consumeErrors=True)
#d = config.components[1]._done
def done(res):
log.flush()
log.close()
if config.port:
config.port.stopListening()
if config.connected_clients:
for proto in config.connected_clients:
proto.transport.abortConnection()
print("Log length: {}".format(len(config.dlog)))
print(config.dlog)
#from twisted.internet import reactor
#reactor.callLater(1, reactor.stop)
def error(err):
print(err)
d.addCallbacks(done, error)
# d2 = Deferred()
return d
def start_webserver(options,
protocol=vtk_wamp.ServerProtocol,
disableLogging=False):
"""
Starts the web-server with the given protocol. Options must be an object
with the following members:
options.host : the interface for the web-server to listen on
options.port : port number for the web-server to listen on
options.timeout : timeout for reaping process on idle in seconds
options.content : root for web-pages to serve.
"""
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
import sys
if not disableLogging:
log.startLogging(sys.stdout)
contextFactory = None
use_SSL = False
if options.sslKey and options.sslCert:
use_SSL = True
wsProtocol = "wss"
from twisted.internet import ssl
contextFactory = ssl.DefaultOpenSSLContextFactory(
options.sslKey, options.sslCert)
else:
wsProtocol = "ws"
# Create WAMP router factory
from autobahn.twisted.wamp import RouterFactory
router_factory = RouterFactory()
# create a user DB
authdb = vtk_wamp.AuthDb()
# create a WAMP router session factory
from autobahn.twisted.wamp import RouterSessionFactory
session_factory = RouterSessionFactory(router_factory)
session_factory.session = vtk_wamp.CustomWampCraRouterSession
session_factory.authdb = authdb
# Create ApplicationSession and register protocols
appSession = protocol(types.ComponentConfig(realm="vtkweb"))
appSession.setAuthDB(authdb)
session_factory.add(appSession)
# create a WAMP-over-WebSocket transport server factory
transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \
url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \
debug = options.debug, \
debug_wamp = options.debug, \
timeout = options.timeout )
root = Resource()
# Do we serve static content or just websocket ?
if len(options.content) > 0:
# Static HTTP + WebSocket
root = File(options.content)
# Handle possibly complex ws endpoint
if not options.nows:
wsResource = WebSocketResource(transport_factory)
handle_complex_resource_path(options.ws, root, wsResource)
# Handle possibly complex lp endpoint
if not options.nolp:
lpResource = WampLongPollResource(session_factory)
handle_complex_resource_path(options.lp, root, lpResource)
if options.uploadPath != None:
from upload import UploadPage
uploadResource = UploadPage(options.uploadPath)
root.putChild("upload", uploadResource)
site = Site(root)
if use_SSL:
reactor.listenSSL(options.port, site, contextFactory)
else:
reactor.listenTCP(options.port, site)
# Work around to force the output buffer to be flushed
# This allow the process launcher to parse the output and
# wait for "Start factory" to know that the WebServer
# is running.
if options.forceFlush:
for i in range(200):
log.msg("+" * 80, logLevel=logging.CRITICAL)
# Initialize testing: checks if we're doing a test and sets it up
testing.initialize(options, reactor, stop_webserver)
# Start the reactor
if options.nosignalhandlers:
reactor.run(installSignalHandlers=0)
else:
reactor.run()
# Give the testing module a chance to finalize, if necessary
testing.finalize()
def run():
import sys, argparse
from twisted.python import log
from twisted.internet.endpoints import serverFromString
## parse command line arguments
##
def_wsocket = 'ws://127.0.0.1:8080/ws'
def_xsocket = None
def_user = '******'
def_secret = '123test'
def_realm = 'realm1'
def_topic_base = 'sys'
def_dsn = 'dbname=autobahn host=localhost user=autouser'
def_endpoint = 'tcp:8080'
def_engine = 'PG9_4'
p = argparse.ArgumentParser(
description="basicrouter example with database")
p.add_argument('-w',
'--websocket',
action='store',
dest='wsocket',
default=def_wsocket,
help='web socket ' + def_wsocket)
p.add_argument('-x',
'--xsocket',
action='store',
dest='xsocket',
default=def_xsocket,
help='x socket definition, default is: None ')
p.add_argument('-r',
'--realm',
action='store',
dest='realm',
default=def_realm,
help='connect to websocket using "realm", default ' +
def_realm)
p.add_argument('-v',
'--verbose',
action='store_true',
dest='verbose',
default=False,
help='Verbose logging for debugging')
p.add_argument('-u',
'--user',
action='store',
dest='user',
default=def_user,
help='connect to websocket as user, default is: ' +
def_user)
p.add_argument('-s',
'--secret',
action='store',
dest='password',
default=def_secret,
help='users "secret" password')
p.add_argument('--debug',
action='store_true',
dest='debug',
default=False,
help='Autobahn layer debugging')
p.add_argument(
'-e',
'--engine',
action='store',
dest='engine',
default=def_engine,
help=
'if specified, a database engine will be attached. Note engine is rooted on --topic'
)
p.add_argument(
"--endpoint",
type=str,
default="tcp:8080",
help=
'Twisted server endpoint descriptor, e.g. "tcp:8080" or "unix:/tmp/mywebsocket", default is "'
+ def_endpoint + '"')
p.add_argument(
'-d',
'--dsn',
action='store',
dest='dsn',
default=def_dsn,
help='if specified the database in dsn will be connected and ready')
p.add_argument(
'-t',
'--topic',
action='store',
dest='topic_base',
default=def_topic_base,
help=
'if you specify --dsn then you will need a topic to root it on, the default '
+ def_topic_base + ' is fine.')
args = p.parse_args()
if args.verbose:
log.startLogging(sys.stdout)
## we use an Autobahn utility to install the "best" available Twisted reactor
##
from autobahn.twisted.choosereactor import install_reactor
reactor = install_reactor()
log.msg("Running on reactor {}".format(reactor))
# database workers...
userdb = UserDb(topic_base=args.topic_base + '.db', debug=args.verbose)
sessiondb = SessionDb(topic_base=args.topic_base, debug=args.verbose)
## create a WAMP router factory
##
component_config = types.ComponentConfig(realm=args.realm)
xomponent_config = types.ComponentConfig(realm=args.realm)
ai = {
'auth_type': 'wampcra',
'auth_user': args.user,
'auth_password': args.password
}
from autobahn.twisted.wamp import RouterFactory
router_factory = RouterFactory()
authorization_session = AuthorizeSession(component_config,
topic_base=args.topic_base +
'.db',
debug=args.verbose,
db=sessiondb,
router=AuthorizeRouter)
router_factory.router = authorization_session.ret_func
## create a WAMP router session factory
##
from autobahn.twisted.wamp import RouterSessionFactory
session_factory = RouterSessionFactory(router_factory)
session_factory.session = MyRouterSession
log.msg("session_factory.session")
session_factory.userdb = userdb
session_factory.sessiondb = sessiondb
log.msg("userdb, sessiondb")
sessiondb_component = SessionData(component_config,
session_factory.sessiondb,
topic_base=args.topic_base)
session_factory.add(sessiondb_component)
session_factory.add(authorization_session)
log.msg("session_factory")
db_session = DB(component_config,
engine=args.engine,
topic_base=args.topic_base + '.db',
dsn=args.dsn,
debug=args.verbose)
session_factory.add(db_session)
session_factory.userdb.set_session(db_session)
session_factory.sessiondb.set_session(db_session)
## create a WAMP-over-WebSocket transport server factory
##
from autobahn.twisted.websocket import WampWebSocketServerFactory
transport_factory = WampWebSocketServerFactory(session_factory,
debug=args.debug)
transport_factory.setProtocolOptions(failByDrop=False)
## start the server from an endpoint
##
## this address clash detection was a goody I got from stackoverflow:
## http://stackoverflow.com/questions/12007316/exiting-twisted-application-after-listenfailure
server = serverFromString(reactor, args.endpoint)
def listen():
srv = server.listen(transport_factory)
def ListenFailed(reason):
log.msg("On Startup Listen Failed with {}".format(reason))
reactor.stop()
srv.addErrback(ListenFailed)
def addsession():
log.msg("here are three sessions {} {} {}".format(
authorization_session, sessiondb_component, db_session))
qv = {
"sessiondb_component": sessiondb_component._session_id,
"db_session": db_session._session_id,
"authorization_session": authorization_session._session_id
}
session_factory.sessiondb.set_system_sessions(qv)
session_factory.sessiondb.add(0, sessiondb_component._session_id,
sessiondb_component)
session_factory.sessiondb.add(0, db_session._session_id, db_session)
session_factory.sessiondb.add(0, authorization_session._session_id,
authorization_session)
reactor.callWhenRunning(listen)
reactor.callWhenRunning(addsession)
# if we set this router to be mastered by another, then start communicating with it
if args.xsocket is not None:
xdb = Xomponent(config=xomponent_config,
authinfo=ai,
topic_base=args.topic_base,
debug=args.verbose,
command='session',
action='list',
action_args={})
xdb.set_session(db_session)
runner = ApplicationRunner(args.xsocket, args.realm)
runner.run(lambda _: xdb, start_reactor=False)
reactor.run()
yield self.register(Sketch_Stop, u"allofw.sketch.stop")
yield self.register(Sketch_List, u"allofw.sketch.list")
yield self.register(Sketch_GetCode, u"allofw.sketch.get_code")
yield self.register(Project_List, u"allofw.project.list")
yield self.register(Project_Delete, u"allofw.project.delete")
yield self.register(Project_UploadFile, u"allofw.project.upload_file")
yield self.register(Project_RenameFile, u"allofw.project.rename_file")
yield self.register(Project_ListFiles, u"allofw.project.list_files")
yield self.register(Project_LoadProject,
u"allofw.project.load_project")
yield self.register(Project_SaveProject,
u"allofw.project.save_project")
root = File("static")
session_factory = RouterSessionFactory(RouterFactory())
component_config = types.ComponentConfig(realm="anonymous")
session_factory.add(AllofwServer(component_config))
factory = WampWebSocketServerFactory(session_factory)
factory.startFactory()
resource = WebSocketResource(factory)
root.putChild("ws", resource)
site = Site(root)
reactor.listenTCP(int(config['webserver']['port']),
site,
interface=config['webserver']['listen'])
reactor.run()
