def setUp():
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
try:
import autobahn
import twisted
except ImportError:
sys.exit("Install all dependencies")
root = Resource()
# root.putChild(constants.WEB_DYNAMIC_BRANCH, resource)
from autobahn.twisted.resource import WebSocketResource, HTTPChannelHixie76Aware
from twisted.web.server import Site
factory = BroadcastServerFactory("ws://127.0.0.1:8888", debug=debug, debugCodePaths=debug)
#если используется proxy
#factory.proxy={'host': '192.168.200.105', 'port': '8088'}
factory.protocol = BroadcastServerProtocol
factory.setProtocolOptions(allowHixie76=True)
ws_resource = WebSocketResource(factory)
root.putChild("ws", ws_resource)
site = Site(root)
site.protocol = HTTPChannelHixie76Aware
listenWS(factory)
reactor.run()
def test_no_self_connect():
"""
Test that when a producer connects, the consumer sends all existing
subscription to it.
"""
class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory):
protocol = wamp.WampServerProtocol
id = generate_id()
consumer = ConsumerServer('localhost', 19200, id=id)
consumer.processor = WampConsumerServerFactory('ws://localhost:19202')
listenWS(consumer.processor)
producer = ProducerClient(id=id)
deferLater(reactor, 0.5, producer.connect, 'localhost', 19200)
def check_connection():
"""
Make sure producer has no connections, because it's been controlled.
"""
print(set(producer.nodes))
assert set(producer.nodes) == set()
return deferLater(reactor, 1.0, check_connection)
def setUp():
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
try:
import autobahn
import twisted
except ImportError:
sys.exit("Install all dependencies")
from orm.database_init import init_db, db_session
from apps.web import constants
init_db()
from pdb import set_trace
set_trace()
from apps.web import main_resource
root = main_resource.Root()
reactor.listenTCP(8000, server.Site(main_resource.Root()))
factory = BroadcastServerFactory("ws://127.0.0.1:8011", debug=debug, debugCodePaths=debug)
factory.protocol = BroadcastServerProtocol
factory.setProtocolOptions(allowHixie76=True)
ws_resource = WebSocketResource(factory)
root.putChild("ws", ws_resource)
site = Site(root)
site.protocol = HTTPChannelHixie76Aware
listenWS(factory)
reactor.run()
def startServer(self, webport, debug = False):
## WAMP Server for wsperf slaves
##
wsperf = WsPerfMasterFactory("ws://localhost:9090")
wsperf.debugWsPerf = debug
listenWS(wsperf)
## Web Server for UI static files
##
if webport:
webdir = File(pkg_resources.resource_filename("autobahntestsuite", "web/wsperfmaster"))
web = Site(webdir)
reactor.listenTCP(webport, web)
## WAMP Server for UI
##
wsperfUi = WsPerfMasterUiFactory("ws://localhost:9091")
wsperfUi.debug = debug
wsperfUi.debugWamp = debug
listenWS(wsperfUi)
## Connect servers
##
wsperf.uiFactory = wsperfUi
wsperfUi.slaveFactory = wsperf
def __init__(self, interface, port, id=None):
self.nodes = WeakSet()
url = 'ws://{0}:{1}/'.format(interface, port)
log.msg('pubsubclub: Listening on %s' % url)
websocket.WebSocketServerFactory.__init__(self, url)
websocket.listenWS(self)
self.id = id
def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.clients = [] self.tickGap = 5 self.tickSetup() listenWS(self)
def run(self):
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
global cam
ServerFactory = BroadcastServerFactory
# ServerFactory = BroadcastPreparedServerFactory
factory = ServerFactory("ws://localhost:9000",
debug=debug,
debugCodePaths=debug)
factory.protocol = BroadcastServerProtocol
factory.setProtocolOptions(allowHixie76=True)
listenWS(factory)
path = os.path.join(os.path.curdir,"www")
print path
webdir = File(path)
web = Site(webdir)
reactor.listenTCP(8000, web)
reactor.run()
cam.stop_recording()
cam.close()
def execute(self):
factory = WampServerFactory("ws://localhost:17998", debug = False, debugWamp = False)
factory.protocol = PlywoodWebSocketServerProtocol
factory.setProtocolOptions(allowHixie76 = True)
listenWS(factory)
reactor.run(installSignalHandlers=0)
def startServer(wsuri, sslKey = None, sslCert = None, debug = False):
factory = TesteeServerFactory(wsuri, debug)
if sslKey and sslCert:
sslContext = ssl.DefaultOpenSSLContextFactory(sslKey, sslCert)
else:
sslContext = None
listenWS(factory, sslContext)
return True
def serve_web():
listenWS(factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(8080, web)
reactor.run()
def init_networking(self):
factory = BroadcastServerFactory("ws://{}:{}".format(self.config['host'], self.config['port']))
factory.world = self.world
factory.game = self
self.world.networking_factory = factory
factory.cache = MessageCache(self.world)
factory.protocol = UserCommunication
listenWS(factory)
logging.info("Server is listening on %s:%i" % (factory.host, factory.port))
def __init__(self):
print '\nRunning notification server in port 8182'
factory = WebSocketServerFactory('ws://localhost:8182')
factory.protocol = ServiceServerProtocol
listenWS(factory)
try:
reactor.run(installSignalHandlers=0)
except KeyboardInterrupt:
reactor.stop()
def listen(cls, uri, apps, allowHixie76=False, debug=False):
with log.enter(obj=cls) as tm:
global server_factory
url = urlparse.urlparse(uri)
server_factory = ServerFactory(uri, apps, debug=debug)
server_factory.protocol = cls
server_factory.setProtocolOptions(allowHixie76=allowHixie76)
listenWS(server_factory)
server_factory.internal_client = InternalClientProtocol.connect(uri, debug)
return server_factory
def start_echo_server():
factory = WebSocketServerFactory('ws://0.0.0.0:9000',
debug = False)
factory.protocol = EchoServerProtocol
thread = EchoThread()
# thread.start()
listenWS(factory)
print 'listening'
def setupWebSocket( address, engine, protocol ): ''' Listen for WebSocket connections at the given address. ''' factory = WebSocketServerFactory( address ) factory.engine = engine factory.protocol = protocol listenWS( factory ) print "Listening for WebSocket connections at:", address
def spawnWebsocketServer(uri, logLevel, protocol, externalPort=None): if logLevel == "DEBUG": isDebug = True else: isDebug = False factory = WebSocketServerFactory(uri, debug=isDebug, externalPort=externalPort) factory.protocol = protocol factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression) listenWS(factory) reactor.run()
def startServer(wsuri, sslKey = None, sslCert = None, debug = False):
factory = BroadcastServerFactory(wsuri, debug)
if sslKey and sslCert:
sslContext = ssl.DefaultOpenSSLContextFactory(sslKey, sslCert)
else:
sslContext = None
listenWS(factory, sslContext)
webdir = File(pkg_resources.resource_filename("autobahntestsuite", "web/broadcastserver"))
web = Site(webdir)
reactor.listenTCP(8080, web)
return True
def startService(self):
# here the channel requested from the websocket is passed to the redis conn
# basically, the listeners of websockets and redis messages are coupled here
def onMessageReceived(message):
msg = dict(channel=self.channel, message=message)
self.wsfactory.broadcast(msg)
self.redisFactory.onMessageReceived = onMessageReceived
# start listening for websocket connections
listenWS(self.wsfactory)
# connect to redis
self.redisFactory.connectTCP(self.channel, reactor)
def _start_server(self):
"""
Start shotgun web server, listening to websocket connections.
:param debug: Boolean Show debug output. Will also Start local web server to test client pages.
"""
cert_crt_path, cert_key_path = certificates.get_certificate_file_names(self._keys_path)
self._raise_if_missing_certificate(cert_key_path)
self._raise_if_missing_certificate(cert_crt_path)
# SSL server context: load server key and certificate
self.context_factory = ssl.DefaultOpenSSLContextFactory(cert_key_path,
cert_crt_path)
# FIXME: Seems like the debugging flags are gone from the initializer at the moment.
# We should try to restore these.
self.factory = WebSocketServerFactory(
"wss://localhost:%d" % self._port
)
self.factory.protocol = ServerProtocol
self.factory.host = self._host
self.factory.host_aliases = self._host_aliases
self.factory.user_id = self._user_id
self.factory.notifier = self.notifier
self.factory.ws_server_id = self._ws_server_id
self.factory.setProtocolOptions(echoCloseCodeReason=True)
try:
self.listener = listenWS(self.factory, self.context_factory)
except error.CannotListenError, e:
raise PortBusyError(str(e))
def run(self):
#import gc
#gc.enable()
#gc.set_debug(gc.DEBUG_LEAK)
# Registers the memory statistics function
super(WebSocketServer, self).run()
factory = self.factory(self.uri, self.extPort)
factory.protocol = self.protocol
factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression)
# This has to be in the child process
listener = listenWS(factory)
def tearDown():
# callback to stopListening
def stopReactor():
if reactor.running:
reactor.stop
d = listener.stopListening()
d.addCallback(stopReactor)
reactor.addSystemEventTrigger('before', 'shutdown', tearDown)
reactor.run()
def _start_server(self):
"""
Start shotgun web server, listening to websocket connections.
:param debug: Boolean Show debug output. Will also Start local web server to test client pages.
"""
cert_crt_path, cert_key_path = certificates.get_certificate_file_names(self._keys_path)
self._raise_if_missing_certificate(cert_key_path)
self._raise_if_missing_certificate(cert_crt_path)
# SSL server context: load server key and certificate
self.context_factory = ssl.DefaultOpenSSLContextFactory(cert_key_path,
cert_crt_path)
self.factory = WebSocketServerFactory(
"wss://localhost:%d" % self._port, debug=self._debug, debugCodePaths=self._debug
)
self.factory.protocol = ServerProtocol
self.factory.websocket_server_whitelist = self._whitelist
self.factory.setProtocolOptions(allowHixie76=True, echoCloseCodeReason=True)
try:
self.listener = listenWS(self.factory, self.context_factory)
except error.CannotListenError, e:
raise PortBusyError(str(e))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--url', default='ws://localhost:9001', help='Listen URL [default: %(default)s]')
parser.add_argument('-O', '--options', default=jsondict({'failByDrop':False}), type=jsondict, action='append', help='extra options (overwrites existing) [default: %(default)s]')
parser.add_argument('-p', '--webport', default=9090, type=int)
parser.add_argument('-i', '--listen-interface', default='localhost', help='interface to listen on')
parser.add_argument('-w', '--webdir', default='.')
parser.add_argument('-d', '--debug', default=False, action='store_true', help='Debug Mode [default: %(default)s]')
parser.add_argument('-o', '--outdir', default='./pages/results', metavar='DIR', help='Output Directory [default: %(default)s]')
parser.add_argument('-c', '--cases', default=['*'], nargs='+', help='test cases [default: %(default)s]')
parser.add_argument('-x', '--exclude-cases', default=[], nargs='+', help='test cases to exclude [default: %(default)s]')
parser.add_argument('-l', '--logfile', type=argparse.FileType('w'), default=sys.stdout, help='logging file [default: stdout]')
parser.add_argument('-t', '--exit-timeout', metavar='SECONDS', default=None, type=float, help='Will automatically exit after %(metavar)s seconds [default: %(default)s]')
args = parser.parse_args()
spec = args.__dict__
log.startLogging(args.logfile)
## fuzzing server
fuzzer = FuzzingServerFactory(spec)
listenWS(fuzzer, interface=args.listen_interface)
## web server
webdir = File(args.webdir)
web = Site(webdir)
reactor.listenTCP(args.webport, web, interface=args.listen_interface)
log.msg("Using Twisted reactor class %s" % str(reactor.__class__))
if args.exit_timeout:
def exit_callback():
log.msg("Exiting due to timeout (--exit-timeout/-t)")
reactor.fireSystemEvent('shutdown')
#reactor.stop()
sys.exit(12)
reactor.callLater(args.exit_timeout, exit_callback)
reactor.run()
def run(self, start_reactor=True):
# Look for event classes in the source tree
self.autodiscover()
# Create factory
self.factory = GatewayWampServerFactory(self.url,
debugWamp=self.debug,
gateway=self
)
self.factory.protocol = TelegraphyConnection
self.factory.setProtocolOptions(allowHixie76=True)
listenWS(self.factory)
r = WebAppXMLRPCInterface(gateway=self)
reactor.listenTCP(self.xmlrpc_port, server.Site(r))
if start_reactor:
reactor.run()
def run(self):
def signal_handler(*args):
logger.info("Stopping threads, please wait...")
# teardown()
self.raw_report_processor.stop()
reactor.stop()
site = twisted.web.server.Site(self.__root_resource)
if self.__ssl_enabled:
ssl_context = self.__load_ssl_certs()
self.__listen_func = functools.partial(
reactor.listenSSL,
contextFactory=ssl_context)
else:
self.__listen_func = reactor.listenTCP
try:
self.install_signal()
# start threads and processes
self.raw_report_processor = RawReportProcessor()
self.raw_report_processor.start()
# web and static content
self.__listen_func(
self.__listen_port, site,
interface=self.__bind_address)
# websockets
try:
listenWS(self.__build_websockets_resource(), interface=self.__bind_address)
except :
logger.warn('Could not start websockets, address already open. This is ok is you wan to run multiple instances.')
logger.info('Faraday Server is ready')
reactor.addSystemEventTrigger('before', 'shutdown', signal_handler)
reactor.run()
except error.CannotListenError as e:
logger.error(str(e))
sys.exit(1)
except Exception as e:
logger.error('Something went wrong when trying to setup the Web UI')
logger.exception(e)
sys.exit(1)
def main():
# Explicitly set dbus main loop.
DBusGMainLoop(set_as_default=True)
# Wake up the settings manager dbus service.
try:
settings_bus = SessionBus().get_object(
'org.gnome.SettingsDaemon', '/org/gnome/SettingsDaemon')
except DBusException as e:
dialog = gtk.MessageDialog(
None,
gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_CLOSE,
GSM_NOT_FOUND_MESSAGE)
dialog.run()
dialog.destroy()
return
try:
settings_bus.Awake(dbus_interface='org.gnome.SettingsDaemon')
except DBusException as e:
# May not always be wakeable. That's Ok.
pass
# Create server.
factory = BroadcastServerFactory('ws://localhost:1337')
listenWS(factory)
# Start twisted.
reactor.startRunning()
# Create the tray icon. Must keep reference to prevent GC.
icon = createTrayIcon()
#Run GTK loop.
gtk.main()
# Kill twisted if it's still alive.
if reactor.running:
reactor.stop()
def main():
writelog('starting server')
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
#print 'debuggin'
else:
debug = False
log.startLogging(DailyLogFile.fromFullPath("/var/log/sprinkler.log"))
debug = True
contextFactory = ssl.DefaultOpenSSLContextFactory('/home/pi/cron/keys/server.key',
'/home/pi/cron/keys/server.crt')
ServerFactory = BroadcastServerFactory
#ServerFactory = BroadcastPreparedServerFactory
factory = ServerFactory("wss://localhost:5000",
debug = debug,
debugCodePaths = debug)
factory2 = ServerFactory("ws://localhost:5001",
debug = debug,
debugCodePaths = debug)
factory.protocol = BroadcastServerProtocol
factory.setProtocolOptions(allowHixie76 = True)
factory2.protocol = BroadcastServerProtocol
factory2.setProtocolOptions(allowHixie76 = True)
listenWS(factory2)
listenWS(factory,contextFactory)
webdir = File("/home/pi/cron/sprinklerwww/")
web = Site(webdir)
web.protocol = HTTPChannelHixie76Aware
webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert'
print 'starting server'
webdir.putChild("sChange",sChange())
webdir.putChild("schedule",schedule())
webdir.putChild("manual",manual())
#reactor.listenTCP(8080, web)
reactor.listenSSL(8081,web,contextFactory)
reactor.run()
def __init__(self, queue):
self.queue = queue
# set up handler to drop emails from the 'queue' into the main queue
lc = task.LoopingCall(self.processSockets)
lc.start(2)
# fire up static server while we're here
staticResource = File('./static/dist')
staticFactory = Site(staticResource, logPath=os.devnull)
staticFactory.noisy = False
if Config.useSSL:
contextFactory = ssl.DefaultOpenSSLContextFactory(
Config.keyFile,
Config.certFile
)
# static HTTPS serving
reactor.listenSSL(Config.httpsPort, staticFactory, contextFactory)
# WSS
WSfactory = WebSocketServerFactory(u"wss://localhost:9000", debug=False)
WSfactory.protocol = self.MyServerProtocol
WSfactory.noisy = False
listenWS(WSfactory, contextFactory)
else:
# static HTTP serving
reactor.listenTCP(Config.httpPort, staticFactory)
# WS
WSfactory = WebSocketServerFactory(u"ws://localhost:9000", debug=False)
WSfactory.protocol = self.MyServerProtocol
WSfactory.noisy = False
listenWS(WSfactory)
# no handlers because threads
reactor.run(installSignalHandlers=0)
def __init__(self):
logging.Handler.__init__(self)
factory = BroadcastLogFactory("ws://0.0.0.0:0")
factory.protocol = BroadcastLogProtocol
self.port = listenWS(factory).getHost()
self.factory = factory
# Start the reactor thread, setting daemon to True
# (daemon = True) allows the program to normally end, which allows the
# close function to be called, where we explicitly join the reactor
# thread
self._th = Thread(target=reactor.run, args=(False,))
self._th.daemon = True
self._th.start()
def setupWebSocketFactory(hostname, port, extPort, cLogger):
"""
Registers factory along with the protocol
Args:
hostname : resolvable fqdn of the system
port : port to listen on
extPort : external port if running behind a proxy.
logger : global logger
Return:
websocket factory
websocket listener object
"""
factory = MetrilyxWebSocketServerFactory(cLogger, "ws://%s:%d" % (hostname, port),
externalPort=extPort)
factory.protocol = getConfiguredProtocol(cLogger)
factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression)
cLogger.warning("Starting websocket server: ws://%s:%d [permessage-deflate]" % (hostname, port))
return factory, listenWS(factory)
def startService(self):
"""
Starting a TCP server and put to the right service collection
:return:
"""
if self.factory.ws_protocol == 'ws':
factory = self.factory.ws_server_factory(self.factory.url)
factory.protocol = self.factory.ws_msg_protocol
factory.name = self.factory.name
self.factory.ws_server_factory = factory
internet.TCPServer(
self.factory.port,
factory,
50
).setServiceParent(self.service_collection)
else:
factory = self.factory.ws_server_factory(self.factory.url)
factory.protocol = self.factory.ws_msg_protocol
factory.startFactory()
self.factory.ws_server_factory = factory
self.listener = listenWS(self.factory.ws_server_factory, self.__ssl_context)
if self.factory.belong_to is False:
return self.__application
def run(self, mode=Modes.DEVELOPMENT, ssl_only=False, use_ssl=False, open_browser=True, ui_path=None):
"""
Start up and run the broker. This method call with not return
"""
from parlay.protocols.websocket import WebSocketServerAdapter
import webbrowser
# cleanup on sigint
signal.signal(signal.SIGINT, lambda sig, frame: self.cleanup())
if mode == Broker.Modes.DEVELOPMENT:
print("INFO: Broker running in DEVELOPER mode. This is fine for a development environment")
print("INFO: For production systems run the Broker in PRODUCTION mode. e.g.: " + \
"broker.run(mode=Broker.Modes.PRODUCTION)")
# print out the local ip to access this broker from
print("This device is remotely accessible at http://" + self.get_local_ip() + ":" + str(self.http_port))
self._run_mode = mode
# interface to listen on. In Development mode listen on everything
# in production mode, only listen on localhost
interface = '127.0.0.1' if mode == Broker.Modes.PRODUCTION else ""
# UI path
if ui_path is not None:
root = static.File(ui_path)
root.putChild("parlay", static.File(PARLAY_PATH + "/ui"))
else:
root = static.File(PARLAY_PATH + "/ui/dist")
root.putChild("docs", static.File(PARLAY_PATH + "/docs/_build/html"))
# ssl websocket
if use_ssl:
try:
from OpenSSL.SSL import Context
ssl_context_factory = BrokerSSlContextFactory()
factory = WebSocketServerFactory("wss://localhost:" + str(self.secure_websocket_port))
factory.protocol = WebSocketServerAdapter
factory.setProtocolOptions()
listenWS(factory, ssl_context_factory, interface=interface)
root.contentTypes['.crt'] = 'application/x-x509-ca-cert'
self.reactor.listenSSL(self.https_port, server.Site(root), ssl_context_factory, interface=interface)
except ImportError:
print("WARNING: PyOpenSSL is *not* installed. Parlay cannot host HTTPS or WSS without PyOpenSSL")
except Exception as e:
print("WARNING: PyOpenSSL has had an error: " + str(e))
if ssl_only:
raise
if not ssl_only:
# listen for websocket connections on port 8085
factory = WebSocketServerFactory("ws://localhost:" + str(self.websocket_port))
factory.protocol = WebSocketServerAdapter
self.reactor.listenTCP(self.websocket_port, factory, interface=interface)
# http server
site = server.Site(root)
self.reactor.listenTCP(self.http_port, site, interface=interface)
if open_browser:
# give the reactor some time to init before opening the browser
self.reactor.callLater(.5, lambda: webbrowser.open_new_tab("http://localhost:"+str(self.http_port)))
# add advertising
reactor.listenMulticast(self.websocket_port, advertiser.ParlayAdvertiser(),
listenMultiple=True)
self.reactor.callWhenRunning(self._started.callback, None)
self.reactor.run()
def _listenServer(self, d):
factory = WampServerFactory('ws://localhost:9000', debugWamp=True)
factory.protocol = ServerProtocol
factory.onConnectionLost = d
return listenWS(factory)
"""Return some JavaScript."""
return js_code
@app.route('/')
def index(request):
return html
c = SimpleRPCContainer()
@c.register
def alert(con, text):
"""Handle text."""
if text:
return f'I received: {text}'
raise Exception('You must enter something.')
@c.register
def problem(con):
raise Exception('That was an error.')
if __name__ == '__main__':
f = WebSocketServerFactory('ws://0.0.0.0:9000')
f.protocol = c.protocol
listenWS(f)
app.run(host='0.0.0.0', port=8080)
default="ws://localhost:9000",
help="Listening URI of WAMP server, e.g. ws://localhost:9000.")
parser.add_argument(
"-t",
"--topic",
type=str,
default="http://example.com/simple",
help="Topic URI to use, e.g. http://example.com/simple")
parser.add_argument(
"-s",
"--secure",
help=
"Enable WAMP-CRA authentication (as anonymous) - This is for testing with Crossbar.io",
action="store_true")
config = parser.parse_args()
if config.debug:
log.startLogging(sys.stdout)
factory = LoadLatencyBrokerFactory(config)
listenWS(factory, backlog=4096)
print reactor.__class__
print autobahn.utf8validator.Utf8Validator
print autobahn.xormasker.XorMaskerNull
print autobahn.wamp1.protocol.json_lib
reactor.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-u',
'--url',
default='ws://localhost:9001',
help='Listen URL [default: %(default)s]')
parser.add_argument(
'-O',
'--options',
default=jsondict({'failByDrop': False}),
type=jsondict,
action='append',
help='extra options (overwrites existing) [default: %(default)s]')
parser.add_argument('-p', '--webport', default=9090, type=int)
parser.add_argument('-i',
'--listen-interface',
default='localhost',
help='interface to listen on')
parser.add_argument('-w', '--webdir', default='.')
parser.add_argument('-d',
'--debug',
default=False,
action='store_true',
help='Debug Mode [default: %(default)s]')
parser.add_argument('-o',
'--outdir',
default='./pages/results',
metavar='DIR',
help='Output Directory [default: %(default)s]')
parser.add_argument('-c',
'--cases',
default=['*'],
nargs='+',
help='test cases [default: %(default)s]')
parser.add_argument('-x',
'--exclude-cases',
default=[],
nargs='+',
help='test cases to exclude [default: %(default)s]')
parser.add_argument('-l',
'--logfile',
type=argparse.FileType('w'),
default=sys.stdout,
help='logging file [default: stdout]')
parser.add_argument(
'-t',
'--exit-timeout',
metavar='SECONDS',
default=None,
type=float,
help=
'Will automatically exit after %(metavar)s seconds [default: %(default)s]'
)
args = parser.parse_args()
spec = args.__dict__
log.startLogging(args.logfile)
## fuzzing server
fuzzer = FuzzingServerFactory(spec)
listenWS(fuzzer, interface=args.listen_interface)
## web server
webdir = File(args.webdir)
web = Site(webdir)
reactor.listenTCP(args.webport, web, interface=args.listen_interface)
log.msg("Using Twisted reactor class %s" % str(reactor.__class__))
if args.exit_timeout:
def exit_callback():
log.msg("Exiting due to timeout (--exit-timeout/-t)")
reactor.fireSystemEvent('shutdown')
#reactor.stop()
sys.exit(12)
reactor.callLater(args.exit_timeout, exit_callback)
reactor.run()
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(FileLogObserver(logFile, level=args[1]).emit)
log.addObserver(FileLogObserver(level=args[1]).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
port = args[2]
PortMapper().add_port_mapping(port, port, 'UDP')
logger.info("Finding NAT Type...")
try:
response = stun.get_ip_info(source_port=port)
except Exception:
response = stun.get_ip_info()
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete, downloading outstanding messages...")
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: ping seed node to establish connection if not full cone NAT
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid,
ip_address,
port,
signed_pubkey=keys.guid_signed_pubkey,
vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle',
ip_address,
port,
protocol,
db,
on_bootstrap_complete,
storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface=args[4])
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface=args[3])
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
logger.info("Libbitcoin server online")
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
logger.critical("Libbitcoin server offline")
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(7, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def test_basic():
"""
Test a simple one-to-one connection with WAMP pubsub.
"""
print('Running test_basic')
# Awful (but simple) way of making sure handshake is complete
handshake = deferLater(reactor, 0.5, lambda: None)
# Ordering the things to do
consumer_client_subscribe = handshake
publisher_dispatch = Deferred()
# All the events that should be triggered
producer_pubsub_received = Deferred()
consumer_pubsub_received = Deferred()
class WampProducerServerProtocol(wamp.WampServerProtocol):
def onSessionOpen(self):
self.registerForPubSub('http://example.com/mytopic')
publisher_dispatch.addCallback(lambda _: self.dispatch(
'http://example.com/mytopic',
{'a': 'b'},
))
# This one shouldn't go through
publisher_dispatch.addCallback(lambda _: self.dispatch(
'http://example.com/NOTmytopic',
{'a': 'b'},
))
class WampProducerServerFactory(ProducerMixin, wamp.WampServerFactory):
protocol = WampProducerServerProtocol
class WampProducerClientProtocol(wamp.WampClientProtocol):
def onSessionOpen(self):
self.subscribe('http://example.com/mytopic', self.onEvent)
def onEvent(self, topic, event):
try:
assert topic == 'http://example.com/mytopic'
assert event == {'a': 'b'}
producer_pubsub_received.callback(None)
except:
producer_pubsub_received.errback()
class WampProducerClientFactory(wamp.WampClientFactory):
protocol = WampProducerClientProtocol
class WampConsumerServerProtocol(wamp.WampServerProtocol):
def onSessionOpen(self):
self.registerForPubSub('http://example.com/mytopic')
class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory):
protocol = WampConsumerServerProtocol
class WampConsumerClientProtocol(wamp.WampClientProtocol):
def onSessionOpen(self):
consumer_client_subscribe.addCallback(lambda _: self.subscribe(
'http://example.com/mytopic',
self.onEvent,
))
consumer_client_subscribe.addCallback(lambda _: deferLater(
reactor, 0.5, lambda: None)).chainDeferred(publisher_dispatch)
def onEvent(self, topic, event):
try:
assert topic == 'http://example.com/mytopic'
assert event == {'a': 'b'}
consumer_pubsub_received.callback(None)
except:
consumer_pubsub_received.errback()
class WampConsumerClientFactory(wamp.WampClientFactory):
protocol = WampConsumerClientProtocol
consumer = ConsumerServer('localhost', 19000)
WampConsumerServerFactory.consumer = consumer
producer = ProducerClient([
('localhost', 19000),
])
WampProducerServerFactory.producer = producer
listenWS(WampProducerServerFactory('ws://localhost:19001'))
connectWS(WampProducerClientFactory('ws://localhost:19001'))
consumer_server = WampConsumerServerFactory('ws://localhost:19002')
listenWS(consumer_server)
consumer.processor = consumer_server
connectWS(WampConsumerClientFactory('ws://localhost:19002'))
return DeferredList([
consumer_client_subscribe,
publisher_dispatch,
producer_pubsub_received,
consumer_pubsub_received,
])
def listen(self):
listenWS(self)
if __name__ == "__main__":
from twisted.internet import reactor, ssl
# if not os.path.exists('../db.sqlite'):
# db.create_all()
log.startLogging(sys.stdout)
contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key',
'keys/server.crt')
# create a Twisted Web resource for our WebSocket server
wsFactory = GxgServerFactory(u"wss://127.0.0.1:9000")
wsResource = WebSocketResource(wsFactory)
# create a Twisted Web WSGI resource for our Flask server
wsgiResource = WSGIResource(reactor, reactor.getThreadPool(), app)
# create a root resource serving everything via WSGI/Flask, but
# the path "/ws" served by our WebSocket stuff
rootResource = WSGIRootResource(wsgiResource, {b'ws': wsResource})
listenWS(wsFactory, contextFactory)
# create a Twisted Web Site and run everything
site = Site(rootResource)
# reactor.listenSSL(9090, site, contextFactory)
reactor.listenTCP(9090, site)
reactor.run()
#curl -i -X POST -H "Content-Type: application/json" -d '{"username":"******","password":"******"}' http://127.0.0.1:9090/api/users
class WampServerFactory(ConsumerMixin, ProducerMixin, wamp.WampServerFactory):
protocol = WampServerProtocol
if __name__ == '__main__':
# import logging
# logging.basicConfig(level=logging.INFO)
from twisted.python import log
import sys
log.startLogging(sys.stderr)
consumer = ConsumerServer('0.0.0.0', 19000)
WampServerFactory.consumer = consumer
producer = ProducerClient([])
WampServerFactory.producer = producer
server = WampServerFactory('ws://localhost:9900')
listenWS(server)
consumer.processor = server
discovery = consul.ConsulDiscovery(
'http://localhost:8500/',
'pubsubclub',
producer,
)
discovery.start()
print('Starting...')
reactor.run()
ws_host = "[::1]"
ws_initial_url = "wss://{}:0".format(ws_host)
print('Initial URL = "{}"'.format(ws_initial_url))
# factory = WebSocketServerFactory(u"wss://127.0.0.1:0")
factory = WebSocketServerFactory(ws_initial_url)
# by default, allowedOrigins is "*" and will work fine out of the
# box, but we can do better and be more-explicit about what we
# allow. We are serving the Web content on 8080, but our WebSocket
# listener is on 9000 so the Origin sent by the browser will be
# from port 8080...
factory.setProtocolOptions(allowedOrigins=[
"https://127.0.0.1:8080",
"https://localhost:8080",
])
factory.protocol = EchoServerProtocol
listener = listenWS(factory, contextFactory, interface='::')
# print('"wss://127.0.0.1:{}"'.format(listener.getHost().port))
ws_actual_url = "wss://{}:{}".format(ws_host, listener.getHost().port)
print('Actual URL = "{}"'.format(ws_actual_url))
webdir = File(".")
webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert'
web = Site(webdir)
reactor.listenSSL(0, web, contextFactory)
#reactor.listenTCP(8080, web)
reactor.run()
#####################################################################
if __name__ == '__main__':
sensorlist, portdict, baudratedict = GetSensors()
## Start Twisted logging system
##
#log.startLogging(sys.stdout)
logfile = os.path.join(homedir, 'MARTAS', 'Logs', 'martas.log')
log.startLogging(open(logfile, 'a'))
## create Serial2Ws gateway factory
##
wsMcuFactory = WsMcuFactory(wsurl)
listenWS(wsMcuFactory)
## create serial port and serial port protocol; modify this according to attached sensors
##
for sensor in sensorlist:
port = serialport + portdict[sensor]
baudrate = baudratedict[sensor]
if sensor[:3].upper() == 'LEM':
protocol = wsMcuFactory.lemiProtocol
if sensor[:3].upper() == 'POS':
protocol = wsMcuFactory.pos1Protocol
if sensor[:3].upper() == 'G82':
protocol = wsMcuFactory.csProtocol
if sensor[:3].upper() == 'GSM':
protocol = wsMcuFactory.gsm90Protocol
def run(*args):
TESTNET = args[0]
LOGLEVEL = args[1]
PORT = args[2]
ALLOWIP = args[3]
SSL = args[4]
RESTPORT = args[5]
WSPORT = args[6]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level=LOGLEVEL).emit)
log.addObserver(FileLogObserver(level=LOGLEVEL).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
p = PortMapper()
threading.Thread(target=p.add_port_mapping, args=(PORT, PORT, "UDP")).start()
logger.info("Finding NAT Type...")
while True:
# sometimes the stun server returns a code the client
# doesn't understand so we have to try again
try:
response = stun.get_ip_info(source_port=PORT)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
nat_type = response[0]
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete")
mserver.get_messages(mlistener)
task.LoopingCall(check_unfunded_for_payment, db, libbitcoin_client, nlistener, TESTNET).start(600)
protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(kserver.querySeed(SEED)).addCallback(on_bootstrap_complete)
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
if nat_type != "Full Cone":
kserver.protocol.ping(SEED_NODE_TESTNET if TESTNET else SEED_NODE)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class OnlyIP(Site):
def __init__(self, resource, ip, timeout=60 * 60 * 1):
self.ip = ip
Site.__init__(self, resource, timeout=timeout)
def buildProtocol(self, addr):
if addr.host == self.ip:
return Site.buildProtocol(self, addr)
return None
# websockets api
if SSL:
ws_factory = WSFactory("wss://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP)
contextFactory = ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT)
ws_factory.protocol = WSProtocol
listenWS(ws_factory, contextFactory)
else:
ws_factory = WSFactory("ws://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP)
ws_factory.protocol = WSProtocol
listenWS(ws_factory)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
ws_interface = "0.0.0.0"
else:
ws_interface = ALLOWIP
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(WSPORT - 1, web, interface=ws_interface)
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
rest_interface = "0.0.0.0"
site = OnlyIP(api, ALLOWIP, timeout=None)
else:
rest_interface = ALLOWIP
site = Site(api, timeout=None)
if SSL:
reactor.listenSSL(RESTPORT, site, ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=rest_interface)
else:
reactor.listenTCP(RESTPORT, site, interface=rest_interface)
# blockchain
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET, log=Logger(service="LibbitcoinClient"))
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER, log=Logger(service="LibbitcoinClient"))
# listeners
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
mlistener = MessageListenerImpl(ws_factory, db)
mserver.protocol.add_listener(mlistener)
blistener = BroadcastListenerImpl(ws_factory, db)
mserver.protocol.add_listener(blistener)
protocol.set_servers(ws_factory, libbitcoin_client)
logger.info("Startup took %s seconds" % str(round(time.time() - args[7], 2)))
reactor.run()
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# json-rpc server
factory = jsonrpc.RPCFactory(RPCCalls(kserver, mserver, keys))
reactor.listenTCP(18465, factory, interface="127.0.0.1")
# web sockets
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
reactor.run()
def start_server(self, url):
server_factory = ServerFactory(url, self.engine, self.broadcaster)
server_factory.protocol = ServerProtocol
listenWS(server_factory)
settings_text = settings_text + "PASSWORD "
addr = ws_type + "0.0.0.0" + ":" + str(port)
# We start the websocket here
factory = WebSocketServerFactory(addr)
failed_start = False
if secure:
if os.path.isfile(ssl_dir +
"/privkey.pem") and os.path.isfile(ssl_dir +
"/cert.pem"):
contextFactory = ssl.DefaultOpenSSLContextFactory(
ssl_dir + '/privkey.pem', ssl_dir + '/cert.pem')
listenWS(factory, contextFactory, interface=interface)
else:
print("[ERROR]: I can't find " + ssl_dir + "cert.pem" + " and/or " +
ssl_dir + 'privkey.pem')
failed_start = True
else:
listenWS(factory, interface=interface)
if not failed_start:
print("[" + name + "] " + "[INFO]: " + ws_type + server_ip + ":" +
str(port) + " " + settings_text)
factory.protocol = ArduinoServerProtocol
# We listen to arduino message in a thread
listener_thread = threading.Thread(target=start_listen)
def start():
websocket_factory = WebSocketServerFactory()
websocket_factory.protocol = MyServerProtocol
websocket_factory.port = 9000
listenWS(websocket_factory)
def run(self):
def signal_handler(*args):
logger.info('Received SIGTERM, shutting down.')
logger.info("Stopping threads, please wait...")
# teardown()
self.raw_report_processor.stop()
self.timer.stop()
log_path = os.path.join(CONST_FARADAY_HOME_PATH, 'logs',
'access-logging.log')
site = twisted.web.server.Site(self.__root_resource,
logPath=log_path,
logFormatter=proxiedLogFormatter)
site.displayTracebacks = False
if self.__ssl_enabled:
ssl_context = self.__load_ssl_certs()
self.__listen_func = functools.partial(reactor.listenSSL,
contextFactory=ssl_context)
else:
self.__listen_func = reactor.listenTCP
try:
self.install_signal()
# start threads and processes
self.raw_report_processor = RawReportProcessor()
self.raw_report_processor.start()
self.timer = TimerClass()
self.timer.start()
# web and static content
self.__listen_func(self.__listen_port,
site,
interface=self.__bind_address)
# websockets
if faraday.server.config.websocket_ssl.enabled:
contextFactory = ssl.DefaultOpenSSLContextFactory(
faraday.server.config.websocket_ssl.keyfile.strip('\''),
faraday.server.config.websocket_ssl.certificate.strip(
'\''))
try:
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address,
contextFactory=contextFactory)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
else:
try:
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
logger.info('Faraday Server is ready')
reactor.addSystemEventTrigger('before', 'shutdown', signal_handler)
reactor.run()
except error.CannotListenError as e:
logger.error(str(e))
sys.exit(1)
except Exception as e:
logger.error(
'Something went wrong when trying to setup the Web UI')
logger.exception(e)
sys.exit(1)
def setup_finalize(event, application):
import OpenSSL.SSL
from twisted.application import internet
from twisted.internet import reactor, ssl
from twisted.python import log
from twisted.web.server import Site
from . import socket_transport
from . import http_transport
from . import websocket_transport
from . import irc
from .services import ServiceEventHandler
from stratum import settings
try:
from . import signature
signing_key = signature.load_privkey_pem(settings.SIGNING_KEY)
except Exception:
print(
"Loading of signing key '%s' failed, protocol messages cannot be signed."
% settings.SIGNING_KEY)
signing_key = None
# Attach HTTPS Poll Transport service to application
try:
sslContext = ssl.DefaultOpenSSLContextFactory(settings.SSL_PRIVKEY,
settings.SSL_CACERT)
except OpenSSL.SSL.Error:
sslContext = None
print(
'Cannot initiate SSL context, are SSL_PRIVKEY or SSL_CACERT missing?'
)
print('This will skip all SSL-based transports.')
# Set up thread pool size for service threads
reactor.suggestThreadPoolSize(settings.THREAD_POOL_SIZE)
if settings.LISTEN_SOCKET_TRANSPORT:
# Attach Socket Transport service to application
socket = internet.TCPServer(
settings.LISTEN_SOCKET_TRANSPORT,
socket_transport.SocketTransportFactory(
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL,
),
)
socket.setServiceParent(application)
# Build the HTTP interface
httpsite = Site(
http_transport.Root(
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
), )
httpsite.sessionFactory = http_transport.HttpSession
if settings.LISTEN_HTTP_TRANSPORT:
# Attach HTTP Poll Transport service to application
http = internet.TCPServer(settings.LISTEN_HTTP_TRANSPORT, httpsite)
http.setServiceParent(application)
if settings.LISTEN_HTTPS_TRANSPORT and sslContext:
https = internet.SSLServer(settings.LISTEN_HTTPS_TRANSPORT,
httpsite,
contextFactory=sslContext)
https.setServiceParent(application)
if settings.LISTEN_WS_TRANSPORT:
from autobahn.twisted.websocket import listenWS
log.msg("Starting WS transport on %d" % settings.LISTEN_WS_TRANSPORT)
ws = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WS_TRANSPORT,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
)
listenWS(ws)
if settings.LISTEN_WSS_TRANSPORT and sslContext:
from autobahn.twisted.websocket import listenWS
log.msg("Starting WSS transport on %d" % settings.LISTEN_WSS_TRANSPORT)
wss = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WSS_TRANSPORT,
is_secure=True,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
)
listenWS(wss, contextFactory=sslContext)
if settings.IRC_NICK:
reactor.connectTCP(
settings.IRC_SERVER, settings.IRC_PORT,
irc.IrcLurkerFactory(
settings.IRC_ROOM,
settings.IRC_NICK,
settings.IRC_HOSTNAME,
))
return event
self.factory.unregister(self)
print("Connection to client closed!")
class BroadcastServerFactory(WebSocketServerFactory):
"""
Simple broadcast server broadcasting any message it receives to all
currently connected clients.
"""
protocol = BroadcastServerProtocol
def __init__(self, url):
WebSocketServerFactory.__init__(self, url)
self.client = None
def register(self, client):
self.client = client
def unregister(self, client):
self.client = None
def post(self, msg):
self.client.sendMessage(msg.encode("UTF8"))
if __name__ == '__main__':
log.startLogging(sys.stdout)
ServerFactory = BroadcastServerFactory(address)
listenWS(ServerFactory)
reactor.run()
def run(self):
def signal_handler(*args):
logger.info('Received SIGTERM, shutting down.')
logger.info("Stopping threads, please wait...")
# teardown()
if self.raw_report_processor.isAlive():
self.raw_report_processor.stop()
self.ping_home_thread.stop()
log_path = CONST_FARADAY_HOME_PATH / 'logs' / 'access-logging.log'
site = twisted.web.server.Site(self.__root_resource,
logPath=log_path,
logFormatter=proxiedLogFormatter)
site.displayTracebacks = False
if self.__ssl_enabled:
ssl_context = self.__load_ssl_certs()
self.__listen_func = functools.partial(reactor.listenSSL,
contextFactory=ssl_context)
else:
self.__listen_func = reactor.listenTCP
try:
self.install_signal()
# start threads and processes
self.raw_report_processor = ReportsManager(
REPORTS_QUEUE, name="ReportsManager-Thread", daemon=True)
self.raw_report_processor.start()
self.ping_home_thread = PingHomeThread()
self.ping_home_thread.start()
# web and static content
self.__listen_func(self.__listen_port,
site,
interface=self.__bind_address)
# websockets
if faraday.server.config.websocket_ssl.enabled:
try:
contextFactory = ssl.DefaultOpenSSLContextFactory(
faraday.server.config.websocket_ssl.keyfile.strip(
'\''),
faraday.server.config.websocket_ssl.certificate.strip(
'\''))
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address,
contextFactory=contextFactory)
except SSLError as e:
logger.error(
'Could not start websockets due to a SSL Config error. Some web functionality will not be available'
)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(f'Could not start websocket, error: {ex}')
else:
try:
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(f'Could not start websocket, error: {ex}')
logger.info('Faraday Server is ready')
reactor.addSystemEventTrigger('before', 'shutdown', signal_handler)
reactor.run()
except error.CannotListenError as e:
logger.error(e)
sys.exit(1)
except Exception as e:
logger.exception(
'Something went wrong when trying to setup the Web UI')
sys.exit(1)
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
# TODO: accept port from command line
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
# TODO: maintain a list of backup STUN servers and try them if ours fails
response = stun.get_ip_info(stun_host="seed.openbazaar.org",
source_port=port)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# TODO: try UPnP if restricted NAT
# TODO: maintain open connection to seed node if STUN/UPnP fail
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid,
ip_address,
port,
signed_pubkey=keys.guid_signed_pubkey)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle',
ip_address,
port,
protocol,
db,
on_bootstrap_complete,
storage=PersistentStorage(db.DATABASE))
except Exception:
kserver = Server(node,
db,
KSIZE,
ALPHA,
storage=PersistentStorage(db.DATABASE))
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"ddd862778e3ed71af06db0e3619a4c6269ec7468c745132dbb73982b319fc572"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
print "Libbitcoin server online"
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
print "Libbitcoin server offline"
client = None
if TESTNET:
libbitcoin_client = obelisk.ObeliskOfLightClient(
"tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = obelisk.ObeliskOfLightClient(
"tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(5, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
if __name__ == '__main__':
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
# SSL server context: load server key and certificate
# We use this for both WS and Web!
#
contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key',
'keys/server.crt')
factory = WebSocketServerFactory("wss://localhost:9000",
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoServerProtocol
factory.setProtocolOptions(allowHixie76=True)
listenWS(factory, contextFactory)
webdir = File(".")
webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert'
web = Site(webdir)
# reactor.listenSSL(8080, web, contextFactory)
reactor.listenTCP(8080, web)
reactor.run()
class BroadcastPreparedServerFactory(BroadcastServerFactory):
"""
Functionally same as above, but optimized broadcast using
prepareMessage and sendPreparedMessage.
"""
def broadcast(self, msg):
print("broadcasting prepared message '{}' ..".format(msg))
preparedMsg = self.prepareMessage(msg)
for c in self.clients:
c.sendPreparedMessage(preparedMsg)
print("prepared message sent to {}".format(c.peer))
if __name__ == '__main__':
log.startLogging(sys.stdout)
ServerFactory = BroadcastServerFactory
# ServerFactory = BroadcastPreparedServerFactory
factory = ServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = BroadcastServerProtocol
listenWS(factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(8080, web)
reactor.run()
def test_connect_replay():
"""
Test that when a producer connects, the consumer sends all existing
subscription to it.
"""
print('Running test_connect_replay')
handshake = deferLater(reactor, 0.5, lambda: None)
producer_connect = handshake
publisher_dispatch = Deferred()
# Events that should be triggered
producer_pubsub_received = Deferred()
client1_pubsub_received = Deferred()
client2_pubsub_received = Deferred()
class WampProducerServerProtocol(wamp.WampServerProtocol):
def onSessionOpen(self):
self.registerForPubSub('http://example.com/mytopic')
publisher_dispatch.addCallback(lambda _: self.dispatch(
'http://example.com/mytopic',
{'a': 'b'},
))
class WampProducerServerFactory(ProducerMixin, wamp.WampServerFactory):
protocol = WampProducerServerProtocol
class WampProducerClientProtocol(wamp.WampClientProtocol):
def onSessionOpen(self):
self.subscribe('http://example.com/mytopic', self.onEvent)
def onEvent(self, topic, event):
try:
assert topic == 'http://example.com/mytopic'
assert event == {'a': 'b'}
producer_pubsub_received.callback(None)
except:
producer_pubsub_received.errback()
class WampProducerClientFactory(wamp.WampClientFactory):
protocol = WampProducerClientProtocol
class WampConsumerServerProtocol(wamp.WampServerProtocol):
def onSessionOpen(self):
self.registerForPubSub('http://example.com/mytopic')
class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory):
protocol = WampConsumerServerProtocol
class WampConsumerClient1Protocol(wamp.WampClientProtocol):
def onSessionOpen(self):
self.subscribe('http://example.com/mytopic', self.onEvent)
self.subscribe('http://example.com/mytopic2', self.onEvent)
def onEvent(self, topic, event):
try:
assert topic == 'http://example.com/mytopic'
assert event == {'a': 'b'}
client1_pubsub_received.callback(None)
except:
client1_pubsub_received.errback()
class WampConsumerClient1Factory(wamp.WampClientFactory):
protocol = WampConsumerClient1Protocol
class WampConsumerClient2Protocol(wamp.WampClientProtocol):
def onSessionOpen(self):
self.subscribe('http://example.com/mytopic', self.onEvent)
def onEvent(self, topic, event):
try:
assert topic == 'http://example.com/mytopic'
assert event == {'a': 'b'}
client2_pubsub_received.callback(None)
except:
client2_pubsub_received.errback()
class WampConsumerClient2Factory(wamp.WampClientFactory):
protocol = WampConsumerClient2Protocol
consumer = ConsumerServer('localhost', 19100)
WampConsumerServerFactory.consumer = consumer
producer = ProducerClient([])
WampProducerServerFactory.producer = producer
producer_connect.addCallback(
lambda _: producer.connect('localhost', 19100))
producer_connect.addCallback(
lambda _: deferLater(reactor, 0.5, lambda: None), ).chainDeferred(
publisher_dispatch)
listenWS(WampProducerServerFactory('ws://localhost:19101'))
connectWS(WampProducerClientFactory('ws://localhost:19101'))
consumer_server = WampConsumerServerFactory('ws://localhost:19102')
listenWS(consumer_server)
consumer.processor = consumer_server
connectWS(WampConsumerClient1Factory('ws://localhost:19102'))
connectWS(WampConsumerClient2Factory('ws://localhost:19102'))
return DeferredList([
producer_pubsub_received,
client1_pubsub_received,
client2_pubsub_received,
])
