def __init__(self, factory, serializers=None): """ Ctor. :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or None for default serializers). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializers: list """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception(u'Could not import any WAMP serializer') self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._protocols = [u'wamp.2.{}'.format(ser.SERIALIZER_ID) for ser in serializers]
def __init__(self, factory, serializers=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or ``None`` for all available serializers). :type serializers: list of objects implementing :class:`autobahn.wamp.interfaces.ISerializer` """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.RAWSOCKET_SERIALIZER_ID] = ser
def __init__(self, factory, serializers=None, debug_wamp=False): """ Ctor. :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or None for default serializers). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializers: list """ assert (callable(factory)) self._factory = factory self.debug_wamp = debug_wamp if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._protocols = [ "wamp.2.%s" % ser.SERIALIZER_ID for ser in serializers ]
def __init__(self, factory, serializer=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializer: The WAMP serializer to use (or ``None`` for "best" serializer, chosen as the first serializer available from this list: CBOR, MessagePack, UBJSON, JSON). :type serializer: object implementing :class:`autobahn.wamp.interfaces.ISerializer` """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializer is None: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: pass if serializer is None: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() except ImportError: pass if serializer is None: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializer = UBJSONSerializer() except ImportError: pass if serializer is None: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: pass if serializer is None: raise Exception("could not import any WAMP serializer") self._serializer = serializer
def __init__(self, factory, serializer=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializer: The WAMP serializer to use (or None for default serializer). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializer: obj """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializer is None: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: pass if serializer is None: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() except ImportError: pass if serializer is None: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializer = UBJSONSerializer() except ImportError: pass if serializer is None: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: pass if serializer is None: raise Exception("could not import any WAMP serializer") self._serializer = serializer
def __init__(self, factory, config): # transport configuration self._config = config # WAMP serializer # serid = config.get('serializer', 'json') if serid == 'json': # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: raise Exception("could not load WAMP-JSON serializer") elif serid == 'msgpack': # try MessagePack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME except ImportError: raise Exception("could not load WAMP-MessagePack serializer") elif serid == 'cbor': # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: raise Exception("could not load WAMP-CBOR serializer") else: raise Exception("invalid WAMP serializer '{}'".format(serid)) rawsocket.WampRawSocketClientFactory.__init__(self, factory, serializer)
def __init__(self, factory, config): # remember transport configuration # self._config = config # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'flatbuffers' in sers: # try FlatBuffers WAMP serializer try: from autobahn.wamp.serializer import FlatBuffersSerializer serializers.append(FlatBuffersSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-FlatBuffers serializer") else: sers.discard('flatbuffers') if 'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard('cbor') if 'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME serializers.append(serializer) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if 'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard('ubjson') if 'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None rawsocket.WampRawSocketServerFactory.__init__(self, factory, serializers) if 'options' in config: set_rawsocket_options(self, config['options']) self.log.debug( "RawSocket transport factory created using {serializers} serializers, max. message size {maxsize}", serializers=serializers, maxsize=self._max_message_size)
def __init__(self, factory, cbdir, config, templates): """ :param factory: WAMP session factory. :type factory: An instance of .. :param cbdir: The Crossbar.io node directory. :type cbdir: str :param config: Crossbar transport configuration. :type config: dict :param templates: :type templates: """ self.debug_traffic = config.get('debug_traffic', False) options = config.get('options', {}) # announce Crossbar.io server version # self.showServerVersion = options.get('show_server_version', self.showServerVersion) if self.showServerVersion: server = "Crossbar/{}".format(crossbar.__version__) else: # do not disclose crossbar version server = "Crossbar" # external (public) listening port (eg when running behind a reverse proxy) # externalPort = options.get('external_port', None) # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'flatbuffers' in sers: # try FlatBuffers WAMP serializer try: from autobahn.wamp.serializer import FlatBuffersSerializer serializers.append(FlatBuffersSerializer(batched=True)) serializers.append(FlatBuffersSerializer()) except ImportError('FlatBuffersSerializer'): self.log.warn( "Warning: could not load WAMP-FlatBuffers serializer") else: sers.discard('flatbuffers') if 'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError('CBORSerializer'): self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard('cbor') if 'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError('MsgPackSerializer'): self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if 'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError('UBJSONSerializer'): self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard('ubjson') if 'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError('JsonSerializer'): self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None websocket.WampWebSocketServerFactory.__init__( self, factory, serializers=serializers, url=config.get('url', None), server=server, externalPort=externalPort) # Crossbar.io node directory self._cbdir = cbdir # transport configuration self._config = config # Jinja2 templates for 404 etc self._templates = templates # enable cookie tracking if a cookie store is configured if 'cookie' in config: # cookie store configuration item cookie_config = config['cookie'] # cookie store cookie_store_config = cookie_config['store'] cookie_store_type = cookie_store_config['type'] # setup ephemeral, memory-backed cookie store if cookie_store_type == 'memory': self._cookiestore = CookieStoreMemoryBacked(cookie_config) self.log.info("Memory-backed cookie store active.") # setup persistent, file-backed cookie store elif cookie_store_type == 'file': cookie_store_file = os.path.abspath( os.path.join(self._cbdir, cookie_store_config['filename'])) self._cookiestore = CookieStoreFileBacked( cookie_store_file, cookie_config) self.log.info( "File-backed cookie store active {cookie_store_file}", cookie_store_file=hlval(cookie_store_file)) # setup persistent, database-backed cookie store elif cookie_store_type == 'database': cookie_dbpath = os.path.abspath( os.path.join(self._cbdir, cookie_store_config['path'])) self._cookiestore = CookieStoreDatabaseBacked( cookie_dbpath, cookie_config) self.log.info( "Database-backed cookie store active! [cookiestore={cookiestore}]", cookiestore=hltype(CookieStoreDatabaseBacked)) else: # should not arrive here as the config should have been checked before raise NotImplementedError( '{}: implementation of cookiestore of type "{}" missing'. format(self.__class__.__name__, cookie_store_type)) else: # this disables cookie tracking (both with or without WAMP-cookie authentication) self._cookiestore = None # set WebSocket options set_websocket_options(self, options)
args = parser.parse_args() # start logging if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') # explicitly select serializer if args.serializer == 'unspecified': serializers = None else: serializers = [] if args.serializer in ['cbor', 'all']: serializers.append(CBORSerializer()) if args.serializer in ['msgpack', 'all']: serializers.append(MsgPackSerializer()) if args.serializer in ['json', 'all']: serializers.append(JsonSerializer()) # any extra info we want to forward to our ClientSession (in self.config.extra) extra = {} # now actually run a WAMP client using our session class ClientSession runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra, serializers=serializers)
default=None, help='The worker number when parallel degree > 1.') parser.add_argument('--iterations', dest='iter', type=int, default=10, help='Number of iterations before exiting.') args = parser.parse_args() if args.parallel > 1: dl = [] for realm in args.realms.split(','): for i in range(args.parallel): cmd = [sys.executable, '-u', os.path.abspath(__file__), '--url', args.url, '--realm', realm, '--worker={}'.format(i)] done = Deferred() worker = Worker(done) reactor.spawnProcess(worker, cmd[0], args=cmd, usePTY=True) dl.append(done) all = gatherResults(dl) reactor.run() else: extra = { 'worker': args.worker, 'iter': args.iter, } runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra, serializers=[CBORSerializer()]) runner.run(PipelinedClient, auto_reconnect=True)
def __init__(self, factory, serializers=None, timeout=10, killAfter=30, queueLimitBytes=128 * 1024, queueLimitMessages=100, debug_transport_id=None, reactor=None): """ Create new HTTP WAMP Web resource. :param factory: A (router) session factory. :type factory: Instance of :class:`autobahn.twisted.wamp.RouterSessionFactory`. :param serializers: List of WAMP serializers. :type serializers: list of obj (which implement :class:`autobahn.wamp.interfaces.ISerializer`) :param timeout: XHR polling timeout in seconds. :type timeout: int :param killAfter: Kill WAMP session after inactivity in seconds. :type killAfter: int :param queueLimitBytes: Kill WAMP session after accumulation of this many bytes in send queue (XHR poll). :type queueLimitBytes: int :param queueLimitMessages: Kill WAMP session after accumulation of this many message in send queue (XHR poll). :type queueLimitMessages: int :param debug: Enable debug logging. :type debug: bool :param debug_transport_id: If given, use this fixed transport ID. :type debug_transport_id: str :param reactor: The Twisted reactor to run under. :type reactor: obj """ Resource.__init__(self) # RouterSessionFactory self._factory = factory # lazy import to avoid reactor install upon module import if reactor is None: from twisted.internet import reactor self.reactor = reactor self._debug_transport_id = debug_transport_id self._timeout = timeout self._killAfter = killAfter self._queueLimitBytes = queueLimitBytes self._queueLimitMessages = queueLimitMessages if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._transports = {} # <Base URL>/open # self.putChild(b"open", WampLongPollResourceOpen(self)) self.log.debug("WampLongPollResource initialized")
def __init__(self, factory, config): # remember transport configuration # self._config = config # explicit list of WAMP serializers # if u'serializers' in config: serializers = [] sers = set(config['serializers']) if u'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard('cbor') if u'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME serializers.append(serializer) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if u'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None # Maximum message size # self._max_message_size = config.get('max_message_size', 128 * 1024) # default is 128kB rawsocket.WampRawSocketServerFactory.__init__(self, factory, serializers) self.log.debug( "RawSocket transport factory created using {serializers} serializers, max. message size {maxsize}", serializers=serializers, maxsize=self._max_message_size)
async def start(self, reactor, url=None, realm=None, profile=None): """ Start main application. This will read the user configuration, potentially asking for a user password. :param reactor: Twisted reactor to use. :param url: Optionally override network URL as defined in profile. :param realm: Optionally override network URL as defined in profile. :param profile: User profile name to load. :return: """ txaio.start_logging(level='info') self.log.info('ok, application starting for user profile "{profile}"', profile=profile) if not os.path.isdir(self.DOTDIR): os.mkdir(self.DOTDIR) self.log.info('dotdir created: "{dotdir}"', dotdir=self.DOTDIR) self._config_path = config_path = os.path.join(self.DOTDIR, self.DOTFILE) self._profile_name = profile or 'default' if not os.path.isfile(self._config_path): self.log.info('no config exist under "{config_path}"', config_path=self._config_path) self._config = UserConfig(self._config_path) self._profile = None else: self._config = UserConfig(self._config_path) # FIXME: start modal dialog to get password from user def getpw(): return '123secret' self._config.load(cb_get_password=getpw) if self._profile_name not in self._config.profiles: raise click.ClickException( 'no such profile "{}" in config "{}" with {} profiles'. format(self._profile_name, config_path, len(self._config.profiles))) else: self._profile = self._config.profiles[self._profile_name] self.log.info( 'user profile "{profile_name}" loaded from "{config_path}":\n\n', config_path=self._config_path, profile_name=self._profile_name) pprint(self._profile.marshal()) print('\n\n') extra = { 'ready': txaio.create_future(), 'done': txaio.create_future(), 'running': True, 'config': self._config, 'config_path': self._config_path, 'profile': self._profile, 'profile_name': self._profile_name, } # XBR network node used as a directory server and gateway to XBR smart contracts network_url = url or (self._profile.network_url if self._profile and self._profile.network_url else 'ws://localhost:8090/ws') # WAMP realm on network node, usually "xbrnetwork" network_realm = realm or (self._profile.network_realm if self._profile and self._profile.network_realm else 'xbrnetwork') runner = ApplicationRunner(url=network_url, realm=network_realm, extra=extra, serializers=[CBORSerializer()]) self.log.info( 'ok, now connecting to "{network_url}", joining realm "{network_realm}" ..', network_url=network_url, network_realm=network_realm) await runner.run(ApplicationClient, reactor=reactor, auto_reconnect=True, start_reactor=False) self.log.info('ok, application client connected!') session, details = await extra['ready'] self.log.info('ok, application session joined: {details}', details=details) def on_exit(_): self.log.info('exiting application ..') extra['running'] = False txaio.resolve(extra['done'], None) win = ApplicationWindow(reactor, session, self._config, self._config_path, self._profile, self._profile_name) win.connect("cancel", on_exit) win.connect("destroy", on_exit) win.show_all() await win.start() ticks = 0 while extra['running']: ticks += 1 self.log.info( 'ok, application main task still running at tick {ticks}', ticks=ticks) await sleep(5) self.log.info('ok, application main task ended!')
def _main(): parser = argparse.ArgumentParser() parser.add_argument('command', type=str, choices=_COMMANDS, const='noop', nargs='?', help='Command to run') parser.add_argument('-d', '--debug', action='store_true', help='Enable debug output.') parser.add_argument('--url', dest='url', type=str, default='wss://planet.xbr.network/ws', help='The router URL (default: "wss://planet.xbr.network/ws").') parser.add_argument('--realm', dest='realm', type=str, default='xbrnetwork', help='The realm to join (default: "xbrnetwork").') parser.add_argument('--ethkey', dest='ethkey', type=str, help='Private Ethereum key (32 bytes as HEX encoded string)') parser.add_argument('--cskey', dest='cskey', type=str, help='Private WAMP-cryptosign authentication key (32 bytes as HEX encoded string)') parser.add_argument('--username', dest='username', type=str, default=None, help='For on-boarding, the new member username.') parser.add_argument('--email', dest='email', type=str, default=None, help='For on-boarding, the new member email address.') parser.add_argument('--market', dest='market', type=str, default=None, help='For creating new markets, the market UUID.') parser.add_argument('--market_title', dest='market_title', type=str, default=None, help='For creating new markets, the market title.') parser.add_argument('--market_label', dest='market_label', type=str, default=None, help='For creating new markets, the market label.') parser.add_argument('--market_homepage', dest='market_homepage', type=str, default=None, help='For creating new markets, the market homepage.') parser.add_argument('--provider_security', dest='provider_security', type=int, default=None, help='') parser.add_argument('--consumer_security', dest='consumer_security', type=int, default=None, help='') parser.add_argument('--market_fee', dest='market_fee', type=int, default=None, help='') parser.add_argument('--marketmaker', dest='marketmaker', type=str, default=None, help='For creating new markets, the market maker address.') parser.add_argument('--actor_type', dest='actor_type', type=int, choices=sorted([ActorType.CONSUMER, ActorType.PROVIDER, ActorType.PROVIDER_CONSUMER]), default=None, help='Actor type: PROVIDER = 1, CONSUMER = 2, PROVIDER_CONSUMER (both) = 3') parser.add_argument('--vcode', dest='vcode', type=str, default=None, help='For verifications of actions, the verification UUID.') parser.add_argument('--vaction', dest='vaction', type=str, default=None, help='For verifications of actions (on-board, create-market, ..), the verification code.') parser.add_argument('--channel', dest='channel', type=str, default=None, help='For creating new channel, the channel UUID.') parser.add_argument('--channel_type', dest='channel_type', type=int, choices=sorted([ChannelType.PAYING, ChannelType.PAYMENT]), default=None, help='Channel type: Seller (PAYING) = 1, Buyer (PAYMENT) = 2') parser.add_argument('--delegate', dest='delegate', type=str, default=None, help='For creating new channel, the delegate address.') parser.add_argument('--amount', dest='amount', type=int, default=None, help='Amount to open the channel with. In tokens of the market coin type, used as means of payment in the market of the channel.') args = parser.parse_args() if args.command == 'version': print('') print(' XBR CLI v{}\n'.format(__version__)) print(' XBRToken contract address: {} [source: {}]'.format(hlid(XBR_DEBUG_TOKEN_ADDR), XBR_DEBUG_TOKEN_ADDR_SRC)) print(' XBRNetwork contract address: {} [source: {}]'.format(hlid(XBR_DEBUG_NETWORK_ADDR), XBR_DEBUG_NETWORK_ADDR_SRC)) print(' XBRMarket contract address: {} [source: {}]'.format(hlid(XBR_DEBUG_MARKET_ADDR), XBR_DEBUG_MARKET_ADDR_SRC)) print(' XBRCatalog contract address: {} [source: {}]'.format(hlid(XBR_DEBUG_CATALOG_ADDR), XBR_DEBUG_CATALOG_ADDR_SRC)) print(' XBRChannel contract address: {} [source: {}]'.format(hlid(XBR_DEBUG_CHANNEL_ADDR), XBR_DEBUG_CHANNEL_ADDR_SRC)) print('') else: if args.command is None or args.command == 'noop': print('no command given. select from: {}'.format(', '.join(_COMMANDS))) sys.exit(0) # read or create a user profile profile = load_or_create_profile() # only start txaio logging after above, which runs click (interactively) if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') log = txaio.make_logger() log.info('XBR CLI {version}', version=hlid('v' + __version__)) log.info('Profile {profile} loaded from {path}', profile=hlval(profile.name), path=hlval(profile.path)) extra = { # user profile and defaults 'profile': profile, # allow to override, and add more arguments from the command line 'command': args.command, 'ethkey': binascii.a2b_hex(args.ethkey[2:]) if args.ethkey else None, 'cskey': binascii.a2b_hex(args.cskey[2:]) if args.cskey else None, 'username': args.username, 'email': args.email, 'market': uuid.UUID(args.market) if args.market else None, 'market_title': args.market_title, 'market_label': args.market_label, 'market_homepage': args.market_homepage, 'market_provider_security': args.provider_security or 0, 'market_consumer_security': args.consumer_security or 0, 'market_fee': args.market_fee or 0, 'marketmaker': binascii.a2b_hex(args.marketmaker[2:]) if args.marketmaker else None, 'actor_type': args.actor_type, 'vcode': args.vcode, 'vaction': uuid.UUID(args.vaction) if args.vaction else None, 'channel': uuid.UUID(args.channel) if args.channel else None, 'channel_type': args.channel_type, 'delegate': binascii.a2b_hex(args.delegate[2:]) if args.delegate else None, 'amount': args.amount or 0, } runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra, serializers=[CBORSerializer()]) try: log.info('Connecting to "{url}" {realm} ..', url=hlval(args.url), realm=('at realm "' + hlval(args.realm) + '"' if args.realm else '')) runner.run(Client, auto_reconnect=False) except Exception as e: print(e) sys.exit(1) else: sys.exit(0)
def __init__(self, factory, cbdir, config, templates): """ Ctor. :param factory: WAMP session factory. :type factory: An instance of .. :param cbdir: The Crossbar.io node directory. :type cbdir: str :param config: Crossbar transport configuration. :type config: dict """ self.debug_traffic = config.get('debug_traffic', False) options = config.get('options', {}) self.showServerVersion = options.get('show_server_version', self.showServerVersion) if self.showServerVersion: server = "Crossbar/{}".format(crossbar.__version__) else: server = "Crossbar" externalPort = options.get('external_port', None) # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if u'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard(u'cbor') if u'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if u'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard(u'ubjson') if u'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard(u'json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None websocket.WampWebSocketServerFactory.__init__( self, factory, serializers=serializers, url=config.get('url', None), server=server, externalPort=externalPort) # Crossbar.io node directory self._cbdir = cbdir # transport configuration self._config = config # Jinja2 templates for 404 etc self._templates = templates # cookie tracking if 'cookie' in config: cookie_store_type = config['cookie']['store']['type'] # ephemeral, memory-backed cookie store if cookie_store_type == 'memory': self._cookiestore = CookieStoreMemoryBacked(config['cookie']) self.log.info("Memory-backed cookie store active.") # persistent, file-backed cookie store elif cookie_store_type == 'file': cookie_store_file = os.path.abspath( os.path.join(self._cbdir, config['cookie']['store']['filename'])) self._cookiestore = CookieStoreFileBacked( cookie_store_file, config['cookie']) self.log.info( "File-backed cookie store active {cookie_store_file}", cookie_store_file=cookie_store_file) else: # should not arrive here as the config should have been checked before raise Exception("logic error") else: self._cookiestore = None # set WebSocket options set_websocket_options(self, options)
parser.add_argument('--verifications', dest='verifications', default='.crossbar/.verifications', type=str, help='XBR node verifications directory') args = parser.parse_args() if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') if not args.email: args.email = '{}@nodomain'.format(args.username) extra = { 'ethkey': binascii.a2b_hex(args.ethkey), 'cskey': binascii.a2b_hex(args.cskey), 'username': args.username, 'email': args.email, 'verifications': args.verifications, } runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra, serializers=[CBORSerializer()]) runner.run(XbrDelegate, auto_reconnect=True)
def _main(): parser = argparse.ArgumentParser() parser.add_argument('command', type=str, choices=_COMMANDS, help='Command to run') parser.add_argument('-d', '--debug', action='store_true', help='Enable debug output.') parser.add_argument('--url', dest='url', type=str, default='wss://planet.xbr.network/ws', help='The router URL (default: "wss://planet.xbr.network/ws").') parser.add_argument('--realm', dest='realm', type=str, default='xbrnetwork', help='The realm to join (default: "xbrnetwork").') parser.add_argument('--ethkey', dest='ethkey', type=str, help='Private Ethereum key (32 bytes as HEX encoded string)') parser.add_argument('--cskey', dest='cskey', type=str, help='Private WAMP-cryptosign authentication key (32 bytes as HEX encoded string)') parser.add_argument('--username', dest='username', type=str, default=None, help='For on-boarding, the new member username.') parser.add_argument('--email', dest='email', type=str, default=None, help='For on-boarding, the new member email address.') parser.add_argument('--market', dest='market', type=str, default=None, help='For creating new markets, the market UUID.') parser.add_argument('--market_title', dest='market_title', type=str, default=None, help='For creating new markets, the market title.') parser.add_argument('--market_label', dest='market_label', type=str, default=None, help='For creating new markets, the market label.') parser.add_argument('--market_homepage', dest='market_homepage', type=str, default=None, help='For creating new markets, the market homepage.') parser.add_argument('--provider_security', dest='provider_security', type=int, default=None, help='') parser.add_argument('--consumer_security', dest='consumer_security', type=int, default=None, help='') parser.add_argument('--market_fee', dest='market_fee', type=int, default=None, help='') parser.add_argument('--marketmaker', dest='marketmaker', type=str, default=None, help='For creating new markets, the market maker address.') parser.add_argument('--actor_type', dest='actor_type', type=int, choices=sorted([ActorType.CONSUMER, ActorType.PROVIDER, ActorType.PROVIDER_CONSUMER]), default=None, help='Actor type: PROVIDER = 1, CONSUMER = 2, PROVIDER_CONSUMER (both) = 3') parser.add_argument('--vcode', dest='vcode', type=str, default=None, help='For verifications of actions, the verification UUID.') parser.add_argument('--vaction', dest='vaction', type=str, default=None, help='For verifications of actions (on-board, create-market, ..), the verification code.') parser.add_argument('--channel', dest='channel', type=str, default=None, help='For creating new channel, the channel UUID.') parser.add_argument('--channel_type', dest='channel_type', type=int, choices=sorted([ChannelType.PAYING, ChannelType.PAYMENT]), default=None, help='Channel type: Seller (PAYING) = 1, Buyer (PAYMENT) = 2') parser.add_argument('--delegate', dest='delegate', type=str, default=None, help='For creating new channel, the delegate address.') parser.add_argument('--amount', dest='amount', type=int, default=None, help='Amount to open the channel with. In tokens of the market coin type, used as means of payment in the market of the channel.') args = parser.parse_args() if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') extra = { 'command': args.command, 'ethkey': binascii.a2b_hex(args.ethkey[2:]), 'cskey': binascii.a2b_hex(args.cskey[2:]), 'username': args.username, 'email': args.email, 'market': uuid.UUID(args.market) if args.market else None, 'market_title': args.market_title, 'market_label': args.market_label, 'market_homepage': args.market_homepage, 'market_provider_security': args.provider_security or 0, 'market_consumer_security': args.consumer_security or 0, 'market_fee': args.market_fee or 0, 'marketmaker': binascii.a2b_hex(args.marketmaker[2:]) if args.marketmaker else None, 'actor_type': args.actor_type, 'vcode': args.vcode, 'vaction': uuid.UUID(args.vaction) if args.vaction else None, 'channel': uuid.UUID(args.channel) if args.channel else None, 'channel_type': args.channel_type, 'delegate': binascii.a2b_hex(args.delegate[2:]) if args.delegate else None, 'amount': args.amount or 0, } runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra, serializers=[CBORSerializer()]) try: runner.run(Client, auto_reconnect=False) except Exception as e: print(e) sys.exit(1) else: sys.exit(0)