def callback(res): # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) # oznajmiamy mu, że będziemy jego następnikiem d1.addCallback(lambda p: p.callRemote(commands.NewNode, key=dumps(self.key), address=self.address, port=self.port)) def new_node(res2): # dostajemy jego db, i nastepnika self.node = Node( self.address, self.port, self.key, loads(res2['stop']), Neighbor(loads(res2['node']), res2['address'], res2['port']), Neighbor(res['node'], res['address'], res['port']), loads(res2['db'])) # dodajemy node do ProtoFactory bo tego mu brakuje self.pf.node = self.node # kontaktujemy się z następnikiem i informujemy, że jesteśmy jego poprzednikiem d2 = ClientCreator(reactor, amp.AMP).connectTCP(res2['address'], res2['port']) d2.addCallback(lambda p: p.callRemote(commands.NewPrev, node=dumps(self.key), address=self.address, port=self.port)) d1.addCallback(new_node)
def connectClient(self): d = ClientCreator(reactor, txprotobuf.Protocol).connectTCP(self.port.getHost().host, self.port.getHost().port) def setProtocol(protocol): self.protocols.append(protocol) return protocol d.addCallback(setProtocol) return d
def find_node(self, key, address=None, port=None): # find node nie moze byc wywolany jesli self.node jest node ktorego szukamy # if (address is None or port is None): if self.node is None: return # moze jakis wyjatek tu trzeba rzucic else: key, address, port = self.node.find_node(key).unpack() # łączymy się ze znanym węzłem w sieci i poszukujemy rekurencyjnie węzła, który zostanie # naszym następnikiem # d = ClientCreator(reactor, amp.AMP).connectTCP(address, port) d.addCallback( lambda p: p.callRemote(commands.FindNode, key=dumps(key))) def callback(res): res['node'] = loads(res['node']) if res['my_key']: return res else: return self.find_node(key, res['address'], res['port']) d.addCallback(callback) return d
def connect(self): spec = txamqp.spec.load(self.config.spec()) delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=self.config.vhost(), spec=spec)\ .connectTCP(self.config.host(), self.config.port()) d.addCallback(self.got_connection) self.d = defer.Deferred() yield self.d
def main(): creator = ClientCreator(reactor, TTwisted.ThriftClientProtocol, Infrastructure.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(config.IAAS_INTERFACE_IPV4, config.IAAS_PORT) creator.addCallback(lambda conn: conn.client) creator.addCallback(connected) reactor.run()
def callback( res): # res zawiera dane serwera na ktorym moze byc klucz # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) d1.addCallback( lambda p: p.callRemote(commands.Set, key=key, value=value)) return d1 # deffer, który zawierać będzie wynik metody set na właściwym serwerze
def __init__(self): spec = txamqp.spec.load('amqp-spec-0-9-1.xml') self.connected = False d = ClientCreator(reactor, AMQClient, delegate=TwistedDelegate(), vhost='/', spec=spec).connectTCP('127.0.0.1', 5672) d.addCallback(self.amqp_connected) self.flowCache = {} self.flowSeen = []
def callback(res): # res zawiera dane serwera na ktorym moze byc klucz # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) d1.addCallback(lambda p: p.callRemote(commands.Get, key=key)) def trapError(result): result.trap(Exception) raise result.type() d1.addErrback(trapError) return d1 # deffer, który zawierać będzie wynik metody get na właściwym serwerze
def connectClient(self): d = ClientCreator(reactor, txprotobuf.Protocol).connectTCP( self.port.getHost().host, self.port.getHost().port) def setProtocol(protocol): self.protocols.append(protocol) return protocol d.addCallback(setProtocol) return d
def addcall(self, obj, callback=None, **kwargs): d = ClientCreator(reactor, amp.AMP).connectTCP(self.address, self.port) d.addCallback(lambda p: p.callRemote(obj, **kwargs)) if callback is None: def callback(res): print "Otrzymano: ", res d.addCallback(callback) def trapError(result): result.trap(Exception) print "Błąd!: {0}".format(result.type) d.addErrback(trapError) return d
def setup(vm): print 'Connecting with new domain...' creator = ClientCreator(reactor, TTwisted.ThriftClientProtocol, RelayService.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(DEFAULT_SETUP_IP, config.RELAY_PORT) creator.addCallback(lambda conn: conn.client) creator.addCallback(connection_established, vm) creator.addErrback(error, vm)
def connect(self): d = ClientCreator( reactor, TTwisted.ThriftClientProtocol, Scheduler.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(self.host, self.port, self.timeout) d.addCallback(self.set_connect) d.addErrback(self.close_conn) log.msg("try connect to Scheduler[%s:%s]" % \ (self.host, self.port)) return d
def connect(self): d = ClientCreator(reactor, TTwisted.ThriftClientProtocol, Scheduler.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(self.host, self.port, self.timeout) d.addCallback(self.set_connect) d.addErrback(self.close_conn) log.msg("try connect to Master[%s:%s]" % \ (self.host, self.port)) return d
def new_node(res2): # dostajemy jego db, i nastepnika self.node = Node(self.address, self.port, self.key, loads(res2['stop']), Neighbor(loads(res2['node']), res2['address'], res2['port']), Neighbor(res['node'], res['address'], res['port']), loads(res2['db'])) # dodajemy node do ProtoFactory bo tego mu brakuje self.pf.node = self.node # kontaktujemy się z następnikiem i informujemy, że jesteśmy jego poprzednikiem d2 = ClientCreator(reactor, amp.AMP).connectTCP(res2['address'], res2['port']) d2.addCallback(lambda p: p.callRemote(commands.NewPrev, node=dumps(self.key), address=self.address, port=self.port))
def start(self): vhost = self.amqp_conn['vhost'] host = self.amqp_conn['host'] port = self.amqp_conn['port'] d = ClientCreator(reactor, AMQClient, delegate=TwistedDelegate(), vhost=vhost, spec=self.spec).connectTCP(host, port) d.addCallback(self.gotConnection) d.addErrback(self.whoops)
def configure_domain(self, clone_entry): ''' Reconfigures a domain by running the reconfiguration drone ''' print 'Connecting with new domain.' creator = ClientCreator(reactor, TTwisted.ThriftClientProtocol, RelayService.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(DEFAULT_SETUP_IP, config.RELAY_PORT, timeout=10) creator.addCallback(lambda conn: conn.client) creator.addCallback(self._launch_drone, clone_entry) creator.addErrback(self._configuration_error, clone_entry)
def main(all_args=None): """The main""" all_args = all_args or [] parser = optparse.OptionParser() options, args = parse_cmd_line(parser, all_args) (port, example, message, count_, topics) = check_cmd_line( options, args, parser.error) host = 'localhost' vhost = '/' username = '******' password = '******' spec = txamqp.spec.load('your_specs_path.xml') delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password) if example in PUBLISH_EXAMPLES: d.addCallback(ALL_EXAMPLES[example], message, count_) else: d.addCallback(ALL_EXAMPLES[example], topics) d.addCallback(publisher_cleanup) d.addErrback(lambda f: sys.stderr.write(str(f))) reactor.run()
def _try_connecting(domain, defer): ''' Connects with the domain's Relay service. If it does not respond in 5 seconds it is assumed that the domain is not available right now ''' creator = ClientCreator(reactor, TTwisted.ThriftClientProtocol, RelayService.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(domain, config.RELAY_PORT, timeout=10) creator.addCallback(lambda conn: conn.client) creator.addCallback(lambda value: defer.callback(True)) creator.addErrback(lambda value: defer.callback(False))
def main(all_args=None): """The main""" # all_args = all_args or [] # parser = optparse.OptionParser() # options, args = parse_cmd_line(parser, all_args) # (port, example, message, count_, topics) = check_cmd_line( # options, args, parser.error) host = "localhost" port = 5672 vhost = "/" username = "******" password = "******" example = "publish2" topics = "#" message = "hello" count = 1000 spec = txamqp.spec.load("./specs/rabbitmq/amqp0-8.stripped.rabbitmq.xml") delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password) if example in PUBLISH_EXAMPLES: d.addCallback(ALL_EXAMPLES[example], message, count) else: d.addCallback(ALL_EXAMPLES[example], topics) d.addCallback(publisher_cleanup) d.addErrback(lambda f: sys.stderr.write(str(f))) reactor.run()
def _makeNewProtocol(self, tosend): import twisted.internet.reactor as reactor deferred = Deferred() def makeProtocol(): return SoapProtocol(con=self.con) def sendPacket(protocol): if protocol is None: return # silently fail - log this? TODO protocol.sendPacket(tosend).addCallback(deferred.callback) return protocol conn_d = ClientCreator(reactor, makeProtocol).connectTCP( host=self.con._message_maker._host, port=self.con._message_maker._port) conn_d.addCallback(sendPacket) conn_d.addCallbacks(self._newProtocolConnected, self._onConnectionError) return deferred
def get_coins(self, amount=5): packet = [constants.Header.SIGN] blinding_factors = list() for _ in range(int(amount)): msg = pick_random() blinding_factor = pick_random() key = RSA.importKey(constants.B.public_key) blind = b64encode(key.blind(msg, blinding_factor)) packet.append(blind) blinding_factors.append((blinding_factor, msg)) d = ClientCreator(reactor, BankClient).connectTCP(constants.B.external_ip, constants.B.port) d.addCallback(self._send_blinds, blinding_factors, packet) d.addErrback(self._error, "Bank")
def callback( res): # res zawiera dane serwera na ktorym moze byc klucz # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) d1.addCallback(lambda p: p.callRemote(commands.Get, key=key)) def trapError(result): result.trap(Exception) raise result.type() d1.addErrback(trapError) return d1 # deffer, który zawierać będzie wynik metody get na właściwym serwerze
def _connect(self): spec_path = os.path.dirname(__file__) + "/amqp0-8.stripped.rabbitmq.xml" spec = txamqp.spec.load(spec_path) self.delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=self.delegate, vhost=self._configuration["vhost"], spec=spec).connectTCP(self._configuration["host"], self._configuration["port"]) d.addCallback(self._connected) def whoops(err): if reactor.running: log.err(err) self.shutdown() reactor.stop() d.addErrback(whoops)
def connect(hosts_map): dlist = [] for i in hosts_map: print 'Connecting with relay %s:%i ' % (i, config.RELAY_PORT) creator = ClientCreator(reactor, TTwisted.ThriftClientProtocol, RelayService.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP(i, config.RELAY_PORT) creator.addCallback(lambda conn: conn.client) d = defer.Deferred() creator.addCallback(d.callback) dlist.append(d) return dlist
def connect_to_server(): host = conf.BROKER_HOST port = conf.BROKER_PORT vhost = conf.BROKER_VHOST username = conf.BROKER_USER password = conf.BROKER_PASSWORD delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, int(port)) d.addCallback(got_connection, username, password) def errback(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(errback)
def doTask(self): self.state = TaskStates.STATE_WAITING log.debug("Connecting to %s (%s)", self._devId, self._manageIp) spec = txamqp.spec.load(os.path.join(os.path.dirname(__file__), "lib/txamqp/specs/standard/amqp0-8.xml")) delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, spec=spec, vhost=self._config.zAMQPVirtualHost).connectTCP(self._config.manageIp, self._config.zAMQPPort) d.addCallback(self._onConnSucc, self._config.zAMQPQueue, self._config.zAMQPUsername, self._config.zAMQPPassword) d.addErrback(self._onConnFail) return d
def update_providers(self, location="", retry=False): """ Update location of user and tell providers """ if retry: sleep(2) if location != "": self.location = location self.io.sendLine("Your location: %s" % self.location) # create new pseudonym for location self.pseudonym = pick_random() self.seed = pick_random() self.paging_names = create_paging_names(self.seed, amount=100) d = ClientCreator(reactor, UserClientProtocol, self).connectTCP(constants.N.external_ip, constants.N.port) d.addCallback(self._update_location) if retry: d.addErrback(self._error, "network operator") else: d.addErrback(self.retry)
def main(): PORT = 5672 MESSAGE = "Hello publixh 1" COUNT = 10 TOPICS = 'topic_name' HOST = 'localhost' VHOST = '/' USERNAME = '******' PASSWORD = '******' spec_path = '{0}/switch/broker/specs/amqp0-8.rabbitmq.xml'.format( settings.PROJECT_ROOT) SPEC = get_spec(spec_path) delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=VHOST, spec=SPEC).connectTCP(HOST, PORT) # auth and get channel d.addCallback(gotConnection, USERNAME, PASSWORD) # publish something d.addCallback(publish3, MESSAGE, COUNT) # consume #d.addCallback(consume3, TOPICS) d.addCallback(publisher_cleanup) reactor.run()
def dataReceived(self, data): self.transport.write(data) campo = data.split(";") #print campo[0],";",campo[1],";",campo[2] # Send an SMS-MT with defined originating address host = '127.0.0.1' port = 5672 vhost = '/' username = '******' password = '******' spec_file = '/etc/jasmin/resource/amqp0-9-1.xml' MO_dst = '24247' MO_src = campo[1] # transformation of the source address! :-) MOD_MO_src = '00' + MO_src[2:] texto = campo[0] spec = txamqp.spec.load(spec_file) delegate = TwistedDelegate() # Connect and authenticate d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password,MOD_MO_src,MO_dst,texto) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) def __init__(self, amqpBroker): self.amqpBroker = amqpBroker
def find_node(self, key, address=None, port=None): # find node nie moze byc wywolany jesli self.node jest node ktorego szukamy # if (address is None or port is None): if self.node is None: return # moze jakis wyjatek tu trzeba rzucic else: key, address, port = self.node.find_node(key).unpack() # łączymy się ze znanym węzłem w sieci i poszukujemy rekurencyjnie węzła, który zostanie # naszym następnikiem # d = ClientCreator(reactor, amp.AMP).connectTCP(address, port) d.addCallback(lambda p: p.callRemote(commands.FindNode, key=dumps(key))) def callback(res): res['node'] = loads(res['node']) if res['my_key']: return res else: return self.find_node(key, res['address'], res['port']) d.addCallback(callback) return d
reactor.stop() if __name__ == "__main__": host = '127.0.0.1' port = 5672 vhost = '/' username = '******' password = '******' spec_file = '/etc/jasmin/resource/amqp0-9-1.xml' spec = txamqp.spec.load(spec_file) # Connect and authenticate d = ClientCreator(reactor, AMQClient, delegate=TwistedDelegate(), vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
yield chan.channel_open() msg = Content(body) msg["delivery mode"] = 2 chan.basic_publish(exchange=config['exchange'], content=msg) yield chan.channel_close() chan0 = yield conn.channel(0) yield chan0.connection_close() reactor.stop() if __name__ == "__main__": import sys if len(sys.argv) != 3: print "%s path_to_spec content" % sys.argv[0] sys.exit(1) config = process_config(read_config(settings.gitosis_config)) spec = txamqp.spec.load(sys.argv[1]) authentication = {"LOGIN": config['user_id'], "PASSWORD": config['password']} delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost="/", spec=spec).connectTCP(config['host'], config['port']) d.addCallback(gotConnection, authentication, sys.argv[2]) reactor.run()
try: quotient = yield client.calculate(1, work) print('Whoa? You know how to divide by zero?') print('FYI the answer is %d' % quotient) except InvalidOperation as e: print(('InvalidOperation: %r' % e)) work.op = Operation.SUBTRACT work.num1 = 15 work.num2 = 10 diff = yield client.calculate(1, work) print(('15-10=%d' % (diff))) log = yield client.getStruct(1) print(('Check log: %s' % (log.value))) reactor.stop() if __name__ == '__main__': d = ClientCreator( reactor, TTwisted.ThriftClientProtocol, Calculator.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP("127.0.0.1", 9090) d.addCallback(lambda conn: conn.client) d.addCallback(main) reactor.run()
host = sys.argv[1] port = int(sys.argv[2]) vhost = sys.argv[3] username = sys.argv[4] password = sys.argv[5] spec = txamqp.spec.load(sys.argv[6]) content = sys.argv[7] try: count = int(sys.argv[8]) except: count = 1 delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password, content, count) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
dl = defer.DeferredList([d1, d2, d3, d4, d5, d6, d7, d8]) dl.addCallback(lambda _: reactor.stop()) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser( description="Example Thrift server", usage= "%(prog)s localhost 5672 / guest guest ../../specs/standard/amqp0-8.stripped.xml" ) parser.add_argument('host') parser.add_argument('port', type=int) parser.add_argument('vhost') parser.add_argument('username') parser.add_argument('password') parser.add_argument('spec_path') args = parser.parse_args() spec = txamqp.spec.load(args.spec_path) delegate = TwistedDelegate() d = ClientCreator(reactor, ThriftAMQClient, delegate, args.vhost, spec).connectTCP(args.host, args.port) d.addCallback(prepareClient, args.username, args.password).addCallback(gotClient) reactor.run()
def __enter__(self): d = ClientCreator(reactor, amp.AMP).connectTCP(self.host, self.port, timeout=self.timeout) d.addCallback(self.connectionEstablished) return d
parser.add_argument('port', type=int) parser.add_argument('vhost') parser.add_argument('username') parser.add_argument('password') parser.add_argument('spec_path') parser.add_argument('content') parser.add_argument('count', type=int, default=1) args = parser.parse_args() spec = txamqp.spec.load(args.spec_path) delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=args.vhost, spec=spec).connectTCP(args.host, args.port) d.addCallback(gotConnection, args.username, args.password, args.content, args.count) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
work.num1 = 1 work.num2 = 0 try: quotient = yield client.calculate(1, work) print 'Whoa? You know how to divide by zero?' except InvalidOperation, io: print 'InvalidOperation: %r' % io work.op = Operation.SUBTRACT work.num1 = 15 work.num2 = 10 diff = yield client.calculate(1, work) print '15-10=%d' % (diff) log = yield client.getStruct(1) print 'Check log: %s' % (log.value) reactor.stop() if __name__ == '__main__': d = ClientCreator(reactor, TTwisted.ThriftClientProtocol, Calculator.Client, TBinaryProtocol.TBinaryProtocolFactory(), ).connectTCP("127.0.0.1", 9090) d.addCallback(lambda conn: conn.client) d.addCallback(main) reactor.run()
d7 = client.calculate(5, w).addCallbacks(gotCalculateResults, gotCalculateErrors).addErrback(gotTransportError) d8 = client.zip() dl = defer.DeferredList([d1, d2, d3, d4, d5, d6, d7, d8]) dl.addCallback(lambda _: reactor.stop()) if __name__ == '__main__': import sys if len(sys.argv) != 7: print "%s host port vhost username password path_to_spec" % sys.argv[0] sys.exit(1) host = sys.argv[1] port = int(sys.argv[2]) vhost = sys.argv[3] username = sys.argv[4] password = sys.argv[5] specFile = sys.argv[6] spec = txamqp.spec.load(specFile) delegate = TwistedDelegate() d = ClientCreator(reactor, ThriftAMQClient, delegate, vhost, spec).connectTCP(host, port) d.addCallback(prepareClient, username, password).addCallback(gotClient) reactor.run()
def __init__(self, name): self.name = name def connected(self, protocol): self._protocol = protocol self._protocol.callRemote(Join, name=self.name).addCallback(self.joined) def joined(self, results): if results['result']: print 'Successfully joined game!' if __name__ == '__main__': arguments = docopt(__doc__, version='PokerNight Client 2.0') globals.username = arguments['<yourName>'] server = arguments['<serverAddress>'] root = Tk() tksupport.install(root) p = Player(globals.username) globals.gui = GUI(root) client = ClientCreator(reactor, ClientProtocol).connectTCP(server, 1234) client.addCallback(p.connected) client = ClientCreator(reactor, ClientProtocol).connectTCP(server, 1234) client.addCallback(globals.gui.connected) reactor.run()
import argparse parser = argparse.ArgumentParser( description="Example consumer", usage="%(prog)s localhost 5672 / guest guest ../../specs/standard/amqp0-8.stripped.xml" ) parser.add_argument('host') parser.add_argument('port', type=int) parser.add_argument('vhost') parser.add_argument('username') parser.add_argument('password') parser.add_argument('spec_path') args = parser.parse_args() spec = txamqp.spec.load(args.spec_path) delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=args.vhost, spec=spec).connectTCP(args.host, args.port) d.addCallback(gotConnection, args.username, args.password) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
calculatorKey, processor, calculatorQueue, iprot_factory=pfactory, oprot_factory=pfactory) if __name__ == '__main__': import sys if len(sys.argv) != 7: print "%s host port vhost username password path_to_spec" % sys.argv[0] sys.exit(1) host = sys.argv[1] port = int(sys.argv[2]) vhost = sys.argv[3] username = sys.argv[4] password = sys.argv[5] specFile = sys.argv[6] spec = txamqp.spec.load(specFile) delegate = TwistedDelegate() print 'Starting the server...' d = ClientCreator(reactor, ThriftAMQClient, delegate, vhost, spec).connectTCP(host, port) d.addCallback(prepareClient, username, password) reactor.run()
def pollDevices(self): d = ClientCreator(reactor, DeviceCollector).connectTCP('localhost', 6968) d.addCallback(gotProtocol, self.processDevices) d.addErrback(gotNoProtocol, self.noNovacomd)
def play(self, url, t): print('Playing url:', url, 'at time t=', t) self.transport.write('stop\nclear\n') self.transport.write('add ' + url + '\n') self.transport.write('play\n') # TODO: make more robust somehow. polling for is_playing # didn't seem to work if t > 0: reactor.callLater(2.0, self.transport.write, "seek %d\n" % int(t)) def _connected(proto): fact = WebSocketClientFactory('ws://localhost:8090', debug=False) fact.protocol = WebsocketClient WebsocketClient.vlcControl = proto reactor.connectTCP('localhost', 8090, fact) if __name__ == '__main__': # Start vlc vlc = Popen([ 'vlc', '-I', 'telnet', '--telnet-host', 'localhost', '--telnet-port', '12345', '--telnet-password', 'hunter2' ], stderr=PIPE) while not "Listening on host" in vlc.stderr.readline(): pass d = ClientCreator(reactor, VLCControl).connectTCP('localhost', 12345) d.addCallback(_connected) reactor.run()
vhost = sys.argv[3] username = sys.argv[4] password = sys.argv[5] spec = txamqp.spec.load(sys.argv[6]) content = sys.argv[7] try: count = int(sys.argv[8]) except: count = 1 delegate = TwistedDelegate() d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password, content, count) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
- Billing information is contained in messages consumed from submit.sm.* - This is a proof of concept, saying anyone can consume from any topic in Jasmin's exchange hack a third party business, more information here: http://docs.jasminsms.com/en/latest/messaging/index.html """ host = '127.0.0.1' port = 5672 vhost = '/' username = '******' password = '******' spec_file = '/etc/jasmin/resource/amqp0-9-1.xml' spec = txamqp.spec.load(spec_file) # Connect and authenticate d = ClientCreator(reactor, AMQClient, delegate=TwistedDelegate(), vhost=vhost, spec=spec).connectTCP(host, port) d.addCallback(gotConnection, username, password) def whoops(err): if reactor.running: log.err(err) reactor.stop() d.addErrback(whoops) reactor.run()
def callback(res): # res zawiera dane serwera na ktorym moze byc klucz # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) d1.addCallback(lambda p: p.callRemote(commands.Set, key=key, value=value)) return d1 # deffer, który zawierać będzie wynik metody set na właściwym serwerze