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 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 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
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()
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
