def start(self): update = task.LoopingCall(self.updateSchedule) update.start(600) # Update from Google Calendar every 10 minutes execute = task.LoopingCall(self.execute) execute.start(60) # Start and stop services every minute session_class = create_scheduler_session(self) component = make_component(session_class) run(component) self.log.info("Scheduler terminated.")
def start(self): if self.started: return super(StandaloneDVR, self).start() class MyDVRSession(DVRSession): def __init__(elf, config=None): super(MyDVRSession, elf).__init__(config, dvr=self) session_class = MyDVRSession component = make_component(session_class) run(component) self.log.info("DVR terminated.")
def start_rie_session(self, robot_name=None, robot_realm=None): try: if robot_realm is None: # get the realm from config name_key = "pepper" if robot_name is None else robot_name.lower( ) robot_realm = config_helper.get_robot_settings( )["realm"][name_key] self.logger.info("{} REALM: {}".format(robot_name, robot_realm)) self.rie = Component(transports=[{ 'url': u"wss://wamp.robotsindeklas.nl", 'serializers': ['msgpack'], 'max_retries': 0 }], realm=robot_realm) self.logger.info("** {}".format(threading.current_thread().name)) self.rie.on_join(self.on_connect) self.logger.info("Running the rie component") run([self.rie]) except Exception as e: self.logger.error("Unable to run the rie component | {}".format(e))
], realm=u"crossbardemo", ) # 1. subscribe to a topic @demo.subscribe(u'io.crossbar.demo.hello') def hello(msg): print("Got hello: {}".format(msg)) # 2. register a procedure for remote calling @demo.register(u'io.crossbar.demo.add2') def add2(x, y): return x + y # 3. after we've authenticated, run some code @demo.on_join async def joined(session, details): # publish an event (won't go to "this" session by default) session.publish('io.crossbar.demo.hello', 'Hello, world!') # 4. call a remote procedure result = await session.call('io.crossbar.demo.add2', 2, 3) print("io.crossbar.demo.add2(2, 3) = {}".format(result)) await session.leave() if __name__ == "__main__": run([demo])
return print("Rebuilding.") path = "{}/venv/bin:{}".format(basedir, environ.get('PATH', '')) environ['PATH'] = path from twisted.internet import reactor yield _run(reactor, join(basedir, u'git'), u'/usr/bin/git', u'pull') yield _run(reactor, join(basedir, u'git', u'docs'), '/usr/bin/make', 'html') print("github push processed successfully") @builder.subscribe(u'webhook.github.', options=SubscribeOptions(match=u"prefix", details_arg="_details")) def _github_notify(**kw): details = kw.pop("_details") print("{}: {} {}".format(details.topic, kw.get('created_at', ''), kw.get('state', ''))) # print(kw.keys()) @builder.on_join def joined(session, details): print("builder joined: {} {}".format(session, details)) session.set_payload_codec(keyring) # e2e encryption keys if __name__ == '__main__': run([builder])
from autobahn.twisted.component import Component, run from autobahn.wamp.types import RegisterOptions from autobahn.wamp.exception import ApplicationError from twisted.internet.defer import inlineCallbacks component = Component( transports=u"ws://localhost:8080/auth_ws", realm=u"crossbardemo", authentication={ u"scram": { u"authid": u"carol", u"authrole": u"authenticated", u"password": u"p4ssw0rd", u"kdf": u"argon2id13", } } ) @component.on_join def joined(session, details): print("Session joined: {}".format(details)) if __name__ == "__main__": run([component]) #, log_level='debug')
def pub(topic): print("publishing '{}'".format(topic)) return session.publish( topic, options=PublishOptions(exclude_me=False), ) def call_progress(topic): print("calling '{}' progressively".format(topic)) def on_progress(some_data): print("received: '{}'".format(some_data)) return session.call( topic, options=CallOptions(on_progress=on_progress) ) reactor.callLater(1, pub, u'com.example.foo') reactor.callLater(2, pub, u'com.non_matching') reactor.callLater(3, pub, u'com.example.some.other.uri') reactor.callLater(4, call_progress, u'com.example.progressive') reactor.callLater(7, session.leave) @component.on_leave def leave(session, details): print("Session leaving: {}: {}".format(details.reason, details.message)) if __name__ == '__main__': run(component)
reactor.callLater(2, session.leave) @inlineCallbacks def setup_bob(reactor, session): print('bob created', session) def on_join(session, details): print('bob joined', session, details) session.on('join', on_join) yield sleep(1) print("bob done sleeping") # session.leave() if __name__ == '__main__': transports = [ { "type": "websocket", "url": "ws://127.0.0.1:8080/ws" } ] component1 = Component(on_join=setup_alice, transports=transports, realm=u'crossbardemo') component2 = Component(main=setup_bob, transports=transports, realm=u'crossbardemo') #run([component1, component2], log_level='debug') #run([component1, component2], log_level='info') run([component1], log_level='info') #run([component2], log_level='info')
A first component, which gets called "setup-like". When it returns, this signals that the component is ready for work. """ # expose the API on the session yield session.expose(api) @coroutine def component2(reactor, session): """ A second component, which gets called "main-like". When it returns, this will automatically close the session. """ result = yield session.call(u'com.example.add2', 2, 3) session.publish(u'com.example.on-hello', u'result={}'.format(result)) if __name__ == '__main__': from autobahn.twisted.component import Component, run # Components wrap either a setup or main function and # can be configured with transports, authentication and so on. components = [ Component(setup=component1), Component(main=component2) ] # a convenience runner is provided which takes a list of # components and runs all of them run(components)
} ) # the "on_join" notification runs when the WAMP session has # successfully connected, authenticated and hence joined a realm on # the router. @hook.on_join @defer.inlineCallbacks def join(session, details): print("joined: {}".format(details)) session.set_payload_codec(keyring) # e2e encryption keys topic = u'webhook.github.push' print("Publishing to: {}".format(topic)) data = { "ref": "refs/heads/master", "commits": [ { "id": "deadbeef", "message": "a commit message", } ] } yield session.publish(topic, **data) yield session.leave() if __name__ == '__main__': run([hook]) #, log_level='debug')
print('Buyer session joined', details) market_maker_adr = binascii.a2b_hex( session.config.extra['market_maker_adr'][2:]) print('Using market maker adr:', session.config.extra['market_maker_adr']) buyer_privkey = binascii.a2b_hex(session.config.extra['buyer_privkey'][2:]) # 100 XBR max_price = 100 * 10**18 buyer = SimpleBuyer(market_maker_adr, buyer_privkey, max_price) balance = await buyer.start(session, details.authid) balance = int(balance / 10**18) print("Remaining balance: {} XBR".format(balance)) async def on_event(key_id, enc_ser, ciphertext, details=None): try: payload = await buyer.unwrap(key_id, enc_ser, ciphertext) print('Received event {}:'.format(details.publication), payload) session.publish(u'xbr.myapp.cardata', payload['counter']) except Exception as e: print(e) session.leave() await session.subscribe(on_event, "io.crossbar.example", options=SubscribeOptions(details=True)) if __name__ == '__main__': run([buyer_component])
'path': '/tmp/cb1.sock' } }, { 'type': 'websocket', 'url': 'ws://127.0.0.1:8080/ws', 'endpoint': { 'type': 'tcp', 'host': '127.0.0.1', 'port': 8080 } } ] transports = TransportPool(transports) components = [ Component( transports, config=Config(realm=u'realm1'), setup=component1_setup ), Component( transports, config=Config(realm=u'realm1', extra={'foo': 23}), main=component2_main ) ] run(components)
from twisted.internet.defer import inlineCallbacks if len(sys.argv) < 3 or (sys.argv[2] != "0" and sys.argv[2] != "1"): print("Usage: eas-set-wc-state.py SERVER 0|1") print("where 0 means free and 1 means occupied") sys.exit(1) easclient = Component( transports=u"ws://%s/ws" % (sys.argv[1]), realm=u"eas", ) @easclient.on_join @inlineCallbacks def join(session, details): print("Joined session") try: wcstate = False if sys.argv[2] == "1": wcstate = True res = yield session.call(u'com.eas.set_wc_state', wcstate) except ApplicationError as e: print("ApplicationError, aborting: %s" % (e)) yield session.leave() if __name__ == '__main__': run([easclient])
], realm="realm1", authentication=AUTHENTICATION) @comp.on_join @inlineCallbacks def _(session, details): print("joined: {}".format(details)) topic_name = u"demo.foo" pid = os.getpid() counter = 0 while session.is_connected(): print("pid {} publish {} to '{}'".format(pid, counter, topic_name)) data = os.urandom(10) session.publish( topic_name, pid, counter, foo='0x' + binascii.b2a_hex(data).decode(), baz=data, options=PublishOptions(exclude_me=False), ) counter += 1 yield sleep(1) if __name__ == "__main__": run([comp], log_level='info')
help='Optional service name.') parser.add_argument('--service_uuid', dest='service_uuid', type=six.text_type, default=None, help='Optional service UUID.') args = parser.parse_args() log_level = 'debug' if args.debug else 'info' # any extra info we want to forward to our ClientSession (in self.config.extra) extra = { u'service_name': args.service_name or "default", u'service_uuid': args.service_uuid, } client = Component(transports=args.url, realm=args.realm, main=main, extra=extra, authentication={ "anonymous": { "authrole": "anonymous", }, }) # starts the reactor, and logging -- this won't return unless all # our components complete run([client])
def main(): load_env() Logger().info("Starting directory service...") component = make_component(Directory) run(component)
) # 1. subscribe to a topic @demo.subscribe(u'io.crossbar.demo.hello') def hello(msg): print("Got hello: {}".format(msg)) # 2. register a procedure for remote calling @demo.register(u'io.crossbar.demo.add2') def add2(x, y): return x + y # 3. after we've authenticated, run some code @demo.on_join async def joined(session, details): # publish an event (won't go to "this" session by default) session.publish('io.crossbar.demo.hello', 'Hello, world!') # 4. call a remote procedure result = await session.call('io.crossbar.demo.add2', 2, 3) print("io.crossbar.demo.add2(2, 3) = {}".format(result)) await session.leave() if __name__ == "__main__": run([demo])
# ############################################################################### import datetime import os import random from autobahn.twisted.component import Component, run import txaio odometer_component = Component(transports=os.environ.get( 'XBR_INSTANCE', u'ws://localhost:8080/ws'), realm=os.environ.get('XBR_REALM', u'realm1')) @odometer_component.on_join async def joined(session, _details): print("session joined...") counter = 20000 while session.is_attached(): date = datetime.datetime.now() print('Odometer Simulator publishing xbr.myapp.odometer', counter, date) session.publish(u'xbr.myapp.odometer', f'{counter} {date}') counter += random.randint(1, 10) await txaio.sleep(1) if __name__ == '__main__': run([odometer_component])
"endpoint": { "type": "tcp", "host": "localhost", "port": 8443, }, "serializers": ["json", "cbor"], }, ], realm="realm1", ) @comp.on_join @inlineCallbacks def _(session, details): print("joined: {}".format(session)) topic_name = u"io.crossbar.demo.public.foo" def _foo(*args, **kw): print("{}: {} {}".format(topic_name, args, kw)) session.subscribe(_foo, topic_name) print("subscribed") while session.is_connected(): print(".") yield sleep(1) if __name__ == "__main__": run([comp]) #, log_level='debug')
"type": "websocket", "url": "wss://127.0.0.1:8083/ws", "endpoint": SSL4ClientEndpoint( reactor, '127.0.0.1', 8080, optionsForClientTLS('localhost'), ), } clearnet_transport = { "type": "websocket", "url": "ws://127.0.0.1:8080/ws", "endpoint": TCP4ClientEndpoint(reactor, 'localhost', 8080) } transports = [ tls_transport_untrusted, tls_transport, clearnet_transport, ] # try main= vs. setup= to see different exit behavior component = Component(main=setup, transports=transports, realm='crossbardemo') #component = Component(setup=setup, transports=transports, realm='crossbardemo') # can add this confirm logging of more error-cases #component.session_factory = Foo txaio.start_logging(level='info') run(component)
reactor.callLater(2, session.leave) @inlineCallbacks def setup_bob(reactor, session): print('bob created', session) def on_join(session, details): print('bob joined', session, details) session.on('join', on_join) yield sleep(1) print("bob done sleeping") # session.leave() if __name__ == '__main__': transports = [{"type": "websocket", "url": "ws://127.0.0.1:8080/ws"}] component1 = Component(on_join=setup_alice, transports=transports, realm=u'crossbardemo') component2 = Component(main=setup_bob, transports=transports, realm=u'crossbardemo') #run([component1, component2], log_level='debug') #run([component1, component2], log_level='info') run([component1], log_level='info') #run([component2], log_level='info')
} component = Component(transports=[transport], realm="deskconn", session_factory=GPIOComponent) component._transports[0].max_retries = 0 return component if __name__ == '__main__': if os.environ.get("SNAP_NAME") == "piconn": crossbar = os.path.expandvars( "$SNAP_COMMON/crossbar-runtime-dir/bin/crossbar") if not os.path.exists(crossbar): print( "Waiting for crossbar runtime directory interface to connect") while not os.path.exists(crossbar): time.sleep(1) print("Found crossbar runtime environment") else: os.environ['SNAP_COMMON'] = os.path.expandvars('$HOME') sock_path = os.path.join( os.path.expandvars('$SNAP_COMMON/deskconnd-sock-dir'), 'deskconnd.sock') print("finding deskconnd...") while not os.path.exists(sock_path): time.sleep(1) print("found, now connecting.") run([assemble()])
from autobahn.twisted.component import Component, run from autobahn.twisted.util import sleep from twisted.internet.defer import inlineCallbacks import os url = os.environ.get('CBURL', u'ws://localhost:8080/ws') realmvalue = os.environ.get('CBREALM', u'realm1') component = Component(transports=url, realm=realmvalue) @component.on_join @inlineCallbacks def joined(session, details): print("session ready") def oncounter(count): print("event received: {0}", count) try: yield session.subscribe(oncounter, u'my.com.hello') print("subscribed to topic") except Exception as e: print("could not subscribe to topic: {0}".format(e)) if __name__ == "__main__": run([component])
from autobahn.twisted.component import Component, run display_component = Component( transports=os.environ.get('XBR_INSTANCE', u'ws://localhost:8080/ws'), realm=os.environ.get('XBR_REALM', u'realm1') ) @display_component.on_join async def joined(session, _details): data = None def get_distance(): return data def on_car_data(self, car_data): print("Got event: {}".format(car_data)) nonlocal data data = car_data print("session attached") sub = await session.subscribe(on_car_data, 'xbr.myapp.cardata') print("Subscribed to xbr.myapp.cardata with {}".format(sub.id)) await session.register(get_distance, 'xbr.myapp.get_distance') print("Procedure {} registered".format("xbr.myapp.get_distance")) if __name__ == '__main__': run([display_component])
topic = 'io.crossbar.example' seller = SimpleSeller(market_maker_adr, seller_privkey) # 1 XBR price = 1 * 10 ** 18 interval = 12 seller.add(api_id, topic, price, interval, None) balance = await seller.start(session) balance = int(balance / 10 ** 18) print("Remaining balance: {} XBR".format(balance)) async def on_odometer_data(count): print("event received: {}".format(count)) payload = {'data': 'py-seller', 'counter': count} key_id, enc_ser, ciphertext = await seller.wrap(api_id, topic, payload) pub = await session.publish(topic, key_id, enc_ser, ciphertext, options=PublishOptions(acknowledge=True)) print('Published event {}: {}'.format(pub.id, payload)) try: await session.subscribe(on_odometer_data, "xbr.myapp.odometer") print("subscribed to topic '{}'".format("xbr.myapp.odometer")) except Exception as e: print("could not subscribe to topic: {}".format(e)) if __name__ == '__main__': run([seller_component])
def do(self, command): self.__define_action_to_subscribe(command) run(self.__component)
seller.add(api_id, topic, price, interval, None) balance = await seller.start(session) balance = int(balance / 10**18) print("Remaining balance: {} XBR".format(balance)) while running: payload = {'data': 'py-seller', 'counter': counter} key_id, enc_ser, ciphertext = await seller.wrap(api_id, topic, payload) pub = await session.publish(topic, key_id, enc_ser, ciphertext, options=PublishOptions(acknowledge=True)) print('Published event {}: {}'.format(pub.id, payload)) counter += 1 await sleep(10) @comp.on_leave def left(session, details): print('Seller session left', details) global running running = False if __name__ == '__main__': run([comp])
def launcher(config, privkey_file, id, python, workdir): """ Runs the CTS 'Launcher' process. The launcher is a CTS process started on a host taking part in a CTS test setup and is responsible for starting processes like probes and testees. It exposes an API via WAMP. This function is also specified as an entry point in setup.py for the `ctslauncher` script. """ # create clean working directory for Python virtualenvs # if not os.path.exists(workdir): print("Working directory {} does not exist. Creating ...".format( workdir)) os.makedirs(workdir) else: if not os.path.isdir(workdir): print( "Fatal: path {} for working directory exists, but is not a directory" .format(workdir)) sys.exit(1) else: print( "Working directory {} exists already - cleaning and recreating." .format(workdir)) try: shutil.rmtree(workdir) except Exception as e: print( "Fatal: error during cleaning of working directory - {}" .format(e)) os.makedirs(workdir) with open(privkey_file, 'rb') as f: privkey = f.read() comp = Component( transports=[{ u"type": u"websocket", u"url": config.router, }], realm="io.crossbar.cts", authentication={ "cryptosign": { "authid": id, "privkey": binascii.b2a_hex(privkey), } }, ) from twisted.internet import reactor @comp.on_join async def setup_launcher(session, details): ip = await session.call("io.crossbar.cts.launcher_ip", details.session) print("address: {}".format(ip)) print("Launcher '{}' connected, session_id={}".format( id, details.session)) try: # XXX since we already loaded the key, maybe privkey= instead of privkey_file here? launch = await create_launcher(reactor, session, id, ip, workdir, config.router, privkey_file, pythons=python) except Exception as e: print(str(e)) raise ##await session.leave() run([comp], log_level=("debug" if config.debug else "info"))
from autobahn.wamp.types import RegisterOptions from autobahn.wamp.exception import ApplicationError from twisted.internet.defer import inlineCallbacks, CancelledError @inlineCallbacks def main(reactor, session): print("Client session={}".format(session)) d = session.call("example.foo", "some", "args") print("Called 'example.foo': {}".format(d)) print("cancel()-ing the above Deferred") d.cancel() try: res = yield d print("somehow we got a result: {}".format(res)) except CancelledError: print("call was canceled successfully") print("done") component = Component( transports="ws://localhost:8080/auth_ws", main=main, realm="crossbardemo", ) if __name__ == "__main__": run([component]) #, log_level='debug')
webapp = Klein() @webapp.route('/', methods=['POST']) def index(request: Request): content = json.loads(request.content.read()) try: new_state = GameState(**content) except Exception as e: print(content) print(e) return "wew" wamp_component.state = new_state print(wamp_component.state.map.game_state) return "ok" if __name__ == "__main__": from twisted.web.server import Site from twisted.internet import reactor, task import sys print(sys.path) reactor.listenTCP(8016, Site(webapp.resource())) run([wamp_component])
print(f"New interval: {rules[0]['interval']}") # Check rules for rule in rules: schedule_work(rule["interval"]) @component.on_join @inlineCallbacks def joined(session, details): global save_session global save_detail save_session = session save_detail = details print("session ready") print(f"Device id: {device_id}") try: session.subscribe(oncounter, topic) print("subscribed to topic") except Exception as e: print("could not subscribe to topic: {0}".format(e)) yield 0 # yield perodic_work() if __name__ == "__main__": run([component])
print("Session attached") if mySession is None: mySession = session rooms = Room.select().join(Patient, JOIN.LEFT_OUTER) for room in rooms: mySession.publish(u"com.eas.room_added", name=room.name, priority=room.priority) if room.patient is not None: mySession.publish( u"com.eas.room_populated", unicode(room.name), { u"id": unicode(room.patient.patId), u"name": unicode(room.patient.name), u"surname": unicode(room.patient.surname), u"title": unicode(room.patient.title) }) def createTables(): with db: db.create_tables([Patient, Room]) if __name__ == '__main__': db.connect() createTables() run([eascomp])