def run(cls): print(f"Starting {cls.__name__}...") url = "ws://%s:%s" % (config["analytics"]["host"], config["analytics"]["port"]) runner = ApplicationRunner(url=url, realm=config["analytics"]["realm"]) runner.run(AnalyticsWAMPComponent)
def run(self): print("Starting Default Commands Component...") url = "ws://%s:%s/ws" % (config["crossbar"]["host"], config["crossbar"]["port"]) runner = ApplicationRunner(url=url, realm=config["crossbar"]["realm"]) runner.run(DefaultCommandsWAMPComponent)
def main(args=None): if args is None: args = sys.argv[1:] print("tirith monitor 0.2.0") print("connecting") runner = ApplicationRunner(url=u"ws://frameshift:8080/ws", realm=u"realm1") runner.run(MonitorComponent)
def execute(action, actor, server, router, port, debug=False, **kwargs): responses = [] if debug: logger.info("DEBUG ON") logging.getLogger('autobahn').setLevel(logging.DEBUG) runner = ApplicationRunner(url="ws://%s:%d/ws" % (router, port), realm="realm1") logger.debug("Starting connection") runner.run(partial(GlotConnector, responses=responses, action=action, actor=actor, debug=debug, server=server, **kwargs)) return responses.pop() if responses else None
def main(args=None): if args is None: args = sys.argv[1:] print("tirith client 0.2.0") print ("connecting...") runner = ApplicationRunner(url=u"ws://frameshift:8080/ws", realm=u"realm1") # throws socket.gaierror on 404 runner.run(TestComponent)
def main_entry(ssl_cert=None): from autobahn.asyncio.wamp import ApplicationRunner proto = "wss" if ssl_cert else "ws" options = None if ssl_cert: raise RuntimeError("asyncio backend does not support ssl") runner = ApplicationRunner(url=u"{0}://127.0.0.1:8181/ws".format(proto), realm=u"realm1", ssl=options) try: runner.run(Component) except KeyboardInterrupt or Exception: raise KeyboardInterrupt print "shutting down kogniserver..."
def main(): # load command-line options arguments = docopt.docopt(__doc__.format(sys.argv[0]), version="0.0.1") # All these dashes are stupid arguments = {k.lstrip('--'): v for k,v in arguments.items()} verbose = arguments.get("verbose", 0) quiet = arguments.get("quiet", 0) level = logging.WARN if verbose == 1: level = logging.INFO elif verbose == 2: level = logging.DEBUG elif verbose == 3: level = logging.DEBUG - 1 elif verbose == 4: level = logging.DEBUG - 2 elif quiet == 1: level = logging.ERROR elif quiet == 2: level = logging.CRITICAL + 1 config = {} try: conf_path = arguments["config"] if not os.path.isfile(conf_path): conf_path = "/etc/orthogonalspace/conf.json" if not os.path.isfile(conf_path): conf_path = "/usr/lib/orthogonalspace/conf.json" if not os.path.isfile(conf_path): sys.exit("You must provide a config file") with open(conf_path) as conf_file: config = json.load(conf_file) except (OSError, IOError): LOG.exception("Could not load config file {}:".format(arguments["config"])) pass runner = ApplicationRunner( os.environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://127.0.0.1:8080/ws"), u'orthogonalspace', extra=config, ) runner.run(OrthogonalSpaceComponent)
class PlnxEndpoint(mp.Process): def __init__(self, endpoint, q, **kwargs): super(PlnxEndpoint, self).__init__(name='%s Endpoint Process' % endpoint, **kwargs) self.endpoint = endpoint self.q = q self.is_killed = mp.Event() def run(self): self.runner = ApplicationRunner("wss://api.poloniex.com:443", 'realm1', extra={'channel': self.endpoint, 'queue': self.q, 'is_killed': self.is_killed}) self.runner.run(PoloniexSession) def join(self, *args, **kwargs): self.is_killed.set() super(PlnxEndpoint, self).join(*args, **kwargs)
def run_wamp(bot): """ Run LechBot in an Autobahn application """ class Component(ApplicationSession): @asyncio.coroutine def onJoin(self, details): # NOQA bot.log.info("Joined WAMP realm !") last_seen_keys = {} def on_event(key, time, text): now = datetime.now() time = parse_time(time) # Outdated message if (now - time).total_seconds() > 120: bot.log.info("Got outdated event " + repr({ 'key': key, 'time': time, 'text': text })) return # Rate limit last_seen = last_seen_keys.get(key, datetime.fromtimestamp(0)) if (now - last_seen).total_seconds() < RATELIMIT.get(key, 0): bot.log.info("Got rate-limited event " + repr({ 'key': key, 'time': time, 'text': text }) + " / Last seen: " + repr(last_seen)) return bot.say(text, target=MAIN_CHAN) bot.log.debug("Got " + repr({ 'key': key, 'time': time, 'text': text })) last_seen_keys[key] = now yield from self.subscribe(on_event, u'incubator.actstream') yield from self.subscribe(on_event, u'hal.eventstream') runner = ApplicationRunner(WAMP_HOST, WAMP_REALM) runner.run(Component)
def connect(self,url,realm): '''connect to websocket :param str url: url to which connect ''' self.url = url if self.conn.id is None: self.conn.login() self.th = Thread(target=self.__f) self.runner = ApplicationRunner(url=url, ssl=True, realm=realm, headers={'cookie':'sessionid=%s' % self.conn.id}) self.loop = asyncio.get_event_loop() self.session = ApplicationSession() coro = self.runner.run(self.session,start_loop = False) (self.__transport, self.__protocol) = self.loop.run_until_complete(coro) self.th.start()
class WampBase(object): '''Base class for websocket streaming ''' def __init__(self,con): ''':param web.rest.base.Connection con: the base http connection ''' self.conn = con self.runner = None self.url = None self.loop = None self.session = None self.th = None def connect(self,url,realm): '''connect to websocket :param str url: url to which connect ''' self.url = url if self.conn.id is None: self.conn.login() self.th = Thread(target=self.__f) self.runner = ApplicationRunner(url=url, ssl=True, realm=realm, headers={'cookie':'sessionid=%s' % self.conn.id}) self.loop = asyncio.get_event_loop() self.session = ApplicationSession() coro = self.runner.run(self.session,start_loop = False) (self.__transport, self.__protocol) = self.loop.run_until_complete(coro) self.th.start() def subscribe(self,callback,topic): if self.session is None: raise RuntimeError('no Connection active') return self.session.subscribe(callback,topic) def leave(self): if self.session is not None: self.session.leave() self.stop() def stop(self): if self.loop is not None: self.loop.stop() self.loop = None def __f(self): #asyncio.set_event_loop(self.loop) self.loop.run_forever()
def __init__(self,config=None): logging.debug('instanciando WampMain') ApplicationSession.__init__(self, config) def _userIdentified(self,data): logging.info('--- Usuario identificado ---') logging.info(data) sys.exit(0) @coroutine def onJoin(self, details): logging.debug('session joined') yield from self.subscribe(self._userIdentified,'assistance.firmware.identify') try: yield from self.call('assistance.firmware.login',dni,password) except Exception as e: logging.exception(e) sys.exit(1) from autobahn.asyncio.wamp import ApplicationRunner runner = ApplicationRunner(url='ws://localhost:8000/ws',realm='assistance',debug=True, debug_wamp=True, debug_app=True) runner.run(WampCommand)
''' if __name__ == '__main__': import sys import logging import inject sys.path.insert(0, '../python') logging.basicConfig(level=logging.DEBUG) from autobahn.asyncio.wamp import ApplicationRunner from model.config import Config from actions.systems.files.files import FilesWamp def config_injector(binder): binder.bind(Config, Config('server-config.cfg')) inject.configure(config_injector) config = inject.instance(Config) url = config.configs['server_url'] realm = config.configs['server_realm'] debug = config.configs['server_debug'] runner = ApplicationRunner(url=url, realm=realm, debug=debug, debug_wamp=debug, debug_app=debug) runner.run(FilesWamp)
from model.config import Config logging.basicConfig(level=logging.DEBUG) def config_injector(binder): binder.bind(Config,Config('firmware-config.cfg')) inject.configure(config_injector) config = inject.instance(Config) ''' Ejecuta el protocolo Wamp del modelo del firmware ''' if __name__ == '__main__': from autobahn.asyncio.wamp import ApplicationRunner from autobahn.wamp.serializer import JsonSerializer from network.wampFirmware import WampFirmware url = config.configs['firmware_url'] realm = config.configs['firmware_realm'] debug = config.configs['firmware_debug'] json = JsonSerializer() runner = ApplicationRunner(url=url,realm=realm,debug=debug, debug_wamp=debug, debug_app=debug, serializers=[json]) runner.run(WampFirmware)
async def join_server(name=None): player_id = self.player_count if name is None: name = "Player {}".format(player_id) self.player_count += 1 player = Player(player_id, name, self) self.players[player_id] = player self.publish('players', {player_id: name}) await self.register(player.perform_move, 'player{n}.perform_move'.format(n=player_id)) await self.register(player.start_game, 'player{n}.start_game'.format(n=player_id)) await self.register(player.join_seat, 'player{n}.join_seat'.format(n=player_id)) await self.register(player.set_name, 'player{n}.set_name'.format(n=player_id)) await self.register(player.change_seat, 'player{n}.change_seat'.format(n=player_id)) return player_id, name await self.register(join_server, 'join_server') await self.register(self.get_players, 'players') await self.register(self.get_seats, 'seats') if __name__ == '__main__': runner = ApplicationRunner(url=u"ws://localhost:8080/ws", realm=u"realm1") runner.run(Coordinator)
''' Se conecta al router wamp y hace correr AssistanceWamp y JustificationsWamp ''' if __name__ == '__main__': import sys import logging import inject inject.configure() sys.path.insert(0, '../python') logging.basicConfig(level=logging.DEBUG) logging.getLogger().setLevel(logging.DEBUG) from autobahn.asyncio.wamp import ApplicationRunner from actions.systems.assistance.assistance import AssistanceWamp # from actions.systems.assistance.justifications import JustificationsWamp from model.registry import Registry reg = inject.instance(Registry) registry = reg.getRegistry('wamp') url = registry.get('url') realm = registry.get('realm') debug = registry.get('debug') logging.info('iniciando app en {} {} {}'.format(url, realm, debug)) runner = ApplicationRunner(url=url, realm=realm) runner.run(AssistanceWamp) # runner.run(JustificationsWamp)
from autobahn.asyncio.wamp import ApplicationSession from autobahn.asyncio.wamp import ApplicationRunner class MyComponent(ApplicationSession): def onJoin(self, details): print("session ready") runner = ApplicationRunner(url=u"ws://192.168.1.130:8080/ws", realm=u"realm1") runner.run(MyComponent)
import sys from autobahn.asyncio.wamp import ApplicationRunner from prettyconf import config from .wamp import WampClient URL = config('WAMP_URL', default='ws://crossbar.dronemapp.com:80/ws') REALM = config('WAMP_REALM', default='kotoko') runner = ApplicationRunner(URL, REALM) try: runner.run(WampClient) except OSError as ex: print('OSError:', ex) sys.exit(100)
def main(): runner = ApplicationRunner("wss://api.poloniex.com:443", "realm1") runner.run(PoloniexComponent)
def start_publishing(self): runner = ApplicationRunner(url=u"wss://demo.crossbar.io/ws", realm=u"realm1") runner.run(PublishStock.PublishStockRunner)
self.publish(target, 0, 0, "Plays: " + str(player.plays)) self.publish(target, 0, 1, "Wins: " + str(player.wins)) self.screen.clear() self.screen.send() for player in self.players.values(): player.reset() self.powerups = [] self.entities = [] def onDisconnect(self): """ Called when the WAMP connection is disconnected :return: None """ asyncio.get_event_loop().stop() if __name__ == '__main__': if GAME_ID == 'demo_game': print("Please change GAME_ID to something else!") exit(1) runner = ApplicationRunner( WAMP_URL, WAMP_REALM, ) runner.run(GameComponent, log_level='info')
from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner import ssl class Component(ApplicationSession): """ An application component that publishes an event every second. """ async def onJoin(self, details): counter = 0 while True: print("publish: com.myapp.topic1", counter) self.publish(u'com.myapp.topic1', counter) counter += 1 await asyncio.sleep(1) if __name__ == '__main__': # see README; this way everything accesses same cert-files cert_path = '../../../../twisted/wamp/pubsub/tls/server.crt' print(cert_path) # create an ssl.Context using just our self-signed cert as the CA certificates options = ssl.create_default_context(cadata=open(cert_path, 'r').read()) # ...which we pass as "ssl=" to ApplicationRunner (passed to loop.create_connection) runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", u"wss://127.0.0.1:8083/ws"), u"crossbardemo", ssl=options, # try removing this, but still use self-signed cert ) runner.run(Component)
# read config and add macs to library self.auto_prefixes = self.redis.get() # self.scan_runner = task.LoopingCall(self.do_scan()) # self.scan_runner.start(self.SCAN_TICKS) # d = threads.deferToThread(self.do_scan) # d.addCallback(self.save_device_scan) # d.addErrback(self.err_device_scan) await self.do_scan() async def do_scan(self): print("scanning") result = await self.scanner.discover() for d in result: print(d) def save_device_scan(self, results: List): pass def err_device_scan(self, *args, **kwargs): print("err") print(args) def write_config(self): pass if __name__ == '__main__': url = os.environ.get("XBAR_ROUTER", u"ws://127.0.0.1:8083/ws") realm = u"realm1" runner = ApplicationRunner(url, realm) runner.run(BLEScanSession)
def main(): runner = ApplicationRunner(url="ws://localhost:8080/ws", realm="realm1") runner.run(ClientSession)
def Start(ToRun, RealmName="realm1"): Runner = ApplicationRunner(environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://127.0.0.1:8080/ws"), RealmName) Runner.run(ToRun)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-x', '--crossbar', metavar='URL', type=str, default=os.environ.get("LG_CROSSBAR", "ws://127.0.0.1:20408/ws"), help="crossbar websocket URL") parser.add_argument( '-n', '--name', dest='name', type=str, default=None, help='public name of this exporter (defaults to the system hostname)') parser.add_argument( '--hostname', dest='hostname', type=str, default=None, help= 'hostname (or IP) published for accessing resources (defaults to the system hostname)' ) parser.add_argument('-d', '--debug', action='store_true', default=False, help="enable debug mode") parser.add_argument( '-i', '--isolated', action='store_true', default=False, help="enable isolated mode (always request SSH forwards)") parser.add_argument('resources', metavar='RESOURCES', type=str, help='resource config file name') args = parser.parse_args() level = 'debug' if args.debug else 'info' extra = { 'name': args.name or gethostname(), 'hostname': args.hostname or gethostname(), 'resources': args.resources, 'isolated': args.isolated } crossbar_url = args.crossbar crossbar_realm = os.environ.get("LG_CROSSBAR_REALM", "realm1") print("crossbar URL: {}".format(crossbar_url)) print("crossbar realm: {}".format(crossbar_realm)) print("exporter name: {}".format(extra['name'])) print("exporter hostname: {}".format(extra['hostname'])) print("resource config file: {}".format(extra['resources'])) extra['loop'] = loop = asyncio.get_event_loop() if args.debug: loop.set_debug(True) runner = ApplicationRunner(url=crossbar_url, realm=crossbar_realm, extra=extra) runner.run(ExporterSession, log_level=level) if reexec: exit(100)
def __init__(self, config: ConfigObj or dict() = {}): self.secrets = config self.limiter = RateLimiter(max_calls=self.max_calls, period=self.max_period) self.runner = ApplicationRunner(self.ws_uri, self.ws_realm)
from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner class Component(ApplicationSession): """ An application component that subscribes and receives events, and stop after having received 5 events. """ @asyncio.coroutine def onJoin(self, details): self.received = 0 def on_event(*args, **kwargs): print(args, kwargs) yield from self.subscribe(on_event, u'incubator.actstream') def onDisconnect(self): asyncio.get_event_loop().stop() if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://snips.lan:8081/ws"), u"urlab", debug_wamp=False, # optional; log many WAMP details debug=False, # optional; log even more details ) runner.run(Component)
@coroutine def onJoin(self, details): def onRefresh(*queue): try: self.refresh(queue[0]['percent'], queue[0]['name']) except ValueError as e: print(e) except IndexError as e: print(e) print(queue) self.subscribe(onRefresh, 'queue') def refresh(self, percentage, name): self.splash.edit(str(name).lower) self.refresh_bar(percentage) self.percentage_text.edit(str(percentage) + '%') self.screen.refresh() def refresh_bar(self, percentage): self.bar.draw_line(x1=0, y1=0, x2=percentage // 5, y2=0) self.bar.draw_line(x1=0, y1=1, x2=percentage // 5, y2=1) if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://titoubuntu:8080/ws"), u"crepinator" ) runner.run(CrepeBot)
def run(self): runner = ApplicationRunner(url=u"ws://api.interchange.ericsson.net/v1", realm=u"interchange") runner.run(self.Component)
def run(main=None, parser=None): # parse command line arguments parser = parser or argparse.ArgumentParser() parser.add_argument('--debug', dest='debug', action='store_true', default=False, help='Enable logging at level "debug".') parser.add_argument( '--url', dest='url', type=str, default=u'wss://fabric.crossbario.com', help='The Crossbar.io Fabric Center (CFC) WebSocket URL ' '(default: wss://fabric.crossbario.com') parser.add_argument('--realm', dest='realm', type=str, help='The management realm to join on CFC') parser.add_argument( '--keyfile', dest='keyfile', type=str, default=u'~/.cbf/default.priv', help='The private client key file to use for authentication.') parser.add_argument('--authmethod', dest='authmethod', type=str, default=u'cryptosign', help='Authentication method: cryptosign or anonymous') args = parser.parse_args() if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') extra = None if args.authmethod == u'cryptosign': # for authenticating the management client, we need a Ed25519 public/private key pair # here, we are reusing the user key - so this needs to exist before privkey_file = os.path.expanduser(args.keyfile) privkey_hex = None user_id = None if not os.path.exists(privkey_file): raise Exception( 'private key file {} does not exist'.format(privkey_file)) else: with open(privkey_file, 'r') as f: data = f.read() for line in data.splitlines(): if line.startswith('private-key-ed25519'): privkey_hex = line.split(':')[1].strip() if line.startswith('user-id'): user_id = line.split(':')[1].strip() if privkey_hex is None: raise Exception('no private key found in keyfile!') if user_id is None: raise Exception('no user ID found in keyfile!') key = cryptosign.SigningKey.from_key_bytes( binascii.a2b_hex(privkey_hex)) extra = { u'args': args, u'key': key, u'authid': user_id, u'main': main, u'return_code': None } elif args.authmethod == u'anonymous': extra = {u'args': args, u'main': main, u'return_code': None} else: raise Exception('logic error') runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra) if args.authmethod == u'cryptosign': runner.run(ManagementClientSession) elif args.authmethod == u'anonymous': runner.run(ManagementAnonymousClientSession) else: raise Exception('logic error') return_code = extra[u'return_code'] if isinstance(return_code, int) and return_code != 0: sys.exit(return_code)
parser.add_argument('-d', '--debug', action='store_true', help='Enable debug output.') parser.add_argument( '--url', dest='url', type=str, default=url, help='The router URL (default: "ws://localhost:8080/ws").') parser.add_argument('--realm', dest='realm', type=str, default=realm, help='The realm to join (default: "realm1").') args = parser.parse_args() # start logging if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') # any extra info we want to forward to our ClientSession (in self.config.extra) extra = {u'foobar': u'A custom value'} # now actually run a WAMP client using our session class ClientSession runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra) runner.run(ClientSession)
from os import environ import asyncio from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner class MyComponent(ApplicationSession): @asyncio.coroutine def onJoin(self, details): # listening for the corresponding message from the "backend" # (any session that .publish()es to this topic). def onevent(msg): print("Got event: {}".format(msg)) yield from self.subscribe(onevent, u'com.myapp.hello') # call a remote procedure. res = yield from self.call(u'com.myapp.add2', 2, 3) print("Got result: {}".format(res)) if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://127.0.0.1:8080/ws"), u"crossbardemo", debug=False, # optional; log even more details ) runner.run(MyComponent)
def run(self, url="ws://127.0.0.1:8080/ws", realm="realm1", debug_wamp=False, debug=False): runner = ApplicationRunner(url, realm, debug_wamp=debug_wamp, debug=debug) runner.run(self)
global done if not done: self.leave() # Disconnect done = True subscribe_args = {"options": {"return": ["id", "name", "category"]}} # Subscribe to ak.wwise.core.object.created # Calls on_object_created whenever the event is received yield From( self.subscribe(on_object_created, WAAPI_URI.ak_wwise_core_object_created, **subscribe_args)) print("Create an object in the Project Explorer") def onDisconnect(self): print("The client was disconnected.") asyncio.get_event_loop().stop() if __name__ == '__main__': runner = ApplicationRunner(url=u"ws://127.0.0.1:8080/waapi", realm=u"get_ancestors_demo") try: runner.run(MyComponent) except Exception as e: print( type(e).__name__ + ": Is Wwise running and Wwise Authoring API enabled?")
from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner from asyncio import coroutine class TestComponent(ApplicationSession): @coroutine def onJoin(self, details): print("session ready") try: res = yield from self.call('lockr.seat.get_id') print("call result: {}".format(res)) except Exception as e: print("call error: {0}".format(e)) if __name__ == '__main__': runner = ApplicationRunner(url='ws://localhost:8080/ws', realm='lockr') runner.run(TestComponent)
@locked async def cancel_reservation(self, token, details=None): if not isinstance(token, str): return False if token not in self.reservations: return False del self.reservations[token] self.schedule_reservations() return True @locked async def poll_reservation(self, token, details=None): try: res = self.reservations[token] except KeyError: return None res.refresh() return res.asdict() @locked async def get_reservations(self, details=None): return {k: v.asdict() for k, v in self.reservations.items()} if __name__ == '__main__': runner = ApplicationRunner( url=environ.get("WS", u"ws://127.0.0.1:20408/ws"), realm="realm1", ) runner.run(CoordinatorComponent)
threading.Thread(target=self.actually_run_command, args=(cmd, )).start() else: self.publish("io.crossbar.command.stdout", key) else: self.buffer += key self.publish("io.crossbar.command.on_key", key) def actually_run_command(self, cmd): process = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE) self.stdout.append("{}:$ {}".format(self.name, cmd)) for line in process.stdout: self.stdout.append(line.decode().strip()) async def start_publishing(self): while len(self.stdout) > 0: self.publish("io.crossbar.command.stdout", self.stdout.popleft()) while len(self.stdout) == 0: await asyncio.sleep(0.2) await self.start_publishing() async def onJoin(self, details): await self.register(self.get_prompt, "io.crossbar.command.id") await self.register(self.process_key, "io.crossbar.command.send_key") await self.start_publishing() if __name__ == '__main__': runner = ApplicationRunner("ws://localhost:8080/ws", "realm1") runner.run(STDOutSession)
def main(): parser = argparse.ArgumentParser() parser.add_argument( '-x', '--crossbar', metavar='URL', type=str, default="ws://127.0.0.1:20408/ws", help="crossbar websocket URL" ) subparsers = parser.add_subparsers(dest='command') place_parser = argparse.ArgumentParser(add_help=False) if 'PLACE' in os.environ: place_parser.add_argument( '-p', '--place', type=str, required=False, default=os.environ.get('PLACE') ) else: place_parser.add_argument('-p', '--place', type=str, required=True) subparser = subparsers.add_parser('resources') subparser.add_argument('-a', '--acquired', action='store_true') subparser.set_defaults(func=ClientSession.print_resources) subparser = subparsers.add_parser('places') subparser.add_argument('-a', '--acquired', action='store_true') subparser.set_defaults(func=ClientSession.print_places) subparser = subparsers.add_parser('add-place') subparser.set_defaults(func=ClientSession.add_place) subparser.add_argument('place') subparser = subparsers.add_parser('del-place') subparser.set_defaults(func=ClientSession.del_place) subparser.add_argument('place') subparser = subparsers.add_parser('add-alias', parents=[place_parser]) subparser.add_argument('alias') subparser.set_defaults(func=ClientSession.add_alias) subparser = subparsers.add_parser('del-alias', parents=[place_parser]) subparser.add_argument('alias') subparser.set_defaults(func=ClientSession.del_alias) subparser = subparsers.add_parser('set-comment', parents=[place_parser]) subparser.add_argument('comment') subparser.set_defaults(func=ClientSession.set_comment) subparser = subparsers.add_parser('add-match', parents=[place_parser]) subparser.add_argument('pattern') subparser.set_defaults(func=ClientSession.add_match) subparser = subparsers.add_parser('del-match', parents=[place_parser]) subparser.add_argument('pattern') subparser.set_defaults(func=ClientSession.del_match) subparser = subparsers.add_parser('acquire', parents=[place_parser]) subparser.set_defaults(func=ClientSession.acquire) subparser = subparsers.add_parser('release', parents=[place_parser]) subparser.set_defaults(func=ClientSession.release) subparser = subparsers.add_parser('env', parents=[place_parser]) subparser.set_defaults(func=ClientSession.env) subparser = subparsers.add_parser('power', parents=[place_parser]) subparser.add_argument('action', choices=['on', 'off', 'cycle', 'get']) subparser.set_defaults(func=ClientSession.power) subparser = subparsers.add_parser('connect', parents=[place_parser]) subparser.add_argument('-l', '--loop', action='store_true') subparser.set_defaults(func=ClientSession.connect) #subparser = subparsers.add_parser('attach', parents=[place_parser]) #subparser.set_defaults(func=ClientSession.attach) args = parser.parse_args() extra = { 'args': args, } if args.command: extra['loop'] = loop = asyncio.get_event_loop() #loop.set_debug(True) runner = ApplicationRunner( url=args.crossbar, realm="realm1", extra=extra ) runner.run(ClientSession) else: parser.print_usage()
from os import environ from autobahn.wamp.types import CallResult from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner class Component(ApplicationSession): """ Application component that calls procedures which produce complex results and showing how to access those. """ async def onJoin(self, details): res = await self.call('com.myapp.add_complex', 2, 3, 4, 5) print("Result: {} + {}i".format(res.kwresults['c'], res.kwresults['ci'])) res = await self.call('com.myapp.split_name', 'Homer Simpson') print("Forname: {}, Surname: {}".format(res.results[0], res.results[1])) self.leave() def onDisconnect(self): asyncio.get_event_loop().stop() if __name__ == '__main__': url = environ.get("AUTOBAHN_DEMO_ROUTER", "ws://127.0.0.1:8080/ws") realm = "crossbardemo" runner = ApplicationRunner(url, realm) runner.run(Component)
def timeserverNow(): return datetime.datetime.now() def computeCtrPredictionModel(adImpressions): # TODO: Implement Logic """ Features: 1. Timestamp: Hashed with 8 categorical values 2. Cosine Similarity: Search Phrases & Ad Target Phrases 3. Search Phrase: Hashed with n categorical values 4. Ad ID: Hashed with n categorical values, where n = count(ad) where ad.impressions > threshold """ return 100 def computeCpm(searchPhrases, qualifyingAds, currentTime): # TODO: Implement Logic return 100 class RegisterProcedure(ApplicationSession): def onJoin(self, details): self.register(timeserverNow, 'com.timeserver.now') self.register(computeCtrPredictionModel, 'compute.ctr') self.register(computeCpm, 'compute.cpm') runner = ApplicationRunner(url=CROSSBAR_URL, realm=CROSSBAR_REALM) runner.run(RegisterProcedure)
# -*- coding: utf-8 -*- ''' Se conecta al router wamp y hace correr el Wamp de Users ''' import inject inject.configure() if __name__ == '__main__': import sys import logging sys.path.insert(0, '../python') logging.basicConfig(level=logging.DEBUG) logging.getLogger().setLevel(logging.DEBUG) from autobahn.asyncio.wamp import ApplicationRunner from actions.systems.tutors.tutors import TutorsWamp from model.registry import Registry reg = inject.instance(Registry) registry = reg.getRegistry('wamp') url = registry.get('url') realm = registry.get('realm') debug = registry.get('debug') runner = ApplicationRunner(url=url, realm=realm) runner.run(TutorsWamp)
s = memcache.Client(["127.0.0.1:11211"]) keytext = sessDetails.realm + '.' + topic obj = s.get(keytext) # try get cached topic object if obj != None: print('backend re-publishing armote.trap.reedsensor', obj) #self.publish(topic, obj) return obj try: yield from asyncio.async(self.register(lastEvent, u'armote.trap.reedsensorLast')) print("procedure registered") except Exception as e: print("could not register procedure: {0}".format(e)) yield from asyncio.async(coap_request(self,sessDetails)) if __name__ == '__main__': wampAddress = u"ws://192.168.1.11:8080/ws" wampRealm = u"trapsensor" runner = ApplicationRunner( #environ.get("AUTOBAHN_TRAPSENSOR_ROUTER", u"ws://192.168.1.112:8080/ws"), wampAddress, realm = wampRealm, debug_wamp=False, # optional; log many WAMP sessDetails debug=False, # optional; log even more sessDetails ) runner.run(AppSession)
if __name__ == '__main__': # Crossbar.io connection configuration url = os.environ.get('CBURL', u'ws://localhost:8080/ws') realm = os.environ.get('CBREALM', u'realm1') # parse command line parameters parser = argparse.ArgumentParser() parser.add_argument('-d', '--debug', action='store_true', help='Enable debug output.') parser.add_argument('--url', dest='url', type=six.text_type, default=url, help='The router URL (default: "ws://localhost:8080/ws").') parser.add_argument('--realm', dest='realm', type=six.text_type, default=realm, help='The realm to join (default: "realm1").') args = parser.parse_args() # start logging if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') # any extra info we want to forward to our ClientSession (in self.config.extra) extra = { u'foobar': u'A custom value' } # now actually run a WAMP client using our session class ClientSession runner = ApplicationRunner(url=args.url, realm=args.realm, extra=extra) runner.run(Component1)
def main(): signal.signal(signal.SIGINT, signal_handler) runner = ApplicationRunner("wss://api.poloniex.com:443", "realm1") runner.run(PoloniexComponent)
# -*- coding: utf-8 -*- ''' Se conecta al router wamp y hace correr el Wamp del Digesto ''' if __name__ == '__main__': import sys, logging, inject sys.path.insert(0,'../python') logging.basicConfig(level=logging.DEBUG) from autobahn.asyncio.wamp import ApplicationRunner from model.config import Config from actions.systems.digesto.digesto import WampDigesto def config_injector(binder): binder.bind(Config,Config('server-config.cfg')) inject.configure(config_injector) config = inject.instance(Config) url = config.configs['server_url'] realm = config.configs['server_realm'] debug = config.configs['server_debug'] runner = ApplicationRunner(url=url,realm=realm,debug=debug, debug_wamp=debug, debug_app=debug) runner.run(WampDigesto)
def run(self): url = app.config['CROSSBAR_URL'] realm = app.config['CROSSBAR_REALM'] runner = ApplicationRunner(url=url, realm=realm) runner.run(notifier)
yield from self.register(current_frames, key+'.frames.state') def set_frames(frames, animation=anim): clean = lambda x: 0 if x is None else max(0, min(255, int(x))) animation.frames = map(clean, frames) yield from self.register(set_frames, key+'.frames.set') @anim.on_change def publish_anim(animation): key = "animation.%s" % animation.name self.publish(key+'.loop', animation.looping) self.publish(key+'.play', animation.playing) self.publish(key+'.fps', animation.fps) self.publish(key+'.frames', animation.frames) @asyncio.coroutine def onJoin(self, details): self.hal = HAL(HALFS_ROOT) yield from self.register(self.tree, u'tree') yield from self.register_switchs() yield from self.register_triggers() yield from self.register_animations() yield from self.register_rgbs() self.hal.install_loop() yield from self.periodic_tasks() if __name__ == '__main__': runner = ApplicationRunner(WAMP_BROKER, WAMP_REALM, debug_wamp=DEBUG) runner.run(Component)
@asyncio.coroutine def time_teller(self): while True: time_now = str(datetime.now().replace(microsecond=0)) self.publish('com.myapp.the_time', time_now) yield from asyncio.sleep(2) @wrap_in_future # the signal handler can't call a coroutine directly so we wrap it in a future @asyncio.coroutine def exit_cleanup(self): print("closing_time") # do some cleaning, wait for subprocess/coroutines to complete.., yield from asyncio.sleep(5) loop = asyncio.get_event_loop() for task in asyncio.Task.all_tasks(): # this is to avoid the cancellation of this coroutine because this coroutine need to be the last one running # to cancel all the others. if task is not asyncio.Task.current_task(): task.cancel() print("everything has been cancelled") loop.stop() if __name__ == "__main__": runner = ApplicationRunner(url="ws://127.0.0.1:8080/ws", realm="realm1", extra={'key': 'value that will be passed to MyBackend'}) runner.run(MyBackend)
class API: # http public_url = "https://poloniex.com/public" private_url = "https://poloniex.com/tradingApi" topic = None limiter = None max_calls = 6 max_period = 60 secrets = None # wamp ws_uri = "wss://api.poloniex.com" ws_realm = "realm1" runner = None callback = None class RunningAPI(ApplicationSession): async def onJoin(self, details): await self.subscribe(self.callback, self.topic) def __init__(self, config: ConfigObj or dict() = {}): self.secrets = config self.limiter = RateLimiter(max_calls=self.max_calls, period=self.max_period) self.runner = ApplicationRunner(self.ws_uri, self.ws_realm) # WAMP Streaming API def subscribe(self, topic: str, callback: callable): self.callback = callback self.topic = topic self.runner.run(API.RunningAPI()) # Public HTTP API, no credentials needed. def returnTicker(self): return self._call(sys._getframe().f_code.co_name, {}) def return24Volume(self): return self._call(sys._getframe().f_code.co_name, {}) def returnOrderBook(self, currencyPair: str = 'BTC_NXT', depth: int = 10): return self._call(sys._getframe().f_code.co_name, locals()) def returnTradeHistory(self, currencyPair: str = 'BTC_NXT', start: int = 1410158341, end: int = 1410499372): return self._call(sys._getframe().f_code.co_name, locals()) def returnChartData(self, currencyPair: str = 'BTC_NXT', start: int = 1405699200, end: int = 9999999999, period: int = 14400): return self._call(sys._getframe().f_code.co_name, locals()) def returnCurrencies(self): return self._call(sys._getframe().f_code.co_name, {}) def returnLoanOrders(self, currency: str = 'BTC'): return self._call(sys._getframe().f_code.co_name, locals()) # Private HTTP API Methods, Require API Key, and Secret on INIT def returnBalances(self): return self._call(sys._getframe().f_code.co_name, {}) def returnCompleteBalances(self, account: str = 'all'): return self._call(sys._getframe().f_code.co_name, locals()) def returnDepositAddresses(self): return self._call(sys._getframe().f_code.co_name, {}) def generateNewAddress(self, currency: str = 'BTC'): return self._call(sys._getframe().f_code.co_name, locals()) def returnDepositsWithdrawals(self, start: int = 1410158341, end: int = 1410499372): return self._call(sys._getframe().f_code.co_name, locals()) def returnOpenOrders(self, currencyPair: str = 'BTC_XCP'): return self._call(sys._getframe().f_code.co_name, locals()) def returnOrderTrades(self, orderNumber: int = None): return self._call(sys._getframe().f_code.co_name, locals()) def buy(self, rate: float, amount: float, currencyPair: str, fillOrKill: int, immediateOrCancel: int, postOnly: int): return self._call(sys._getframe().f_code.co_name, locals()) def sell(self, rate: float, amount: float, currencyPair: str, fillOrKill: int, immediateOrCancel: int, postOnly: int): return self._call(sys._getframe().f_code.co_name, locals()) def cancelOrder(self, orderNumber: int): return self._call(sys._getframe().f_code.co_name, locals()) def moveOrder(self, orderNumber: int, rate: float, amount: float, immediateOrCancel: int, postOnly: int): return self._call(sys._getframe().f_code.co_name, locals()) def withdraw(self, currency: str, amount: float, address: str, paymentId: str): return self._call(sys._getframe().f_code.co_name, locals()) def returnFeeInfo(self): return self._call(sys._getframe().f_code.co_name, {}) def returnAvailableAccountBalances(self, account: str = 'all'): return self._call(sys._getframe().f_code.co_name, locals()) def returnTradableBalances(self): return self._call(sys._getframe().f_code.co_name, {}) def transferBalance(self, currency: str, amount: float, fromAccount: str, toAccount: str): return self._call(sys._getframe().f_code.co_name, locals()) def returnMarginAccountSummary(self): return self._call(sys._getframe().f_code.co_name, {}) def marginBuy(self, currencyPair: str, rate: float, amount: float): return self._call(sys._getframe().f_code.co_name, locals()) def marginSell(self, currencyPair: str, rate: float, amount: float): return self._call(sys._getframe().f_code.co_name, locals()) def getMarginPosition(self, currencyPair: str): return self._call(sys._getframe().f_code.co_name, locals()) def closeMarginPosition(self, currencyPair: str): return self._call(sys._getframe().f_code.co_name, locals()) def createLoanOffer(self, currency: str, amount: float, duration: int, autoRenew: int, lendingRate: int): return self._call(sys._getframe().f_code.co_name, locals()) def cancelLoanOffer(self, orderNumber: int): return self._call(sys._getframe().f_code.co_name, locals()) def returnOpenLoanOffers(self): return self._call(sys._getframe().f_code.co_name, {}) def returnActiveLoans(self): return self._call(sys._getframe().f_code.co_name, {}) def returnLendingHistory(self): return self._call(sys._getframe().f_code.co_name, {}) def toggleAutoRenew(self, orderNumber: int): return self._call(sys._getframe().f_code.co_name, locals()) def _call(self, topic: str, args: dict() = {}): if topic in [ 'returnTicker', 'return24Volume', 'returnOrderBook', 'returnTradeHistory', 'returnChartData', 'returnCurrencies', 'returnLoanOrders' ]: api = [self.public_url, 'get', topic] else: api = [self.private_url, 'post', topic, self.secrets] def __call(api_details, uri): request = getattr(requests, api_details[1]) headers = {} del uri['self'] uri['command'] = api_details[2] if api_details[2] == 'post': uri['nonce'] = int(time.time() * 1000) sign = hmac.new(api_details[3]['secret'], uri, hashlib.sha512).hexdigest() headers['Sign'] = sign headers['Key'] = api_details[3]['api_key'] return json.loads( request(api_details[0], uri, headers=headers).content.decode()) with self.limiter: return __call(api, args)
def main(): ws = initialize_component() # secret = read_secret() runner = ApplicationRunner(ws, u"realm1") runner.run(AppSession)
class MyComponent(ApplicationSession): def onJoin(self, details): try: res = yield From(self.call( WAAPI_URI.ak_wwise_core_getinfo)) # RPC call without arguments except Exception as ex: print("call error: {}".format(ex)) else: # Call was successful, displaying information from the payload. print( "Hello {} {}".format(res.kwresults['displayName'], res.kwresults['version']['displayName'])) self.leave() def onDisconnect(self): print("The client was disconnected.") asyncio.get_event_loop().stop() if __name__ == '__main__': runner = ApplicationRunner(url=u"ws://127.0.0.1:8080/waapi", realm=u"realm1") try: runner.run(MyComponent) except Exception as e: print( type(e).__name__ + ": Is Wwise running and Wwise Authoring API enabled?")
return order_book quote = "CNY" base = "BTS" order_book_last = {} while True: try: order_book = get_order_book(quote,base) if (order_book_last != order_book): order_book_last = order_book #print("update now") #pprint(order_book) self.mypublish(u'btsbots.demo.order_book_%s_%s'%(quote,base), order_book) #else: #print("don't need update") except Exception as e: print(e) yield from sleep(10) def onLeave(self, details): print("onLeave: {}".format(details)) self.disconnect() def onDisconnect(self): self.IsConnect = False print("onDisconnect: {}".format(details)) runner = ApplicationRunner(url = config_wamp["url"], realm = config_wamp["realm"]) runner.run(MyComponent)
def make(config): ## # This component factory creates instances of the # application component to run. ## # The function will get called either during development # using the ApplicationRunner below, or as a plugin running # hosted in a WAMPlet container such as a Crossbar.io worker. ## if config: return Component1(config) else: # if no config given, return a description of this WAMPlet .. return {'label': 'Awesome WAMPlet 1', 'description': 'This is just a test WAMPlet that provides some procedures to call.'} if __name__ == '__main__': from autobahn.asyncio.wamp import ApplicationRunner # test drive the component during development .. runner = ApplicationRunner( url="ws://127.0.0.1:8080/ws", realm="realm1", debug=False, # low-level WebSocket debugging debug_wamp=False, # WAMP protocol-level debugging debug_app=True) # app-level debugging runner.run(make)
class Component(ApplicationSession): """ An application component calling the different backend procedures. """ async def onJoin(self, details): def on_event(val): print("Someone requested to square non-positive: {}".format(val)) await self.subscribe(on_event, u'com.myapp.square_on_nonpositive') for val in [2, 0, -2]: res = await self.call(u'com.myapp.square', val, options=CallOptions()) print("Squared {} = {}".format(val, res)) await self.leave() def onDisconnect(self): asyncio.get_event_loop().stop() if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", u"ws://127.0.0.1:8080/ws"), u"crossbardemo", ) runner.run(Component)
from os import environ import asyncio from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner class MyComponent(ApplicationSession): @asyncio.coroutine def onJoin(self, details): # listening for the corresponding message from the "backend" # (any session that .publish()es to this topic). def onevent(msg): print("Got event: {}".format(msg)) yield from self.subscribe(onevent, 'com.myapp.hello') # call a remote procedure. res = yield from self.call('com.myapp.add2', 2, 3) print("Got result: {}".format(res)) if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", "ws://127.0.0.1:8080/ws"), u"crossbardemo", debug_wamp=False, # optional; log many WAMP details debug=False, # optional; log even more details ) runner.run(MyComponent)
import asyncio import uvloop from autobahn.asyncio.wamp import ApplicationRunner from readserial import Output, create_serial_connection from sendreadings import MyComponent import functools ARDUINO = '/dev/ttyACM0' SPEED = 115200 commqueue = asyncio.Queue() asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) if __name__ == '__main__': loop = asyncio.get_event_loop() coro = create_serial_connection(loop, Output, commqueue, ARDUINO ,baudrate=SPEED) try: #loop.run_until_complete(coro) runner = ApplicationRunner(url=u"ws://localhost:8080/ws", realm=u"realm1", extra={"commqueue":commqueue}) import ipdb ipdb.set_trace() asyncio.ensure_future(coro, loop=loop) runner.run(MyComponent) except KeyboardInterrupt as e: print("Caught keyboard interrupt.") loop.run_forever() finally: loop.close()
user = yield from self.call('users.findByDni', dni) userEmail = { 'user_id': user["id"], 'email': email, 'confirmed': False } emailId = yield from self.call('users.mails.persistMail', userEmail) yield from self.call('users.mails.sendEmailConfirmation', emailId) sys.exit("***** Email alternativo agregado: " + user["name"] + " " + user["lastname"] + " " + email + " (" + emailId + ")") if __name__ == '__main__': from autobahn.asyncio.wamp import ApplicationRunner from autobahn.wamp.serializer import JsonSerializer url = config.configs['server_url'] realm = config.configs['server_realm'] debug = config.configs['server_debug'] json = JsonSerializer() runner = ApplicationRunner(url=url,realm=realm,debug=debug, debug_wamp=debug, debug_app=debug, serializers=[json]) runner.run(WampMain)
""" An application component calling the different backend procedures. """ @asyncio.coroutine def onJoin(self, details): def on_event(val): print("Someone requested to square non-positive: {}".format(val)) yield from self.subscribe(on_event, 'com.myapp.square_on_nonpositive') for val in [2, 0, -2]: res = yield from self.call('com.myapp.square', val, options=CallOptions(disclose_me=True)) print("Squared {} = {}".format(val, res)) self.leave() def onDisconnect(self): asyncio.get_event_loop().stop() if __name__ == '__main__': runner = ApplicationRunner( environ.get("AUTOBAHN_DEMO_ROUTER", "ws://localhost:8080/ws"), u"crossbardemo", debug_wamp=False, # optional; log many WAMP details debug=False, # optional; log even more details ) runner.run(Component)