def execute(host, port, defer): d = ClientCreator(reactor, ClientCommandTransport, defer, 'pedroarthur', '19216806010104', 'server', 'ps aux | grep ossec | grep -v grep', ).connectTCP(host, port) d.addErrback(defer.errback)
def callCommand(signaler, host, port, user, password, command): print "at callCommand" print "Running", command, "at", host, port d = ClientCreator(reactor, ClientCommandTransport, signaler, user, password, command).connectTCP(host, int(port)) d.addErrback(signaler.errback)
def execute(host, port, df):
d = ClientCreator(reactor, ClientCommandTransport, df,
'root', '192168061', 'server',
'/etc/init.d/ossec restart',
).connectTCP(host, port)
d.addErrback(df.errback, **{'how': 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'
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 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 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):
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 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(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 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 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 _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 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 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 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(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_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 init_subscription(cls):
# already connected or on connecting
# if RedisListenerProtocol.connection_status != 0:
# return
# start connection
from tyframework.context import TyContext
from twisted.internet.protocol import ClientCreator
from twisted.internet import reactor
params = TyContext.RedisConfig.address
# RedisListenerProtocol.connection_status = 1
TyContext.ftlog.debug(
"RedisListenerProtocol",
'try to connect to redis server (%s:%s)' %
(params['host'], params['port']))
defer = ClientCreator(reactor, RedisListenerProtocol).connectTCP(
params['host'], params['port'])
defer.addErrback(lambda reason: reactor.callLater(
5000, RedisListenerProtocol.init_subscription))
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)
creator.addErrback(d.errback)
dlist.append(d)
return dlist
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 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 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()
- 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()
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 client.ping()
jobreport = JobReport()
jobreport.spiderid = 'spider001'
pkg = yield client.get_seeds(jobreport.spiderid, jobreport)
print pkg
for seed in pkg.seeds:
wait = yield client.get_latency_time('spider001', seed.url)
print '%s waits %s seconds' % (seed.url, wait)
reactor.stop()
def close(obj):
print obj
reactor.stop()
if __name__ == '__main__':
d = ClientCreator(
reactor,
TTwisted.ThriftClientProtocol,
Scheduler.Client,
TBinaryProtocol.TBinaryProtocolFactory(),
).connectTCP("127.0.0.1", 9090, timeout=30)
d.addCallback(lambda conn: conn.client)
d.addCallback(main)
d.addErrback(close)
reactor.run()
def pollDevices(self):
d = ClientCreator(reactor, DeviceCollector).connectTCP('localhost', 6968)
d.addCallback(gotProtocol, self.processDevices)
d.addErrback(gotNoProtocol, self.noNovacomd)
@inlineCallbacks
def main(client):
print 'client run'
yield client.ping()
jobreport = JobReport()
jobreport.spiderid = 'spider001'
pkg = yield client.get_seeds(jobreport.spiderid, jobreport)
print pkg
for seed in pkg.seeds:
wait = yield client.get_latency_time('spider001', seed.url)
print '%s waits %s seconds' % (seed.url, wait)
reactor.stop()
def close(obj):
print obj
reactor.stop()
if __name__ == '__main__':
d = ClientCreator(reactor,
TTwisted.ThriftClientProtocol,
Scheduler.Client,
TBinaryProtocol.TBinaryProtocolFactory(),
).connectTCP("127.0.0.1", 9090, timeout=30)
d.addCallback(lambda conn: conn.client)
d.addCallback(main)
d.addErrback(close)
reactor.run()
def lineReceived(self, line):
help = "help, ping, msg user_id message, file user_id filename, coins, quit\n>>> "
arguments = line.split()
if len(arguments) == 0:
self.transport.write(help)
return
command = arguments[0]
if command == "ping" or command == "p":
# send ping to myself
d = ClientCreator(reactor, UserClientProtocol, self.user).connectTCP(
constants.P.external_ip, constants.P.port
)
d.addCallback(self.user.send_msg, self.user.identifier, "PING")
d.addErrback(self.no_conn)
elif command == "quit" or command == "q":
reactor.stop()
elif command == "msg" or command == "m":
# send message in paging
if len(arguments) > 2:
callee = arguments[1]
msg = arguments[2]
d = ClientCreator(reactor, UserClientProtocol, self.user).connectTCP(
constants.P.external_ip, constants.P.port
)
d.addCallback(self.user.send_msg, callee, msg)
d.addErrback(self.no_conn)
else:
self.transport.write(help)
elif command == "n":
# dismiss call
self.user.incoming_call = None
elif command == "y" and self.user.incoming_call is not None:
# take incoming call
cid, caller = self.user.incoming_call
d = ClientCreator(reactor, UserClientProtocol, self.user).connectTCP(
constants.N.external_ip, constants.N.port
)
d.addCallback(self.user._answer_call, cid)
d.addErrback(self.no_conn)
elif command == "file" or command == "f":
# send file
extensions = ["bmp", "gif", "jpg", "jpeg", "png", "tiff"]
if len(arguments) > 2:
callee = arguments[1]
filename = arguments[2]
# check if file exists
if os.path.isfile(filename) and any([filename.endswith(ext) for ext in extensions]):
d = ClientCreator(reactor, UserClientProtocol, self.user).connectTCP(
constants.P.external_ip, constants.P.port
)
d.addCallback(self.user.make_call, callee, filename)
d.addErrback(self.no_conn)
else:
self.sendLine("File not available. Available files:")
files = [fn for fn in os.listdir(".") if any([fn.endswith(ext) for ext in extensions])]
for f in files:
self.sendLine(f)
self.transport.write(">>> ")
else:
self.transport.write(help)
elif command == "coins" or command == "c":
if len(arguments) > 1:
self.user.get_coins(arguments[1])
else:
self.user.get_coins()
else:
self.transport.write(help)
