def sendPacketData(self, data):
if self.verbose > 3:
self.message('sendPacketData ' + data)
factory = RestClientFactory(self.host, self.port, self.path, data, self.timeout)
reactor.connectTCP(self.host, self.port, factory)
self.sentTime = seconds()
return factory.deferred
def run(self):
log.msg("Running bot as %r" % self.name)
self.irc = BottuClientFactory(self)
self.join_passive_channel.ready()
reactor.connectTCP(self.network, self.port, self.irc)
reactor.run()
log.msg("Stopping bot")
def testWriter(self):
f = protocol.Factory()
f.protocol = LargeBufferWriterProtocol
f.done = 0
f.problem = 0
f.len = self.datalen
p = reactor.listenTCP(0, f, interface="127.0.0.1")
n = p.getHost().port
self.ports.append(p)
clientF = LargeBufferReaderClientFactory()
reactor.connectTCP("127.0.0.1", n, clientF)
while 1:
rxlen = clientF.len
try:
spinUntil(lambda :f.done and clientF.done, timeout=30)
except defer.TimeoutError:
if clientF.len == rxlen:
raise
# if we're still making progress, keep trying
continue
break
self.failUnless(f.done, "writer didn't finish, it probably died")
self.failUnless(clientF.len == self.datalen,
"client didn't receive all the data it expected "
"(%d != %d)" % (clientF.len, self.datalen))
self.failUnless(clientF.done, "client didn't see connection dropped")
def connect(self, host, port, username=None, password=None, retry=False):
if retry:
# Launch a client
self.pbClientFactory = ReconnectingPBClientFactory()
self.pbClientFactory.gotPerspective = self._connected
self.pbClientFactory.disconnected = self._disconnected
# Start login
if username is None and password is None:
self.pbClientFactory.startLogin(
Anonymous())
else:
self.pbClientFactory.startLogin(
UsernamePassword(
username,
password))
reactor.connectTCP(host, port, self.pbClientFactory)
else:
# Launch a client
self.pbClientFactory = pb.PBClientFactory()
reactor.connectTCP(host, port, self.pbClientFactory)
yield self.pbClientFactory.getRootObject()
if username is None and password is None:
yield self.pbClientFactory.login(
Anonymous()).addCallback(self._connected)
else:
yield self.pbClientFactory.login(
UsernamePassword(
username,
password)).addCallback(self._connected)
def render_POST(self, request):
text = request.args.get("feedback")
if text is None:
raise FeedbackException("No text.")
if len(text) > 50000:
raise FeedbackException("Too much text.")
text = text[0]
# basic checksum to stop really lame kiddies spamming, see feedback.js for js version
checksum = 0;
text = text.decode("utf-8", "ignore")
for x in text:
checksum = ((checksum + 1) % 256) ^ (ord(x) % 256);
sentchecksum = int(request.args.get("c", [0])[0])
if checksum != sentchecksum:
raise FeedbackException("Bad checksum: %d vs. %d" % (sentchecksum, checksum))
msg = MIMEText(text.encode("utf-8"), _charset="utf-8")
msg["Subject"] = "qwebirc feedback from %s" % request.getclientIP()
msg["From"] = config.feedbackengine["from"]
msg["To"] = config.feedbackengine["to"]
email = StringIO(msg.as_string())
email.seek(0, 0)
factorytype = SMTPSenderFactory
factory = factorytype(fromEmail=config.feedbackengine["from"], toEmail=config.feedbackengine["to"], file=email, deferred=defer.Deferred())
reactor.connectTCP(config.feedbackengine["smtp_host"], config.feedbackengine["smtp_port"], factory)
self.__hit()
return "1"
def startWorker(self):
log.msg("Starting the SmppTransport with %s" % self.config)
# TODO: move this to a config file
dbindex = get_deploy_int(self._amqp_client.vhost)
self.smpp_offset = int(self.config['smpp_offset'])
self.transport_name = self.config.get('TRANSPORT_NAME', 'fallback')
# Connect to Redis
self.r_server = redis.Redis("localhost", db=dbindex)
self.r_prefix = "%(system_id)s@%(host)s:%(port)s" % self.config
log.msg("Connected to Redis, prefix: %s" % self.r_prefix)
last_sequence_number = int(self.r_get_last_sequence()
or self.smpp_offset)
log.msg("Last sequence_number: %s" % last_sequence_number)
# start the Smpp transport
factory = EsmeTransceiverFactory(self.config,
self._amqp_client.vumi_options)
factory.loadDefaults(self.config)
factory.setLastSequenceNumber(last_sequence_number)
factory.setConnectCallback(self.esme_connected)
factory.setDisconnectCallback(self.esme_disconnected)
factory.setSubmitSMRespCallback(self.submit_sm_resp)
factory.setDeliveryReportCallback(self.delivery_report)
factory.setDeliverSMCallback(self.deliver_sm)
factory.setSendFailureCallback(self.send_failure)
log.msg(factory.defaults)
reactor.connectTCP(
factory.defaults['host'],
factory.defaults['port'],
factory)
def testConnectByServiceFail(self):
try:
reactor.connectTCP("127.0.0.1", "thisbetternotexist",
MyClientFactory())
except error.ServiceNameUnknownError:
return
self.assert_(False, "connectTCP didn't raise ServiceNameUnknownError")
def testWriter(self):
f = protocol.Factory()
f.protocol = WriterProtocol
f.done = 0
f.problem = 0
wrappedF = WiredFactory(f)
p = reactor.listenTCP(0, wrappedF, interface="127.0.0.1")
n = p.getHost().port
self.ports.append(p)
clientF = WriterClientFactory()
wrappedClientF = WiredFactory(clientF)
reactor.connectTCP("127.0.0.1", n, wrappedClientF)
def check(ignored):
self.failUnless(f.done, "writer didn't finish, it probably died")
self.failUnless(f.problem == 0, "writer indicated an error")
self.failUnless(clientF.done,
"client didn't see connection dropped")
expected = "".join(["Hello Cleveland!\n",
"Goodbye", " cruel", " world", "\n"])
self.failUnless(clientF.data == expected,
"client didn't receive all the data it expected")
d = defer.gatherResults([wrappedF.onDisconnect,
wrappedClientF.onDisconnect])
return d.addCallback(check)
def _runTest(self, clientProto, serverProto, clientIsServer=False):
self.clientProto = clientProto
cf = self.clientFactory = protocol.ClientFactory()
cf.protocol = lambda: clientProto
if clientIsServer:
cf.server = 0
else:
cf.client = 1
self.serverProto = serverProto
sf = self.serverFactory = protocol.ServerFactory()
sf.protocol = lambda: serverProto
if clientIsServer:
sf.client = 0
else:
sf.server = 1
if clientIsServer:
inCharge = cf
else:
inCharge = sf
inCharge.done = 0
port = self.port = reactor.listenTCP(0, sf, interface="127.0.0.1")
portNo = port.getHost().port
reactor.connectTCP('127.0.0.1', portNo, cf)
i = 0
while i < 1000 and not inCharge.done:
reactor.iterate(0.01)
i += 1
self.failUnless(
inCharge.done,
"Never finished reading all lines: %s" % (inCharge.lines,))
def start(host='localhost', port=61613, username='******', password='******'):
"""Start twisted event loop and the fun should begin...
"""
StompClientFactory.username = username
StompClientFactory.password = password
reactor.connectTCP(host, port, StompClientFactory())
reactor.run()
def main():
config = hamper.config.load()
hamper.log.setup_logging()
reactor.connectTCP(config['server'], config['port'],
CommanderFactory(config))
reactor.run()
def test_multiprocessing_factory(self):
# Wrap the TestFactory.
mp_factory = ScaleFactory(TestFactory(), core=2)
# launch the new multiprocessing factory
port = reactor.listenTCP(8118, mp_factory)
# connect twice to the new server and check that
# instances server run into different process'
client_factory = TestClientFactory()
client_factory.client_deferred_list = [Deferred(), Deferred()]
#time.sleep(1)
cl1 = reactor.connectTCP('localhost', 8118, client_factory)
cl2 = reactor.connectTCP('localhost', 8118, client_factory)
result = gatherResults(client_factory.client_deferred_list)
def check_result(r_list):
self.assertEqual(len(r_list), 2, "Both client should have been called. ({0})".format(repr(r_list)))
self.assertTrue(r_list[0][0] != r_list[1][0], """pid returned from the first client should be different from
the one returned by the second client""")
self.assertTrue(r_list[0][1] == b'0')
self.assertTrue(r_list[1][1] == b'1')
result.addCallback(check_result)
self.addCleanup(self._clean_reactor, [port], [cl1, cl2])
return result
def connect_to_pot(self, returned_conn_details):
if returned_conn_details:
if returned_conn_details['success']:
self.sensor_name = returned_conn_details['sensor_name']
self.honey_ip = returned_conn_details['honey_ip']
self.honey_port = returned_conn_details['honey_port']
self.username = returned_conn_details['username']
self.password = returned_conn_details['password']
self.auth_packets = [[5, self.to_string('ssh-userauth')], [50, self.to_string(self.username) + self.to_string('ssh-connection') + self.to_string('none')]]
if self.sensor_name == self.server.sensor_name and self.honey_ip == self.server.honey_ip and self.honey_port == self.server.honey_port:
log.msg(log.LGREEN, '[POST_AUTH]', 'Details the same as pre-auth, not re-directing')
self.dont_post_auth()
else:
self.server.client.loseConnection()
self.server.clientConnected = False
if not self.server.disconnected:
log.msg(log.LGREEN, '[POST_AUTH]', 'Connecting to Honeypot: %s (%s:%s)' % (self.sensor_name, self.honey_ip, self.honey_port))
client_factory = client.HonsshClientFactory()
client_factory.server = self.server
self.bind_ip = self.server.net.setupNetworking(self.server.peer_ip, self.honey_ip, self.honey_port)
self.networkingSetup = True
reactor.connectTCP(self.honey_ip, self.honey_port, client_factory, bindAddress=(self.bind_ip, self.server.peer_port+1), timeout=10)
pot_connect_defer = threads.deferToThread(self.is_pot_connected)
pot_connect_defer.addCallback(self.pot_connected)
else:
log.msg(log.LBLUE, '[POST_AUTH]', 'SUCCESS = FALSE, NOT POST-AUTHING')
self.dont_post_auth()
else:
log.msg(log.LRED, '[POST_AUTH][ERROR]', 'PLUGIN ERROR - DISCONNECTING ATTACKER')
self.server.loseConnection()
def sendmail(self, s, recipients):
result = defer.Deferred()
if have_ssl and self.useTls:
client_factory = ssl.ClientContextFactory()
client_factory.method = SSLv3_METHOD
else:
client_factory = None
if self.smtpUser and self.smtpPassword:
useAuth = True
else:
useAuth = False
if not ESMTPSenderFactory:
raise RuntimeError("twisted-mail is not installed - cannot " "send mail")
sender_factory = ESMTPSenderFactory(
self.smtpUser,
self.smtpPassword,
self.fromaddr,
recipients,
StringIO(s),
result,
contextFactory=client_factory,
requireTransportSecurity=self.useTls,
requireAuthentication=useAuth,
)
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def processAT(self, data):
try:
timediff = data[1]
server = data[2]
clientID = data[3]
location = data[4]
time_stamp = data[5]
#check if data exists and is the same
if self.database.has_key(clientID):
if time_stamp == self.database[clientID]['time_in']:
if location == self.database[clientID]['loc_']:
return
#update because data is not the same
outmsg = 'AT ' + timediff + ' ' + server + ' ' + clientID + ' ' + location + ' ' + time_stamp + '\n'
lat, long = self._getLatLong(location)
client_dict = {'Server_ID': server, 'time_in': time_stamp, 'loc_': location ,'at_msg': outmsg, '_lat': lat, '_long': long}
self.database[clientID] = client_dict
#send to other servers
self._received = outmsg
factory = protocol.ClientFactory()
factory.protocol = ClientProtocol
factory.originator = self
reactor.connectTCP('localhost', 12781, factory)
except IndexError:
outmsg = "?" + " " + data[0] + "\n"
#self.transport.write(outmsg)
logging.info("Command unrecognized. OUTPUT MSG: " +outmsg)
def render(self, request):
"""Render this request, from my server.
This will always be asynchronous, and therefore return NOT_DONE_YET.
It spins off a request to the pb client, and either adds it to the list
of pending issues or requests it immediately, depending on if the
client is already connected.
"""
if not self.publisher:
self.pending.append(request)
if not self.waiting:
self.waiting = 1
bf = pb.PBClientFactory()
timeout = 10
if self.host == "unix":
reactor.connectUNIX(self.port, bf, timeout)
else:
reactor.connectTCP(self.host, self.port, bf, timeout)
d = bf.getRootObject()
d.addCallbacks(self.connected, self.notConnected)
else:
i = Issue(request)
self.publisher.callRemote('request', request).addCallbacks(i.finished, i.failed)
return server.NOT_DONE_YET
def main():
#64bit machine builds innomitor and bitblinder
# reactor.connectTCP('192.168.1.121', 12900, SSHFactory(LinuxInnomitorBuild()))
reactor.connectTCP('192.168.1.121', 12900, SSHFactory(LinuxBitBlinderBuild(Globals.VERSION)))
#32bit machine just builds innomitor
# reactor.connectTCP('192.168.1.121', 13200, SSHFactory(LinuxInnomitorBuild()))
reactor.run()
def make_session(pint, attrs, session_type='BOSH'):
"""
pint - punjab session interface class
attrs - attributes sent from the body tag
"""
s = Session(pint, attrs)
if pint.v:
log.msg('================================== %s connect to %s:%s ==================================' % (str(time.time()),s.hostname,s.port))
connect_srv = s.connect_srv
if attrs.has_key('route'):
connect_srv = False
if s.hostname in ['localhost', '127.0.0.1']:
connect_srv = False
if not connect_srv:
reactor.connectTCP(s.hostname, s.port, s, bindAddress=pint.bindAddress)
else:
connector = XMPPClientConnector(reactor, s.hostname, s)
connector.connect()
# timeout
reactor.callLater(s.inactivity, s.checkExpired)
pint.sessions[s.sid] = s
return s, s.waiting_requests[0].deferred
def main():
# command line processing
process_commandline()
call_list_server = None
# run the call list providing web server in listening mode
if CONFIG["LISTEN"]:
call_list_server = CallListServer()
site = http_server.Site(call_list_server)
try:
reactor.listenTCP(CONFIG["HTTP_PORT"], site, interface=CONFIG["HTTP_HOST"])
except:
# port could not be bound
# (already in use, permission denied, ...)
call_list_server = None
else:
dprint("running call list web server on 'http://{HTTP_HOST}:{HTTP_PORT}'".format(**CONFIG))
# configure notifications
enable_notifcations(
not CONFIG["DISABLE_NOTIFICATIONS"],
# 'All recent calls...' link only when the call list webserver
# is running
call_list_server,
)
# start the client
reactor.connectTCP(
CONFIG["NCID_HOST"], CONFIG["NCID_PORT"], NCIDClientFactory(reactor, CONFIG["LISTEN"], call_list_server)
)
# run the event dispatcher
reactor.run()
dprint("done.")
def handleStatus_301(self):
l = self.headers.get('location')
if not l:
self.handleStatusDefault()
return
url = l[0]
if self.followRedirect:
scheme, host, port, path = \
_parse(url, defaultPort=self.transport.getPeer().port)
self.factory.setURL(url)
if self.factory.scheme == 'https':
from twisted.internet import ssl
contextFactory = ssl.ClientContextFactory()
reactor.connectSSL(self.factory.host, self.factory.port,
self.factory, contextFactory)
else:
reactor.connectTCP(self.factory.host, self.factory.port,
self.factory)
else:
self.handleStatusDefault()
self.factory.noPage(
failure.Failure(
error.PageRedirect(
self.status, self.message, location = url)))
self.quietLoss = 1
self.transport.loseConnection()
def main():
from optparse import OptionParser
parser = OptionParser(usage="usage: %prog [options] channels")
# IRC connection options
parser.add_option("-s", "--server",
action="store", dest="server",
default="irc.freenode.net",
help="IRC server to connect to")
parser.add_option("-p", "--port",
action="store", type="int", dest="port", default=None,
help="IRC server to connect to")
parser.add_option("--ssl",
action="store_true", dest="ssl", default=False,
help="use SSL")
parser.add_option("--password",
action="store", dest="password", default=None,
help="server password")
parser.add_option("-n", "--nick",
action="store", dest="nick", default="karmabot",
help="nickname to use")
# Bot options
parser.add_option("-v", "--verbose",
action="store_true", dest="verbose", default=False,
help="enable verbose output")
parser.add_option("-d", "--data",
action="store", dest="filename", default="karma.json",
help="karma data file name")
parser.add_option("-t", "--trust",
action="append", dest="trusted", default=[],
help="trusted hostmasks")
parser.add_option("-f", "--facets",
action="append", dest="facets", default=[],
help="additional facets to load")
(options, channels) = parser.parse_args()
if not channels:
parser.error("You must supply some channels to join.")
else:
log.msg("Channels to join: %s" % channels)
if options.verbose:
log.startLogging(sys.stdout)
if not options.port:
options.port = 6667 if not options.ssl else 9999
# FIXME: this needs to be replaced with a real facet manager
for facet_path in options.facets:
execfile(facet_path, globals())
factory = KarmaBotFactory(options.filename, options.nick,
channels, options.trusted, options.password)
if not options.ssl:
reactor.connectTCP(options.server, options.port, factory)
else:
reactor.connectSSL(options.server, options.port,
factory, ssl.ClientContextFactory())
reactor.run()
def start(self):
f = pb.PBClientFactory()
d = f.login(credentials.UsernamePassword('local1', 'localpw'), self)
reactor.connectTCP('127.0.0.1', self.port, f)
# we need to hold a reference to this, otherwise the broker will sever
# the connection
self.mind = yield d
def connect(self):
factory = RedisClientFactory(password=self.password, db=self.db, use_hiredis=self.use_hiredis)
reactor.connectTCP(self.host, self.port, factory)
self.redis_conn, new_defer = yield factory.deferred
logging.debug("self.redis_conn is %s" % str(self.redis_conn))
setattr(self.factory, self.factory_attr, self.redis_conn)
new_defer.addCallback(self.reconnect_callback)
def deliverJob(self):
# returns a Deferred that fires when the job has been delivered
if self.connect == "ssh":
tryhost = self.getopt("tryhost")
tryuser = self.getopt("username")
trydir = self.getopt("trydir")
argv = ["ssh", "-l", tryuser, tryhost, "buildbot", "tryserver", "--jobdir", trydir]
# now run this command and feed the contents of 'job' into stdin
pp = RemoteTryPP(self.jobfile)
reactor.spawnProcess(pp, argv[0], argv, os.environ)
d = pp.d
return d
if self.connect == "pb":
user = self.getopt("username")
passwd = self.getopt("passwd")
master = self.getopt("master")
tryhost, tryport = master.split(":")
tryport = int(tryport)
f = pb.PBClientFactory()
d = f.login(credentials.UsernamePassword(user, passwd))
reactor.connectTCP(tryhost, tryport, f)
d.addCallback(self._deliverJob_pb)
return d
raise RuntimeError("unknown connecttype '%s', should be 'ssh' or 'pb'" % self.connect)
def getStatus(self):
# returns a Deferred that fires when the builds have finished, and
# may emit status messages while we wait
wait = bool(self.getopt("wait", "try_wait"))
if not wait:
# TODO: emit the URL where they can follow the builds. This
# requires contacting the Status server over PB and doing
# getURLForThing() on the BuildSetStatus. To get URLs for
# individual builds would require we wait for the builds to
# start.
print "not waiting for builds to finish"
return
d = self.running = defer.Deferred()
if self.buildsetStatus:
self._getStatus_1()
return self.running
# contact the status port
# we're probably using the ssh style
master = self.getopt("master")
host, port = master.split(":")
port = int(port)
self.announce("contacting the status port at %s:%d" % (host, port))
f = pb.PBClientFactory()
creds = credentials.UsernamePassword("statusClient", "clientpw")
d = f.login(creds)
reactor.connectTCP(host, port, f)
d.addCallback(self._getStatus_ssh_1)
return self.running
def addRequest(self, uri, file,exitfunc):
self.exitfunc=exitfunc
if len(self.deferreds) >= self.SIZE:
# wait for completion of all previous requests
DeferredList(self.deferreds
).addCallback(self._callback)
self.deferreds = []
# queue the request
deferred = Deferred()
self.requests.append((uri, file,deferred))
return deferred
else:
# execute the request now
#deferred = downloadPage(url, file)
host, port, url = MyUtils.parse(uri)
f = client.HTTPDownloader(uri, file)
f.deferred.addCallbacks(callback=self.exitfunc,
callbackArgs=(file,) )
self.deferreds.append(f.deferred)
reactor.connectTCP(host, port, f)
return f.deferred
def testWriteLimit(self):
server = Server()
c1, c2 = SimpleProtocol(), SimpleProtocol()
# The throttling factory starts checking bandwidth immediately
now = time.time()
tServer = policies.ThrottlingFactory(server, writeLimit=10)
port = reactor.listenTCP(0, tServer, interface="127.0.0.1")
n = port.getHost()[2]
reactor.iterate(); reactor.iterate()
for c in c1, c2:
reactor.connectTCP("127.0.0.1", n, SillyFactory(c))
self.doIterations()
for p in tServer.protocols.keys():
p = p.wrappedProtocol
self.assert_(isinstance(p, EchoProtocol))
p.transport.registerProducer(p, 1)
c1.transport.write("0123456789")
c2.transport.write("abcdefghij")
self.doIterations()
self.assertEquals(c1.buffer, "0123456789")
self.assertEquals(c2.buffer, "abcdefghij")
self.assertEquals(tServer.writtenThisSecond, 20)
# at this point server should've written 20 bytes, 10 bytes
# above the limit so writing should be paused around 1 second
# from 'now', and resumed a second after that
for p in tServer.protocols.keys():
self.assert_(not hasattr(p.wrappedProtocol, "paused"))
self.assert_(not hasattr(p.wrappedProtocol, "resume"))
while not hasattr(p.wrappedProtocol, "paused"):
reactor.iterate()
self.assertEquals(tServer.writtenThisSecond, 0)
for p in tServer.protocols.keys():
self.assert_(hasattr(p.wrappedProtocol, "paused"))
self.assert_(not hasattr(p.wrappedProtocol, "resume"))
self.assert_(abs(p.wrappedProtocol.paused - now - 1.0) < 0.1)
while not hasattr(p.wrappedProtocol, "resume"):
reactor.iterate()
for p in tServer.protocols.keys():
self.assert_(hasattr(p.wrappedProtocol, "resume"))
self.assert_(abs(p.wrappedProtocol.resume -
p.wrappedProtocol.paused - 1.0) < 0.1)
c1.transport.loseConnection()
c2.transport.loseConnection()
port.stopListening()
for p in tServer.protocols.keys():
p.loseConnection()
self.doIterations()
def received_broadcast(self, data):
print "Received feed."
message = Message(data)
row = db.select_entries("contacts", {"label": message.label})
if len(row) == 0:
print "Can't find this label: " + message.label
return
row = row[0]
message.decrypt(row["sharedkey"])
if not message.validate():
print "Received an invalid message."
return
print "Found label: " + message.label
if self.factory.role == "hidden-client":
if self.factory.listener_factory:
self.factory.listener_factory.send_message(message.cleartext_msg)
self.factory.listener_factory.client.transport.loseConnection()
db.insert_entry("contacts", {"name": self.factory.name, "label":message.new_label, "sharedkey": row["sharedkey"]})
else:
if self.factory.role == "proxy":
message.cleartext_msg = re.sub(r'CONNECT (?P<value>.*?) HTTP/1.0\r\n', 'CONNECT localhost HTTP/1.0\r\n', message.cleartext_msg)
socks_client_factory = HTTPClientFactory(reactor, message)
socks_client_factory.set_communicator(self)
reactor.connectTCP("localhost", 4333, socks_client_factory)
db.insert_entry("contacts", {"name": self.factory.name, "label":message.new_label, "sharedkey": row["sharedkey"]})
def is_already_running(self):
"""Check if the instance is already running."""
factory = PortDetectFactory()
# pylint: disable=E1101
reactor.connectTCP(LOCALHOST, self.config.port, factory)
result = yield factory.is_listening()
defer.returnValue(result)
def _makeDeferredRequest(url, contextFactory=None, proxy=None,
progress_tracker=None,
clientFactoryClass=None,
*args, **kwargs):
"""Download a web page as a string.
Download a page. Return a deferred, which will callback with a
page (as a string) or errback with a description of the error.
See HTTPClientFactory to see what extra args can be passed.
"""
if proxy:
scheme, host, port, path = _parse(proxy)
kwargs['proxy'] = proxy
else:
scheme, host, port, path = _parse(url)
if not clientFactoryClass:
clientFactoryClass = HTTPClientFactory
factory = clientFactoryClass(url, *args, **kwargs)
if progress_tracker is not None and hasattr(factory, 'set_progress_tracker'):
factory.set_progress_tracker(progress_tracker)
if scheme == 'https':
from twisted.internet import ssl
if contextFactory is None:
contextFactory = ssl.ClientContextFactory()
reactor.connectSSL(host, port, factory, contextFactory)
else:
reactor.connectTCP(host, port, factory)
return factory.deferred
def main(args, net, datadir_path, merged_urls, worker_endpoint):
try:
print 'p2pool (version %s)' % (p2pool.__version__, )
print
@defer.inlineCallbacks
def connect_p2p():
# connect to bitcoind over bitcoin-p2p
print '''Testing bitcoind P2P connection to '%s:%s'...''' % (
args.bitcoind_address, args.bitcoind_p2p_port)
factory = bitcoin_p2p.ClientFactory(net.PARENT)
reactor.connectTCP(args.bitcoind_address, args.bitcoind_p2p_port,
factory)
yield factory.getProtocol() # waits until handshake is successful
print ' ...success!'
print
defer.returnValue(factory)
if args.testnet: # establish p2p connection first if testnet so bitcoind can work without connections
factory = yield connect_p2p()
# connect to bitcoind over JSON-RPC and do initial getmemorypool
url = '%s://%s:%i/' % ('https' if args.bitcoind_rpc_ssl else 'http',
args.bitcoind_address, args.bitcoind_rpc_port)
print '''Testing bitcoind RPC connection to '%s' with username '%s'...''' % (
url, args.bitcoind_rpc_username)
bitcoind = jsonrpc.Proxy(
url,
dict(Authorization='Basic ' +
base64.b64encode(args.bitcoind_rpc_username + ':' +
args.bitcoind_rpc_password)),
timeout=30)
yield helper.check(bitcoind, net)
temp_work = yield helper.getwork(bitcoind)
bitcoind_warning_var = variable.Variable(None)
@defer.inlineCallbacks
def poll_warnings():
errors = (yield
deferral.retry('Error while calling getmininginfo:')(
bitcoind.rpc_getmininginfo)())['errors']
bitcoind_warning_var.set(errors if errors != '' else None)
yield poll_warnings()
task.LoopingCall(poll_warnings).start(20 * 60)
print ' ...success!'
print ' Current block hash: %x' % (temp_work['previous_block'], )
print ' Current block height: %i' % (temp_work['height'] - 1, )
print
if not args.testnet:
factory = yield connect_p2p()
print 'Determining payout address...'
if args.pubkey_hash is None:
address_path = os.path.join(datadir_path, 'cached_payout_address')
if os.path.exists(address_path):
with open(address_path, 'rb') as f:
address = f.read().strip('\r\n')
print ' Loaded cached address: %s...' % (address, )
else:
address = None
if address is not None:
res = yield deferral.retry(
'Error validating cached address:',
5)(lambda: bitcoind.rpc_validateaddress(address))()
if not res['isvalid'] or not res['ismine']:
print ' Cached address is either invalid or not controlled by local bitcoind!'
address = None
if address is None:
print ' Getting payout address from bitcoind...'
address = yield deferral.retry(
'Error getting payout address from bitcoind:',
5)(lambda: bitcoind.rpc_getaccountaddress('p2pool'))()
with open(address_path, 'wb') as f:
f.write(address)
my_pubkey_hash = bitcoin_data.address_to_pubkey_hash(
address, net.PARENT)
else:
my_pubkey_hash = args.pubkey_hash
print ' ...success! Payout address:', bitcoin_data.pubkey_hash_to_address(
my_pubkey_hash, net.PARENT)
print
ss = p2pool_data.ShareStore(os.path.join(datadir_path, 'shares.'), net)
shares = {}
known_verified = set()
print "Loading shares..."
for i, (mode, contents) in enumerate(ss.get_shares()):
if mode == 'share':
contents.time_seen = 0
shares[contents.hash] = contents
if len(shares) % 1000 == 0 and shares:
print " %i" % (len(shares), )
elif mode == 'verified_hash':
known_verified.add(contents)
else:
raise AssertionError()
print " ...done loading %i shares (%i verified)!" % (
len(shares), len(known_verified))
print
print 'Initializing work...'
node = p2pool_node.Node(factory, bitcoind, shares.values(),
known_verified, net)
yield node.start()
for share_hash in shares:
if share_hash not in node.tracker.items:
ss.forget_share(share_hash)
for share_hash in known_verified:
if share_hash not in node.tracker.verified.items:
ss.forget_verified_share(share_hash)
del shares, known_verified
node.tracker.removed.watch(lambda share: ss.forget_share(share.hash))
node.tracker.verified.removed.watch(
lambda share: ss.forget_verified_share(share.hash))
def save_shares():
for share in node.tracker.get_chain(
node.best_share_var.value,
min(node.tracker.get_height(node.best_share_var.value),
2 * net.CHAIN_LENGTH)):
ss.add_share(share)
if share.hash in node.tracker.verified.items:
ss.add_verified_hash(share.hash)
task.LoopingCall(save_shares).start(60)
print ' ...success!'
print
print 'Joining p2pool network using port %i...' % (args.p2pool_port, )
@defer.inlineCallbacks
def parse(x):
if ':' in x:
ip, port = x.split(':')
defer.returnValue(((yield reactor.resolve(ip)), int(port)))
else:
defer.returnValue(((yield reactor.resolve(x)), net.P2P_PORT))
addrs = {}
if os.path.exists(os.path.join(datadir_path, 'addrs')):
try:
with open(os.path.join(datadir_path, 'addrs'), 'rb') as f:
addrs.update(
dict((tuple(k), v) for k, v in json.loads(f.read())))
except:
print >> sys.stderr, 'error parsing addrs'
for addr_df in map(parse, net.BOOTSTRAP_ADDRS):
try:
addr = yield addr_df
if addr not in addrs:
addrs[addr] = (0, time.time(), time.time())
except:
log.err()
connect_addrs = set()
for addr_df in map(parse, args.p2pool_nodes):
try:
connect_addrs.add((yield addr_df))
except:
log.err()
node.p2p_node = p2pool_node.P2PNode(
node,
port=args.p2pool_port,
max_incoming_conns=args.p2pool_conns,
addr_store=addrs,
connect_addrs=connect_addrs,
desired_outgoing_conns=args.p2pool_outgoing_conns,
)
node.p2p_node.start()
def save_addrs():
with open(os.path.join(datadir_path, 'addrs'), 'wb') as f:
f.write(json.dumps(node.p2p_node.addr_store.items()))
task.LoopingCall(save_addrs).start(60)
print ' ...success!'
print
if args.upnp:
@defer.inlineCallbacks
def upnp_thread():
while True:
try:
is_lan, lan_ip = yield ipdiscover.get_local_ip()
if is_lan:
pm = yield portmapper.get_port_mapper()
yield pm._upnp.add_port_mapping(
lan_ip, args.p2pool_port, args.p2pool_port,
'p2pool', 'TCP')
except defer.TimeoutError:
pass
except:
if p2pool.DEBUG:
log.err(None, 'UPnP error:')
yield deferral.sleep(random.expovariate(1 / 120))
upnp_thread()
# start listening for workers with a JSON-RPC server
print 'Listening for workers on %r port %i...' % (worker_endpoint[0],
worker_endpoint[1])
wb = work.WorkerBridge(node, my_pubkey_hash, args.donation_percentage,
merged_urls, args.worker_fee)
web_root = web.get_web_root(wb, datadir_path, bitcoind_warning_var)
worker_interface.WorkerInterface(wb).attach_to(
web_root, get_handler=lambda request: request.redirect('/static/'))
deferral.retry('Error binding to worker port:', traceback=False)(
reactor.listenTCP)(worker_endpoint[1],
server.Site(web_root),
interface=worker_endpoint[0])
with open(os.path.join(os.path.join(datadir_path, 'ready_flag')),
'wb') as f:
pass
print ' ...success!'
print
# done!
print 'Started successfully!'
print 'Go to http://127.0.0.1:%i/ to view graphs and statistics!' % (
worker_endpoint[1], )
if args.donation_percentage > 0.51:
print '''Donating %.1f%% of work towards P2Pool's development. Thanks for the tip!''' % (
args.donation_percentage, )
elif args.donation_percentage < 0.49:
print '''Donating %.1f%% of work towards P2Pool's development. Please donate to encourage further development of P2Pool!''' % (
args.donation_percentage, )
else:
print '''Donating %.1f%% of work towards P2Pool's development. Thank you!''' % (
args.donation_percentage, )
print 'You can increase this amount with --give-author argument! (or decrease it, if you must)'
print
if hasattr(signal, 'SIGALRM'):
signal.signal(
signal.SIGALRM, lambda signum, frame: reactor.callFromThread(
sys.stderr.write, 'Watchdog timer went off at:\n' + ''.
join(traceback.format_stack())))
signal.siginterrupt(signal.SIGALRM, False)
task.LoopingCall(signal.alarm, 30).start(1)
if args.irc_announce:
from twisted.words.protocols import irc
class IRCClient(irc.IRCClient):
nickname = 'p2pool%02i' % (random.randrange(100), )
channel = net.ANNOUNCE_CHANNEL
def lineReceived(self, line):
if p2pool.DEBUG:
print repr(line)
irc.IRCClient.lineReceived(self, line)
def signedOn(self):
self.in_channel = False
irc.IRCClient.signedOn(self)
self.factory.resetDelay()
self.join(self.channel)
@defer.inlineCallbacks
def new_share(share):
if not self.in_channel:
return
if share.pow_hash <= share.header[
'bits'].target and abs(share.timestamp -
time.time()) < 10 * 60:
yield deferral.sleep(random.expovariate(1 / 60))
message = '\x02%s BLOCK FOUND by %s! %s%064x' % (
net.NAME.upper(),
bitcoin_data.script2_to_address(
share.new_script, net.PARENT),
net.PARENT.BLOCK_EXPLORER_URL_PREFIX,
share.header_hash)
if all('%x' %
(share.header_hash, ) not in old_message
for old_message in self.recent_messages):
self.say(self.channel, message)
self._remember_message(message)
self.watch_id = node.tracker.verified.added.watch(
new_share)
self.recent_messages = []
def joined(self, channel):
self.in_channel = True
def left(self, channel):
self.in_channel = False
def _remember_message(self, message):
self.recent_messages.append(message)
while len(self.recent_messages) > 100:
self.recent_messages.pop(0)
def privmsg(self, user, channel, message):
if channel == self.channel:
self._remember_message(message)
def connectionLost(self, reason):
node.tracker.verified.added.unwatch(self.watch_id)
print 'IRC connection lost:', reason.getErrorMessage()
class IRCClientFactory(protocol.ReconnectingClientFactory):
protocol = IRCClient
reactor.connectTCP("irc.freenode.net", 6667, IRCClientFactory())
@defer.inlineCallbacks
def status_thread():
last_str = None
last_time = 0
while True:
yield deferral.sleep(3)
try:
height = node.tracker.get_height(node.best_share_var.value)
this_str = 'P2Pool: %i shares in chain (%i verified/%i total) Peers: %i (%i incoming)' % (
height,
len(node.tracker.verified.items),
len(node.tracker.items),
len(node.p2p_node.peers),
sum(1 for peer in node.p2p_node.peers.itervalues()
if peer.incoming),
) + (' FDs: %i R/%i W' %
(len(reactor.getReaders()), len(reactor.getWriters()))
if p2pool.DEBUG else '')
datums, dt = wb.local_rate_monitor.get_datums_in_last()
my_att_s = sum(datum['work'] / dt for datum in datums)
this_str += '\n Local: %sH/s in last %s Local dead on arrival: %s Expected time to share: %s' % (
math.format(int(my_att_s)),
math.format_dt(dt),
math.format_binomial_conf(
sum(1 for datum in datums if datum['dead']),
len(datums), 0.95),
math.format_dt(2**256 / node.tracker.items[
node.best_share_var.value].max_target / my_att_s)
if my_att_s and node.best_share_var.value else '???',
)
if height > 2:
(stale_orphan_shares,
stale_doa_shares), shares, _ = wb.get_stale_counts()
stale_prop = p2pool_data.get_average_stale_prop(
node.tracker, node.best_share_var.value,
min(60 * 60 // net.SHARE_PERIOD, height))
real_att_s = p2pool_data.get_pool_attempts_per_second(
node.tracker, node.best_share_var.value,
min(height - 1, 60 * 60 //
net.SHARE_PERIOD)) / (1 - stale_prop)
this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %.4f %s' % (
shares,
stale_orphan_shares,
stale_doa_shares,
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95),
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95, lambda x: (1 - x) / (1 - stale_prop)),
node.get_current_txouts().get(
bitcoin_data.pubkey_hash_to_script2(
my_pubkey_hash), 0) * 1e-8,
net.PARENT.SYMBOL,
)
this_str += '\n Pool: %sH/s Stale rate: %.1f%% Expected time to block: %s' % (
math.format(int(real_att_s)),
100 * stale_prop,
math.format_dt(
2**256 /
node.bitcoind_work.value['bits'].target /
real_att_s),
)
for warning in p2pool_data.get_warnings(
node.tracker, node.best_share_var.value, net,
bitcoind_warning_var.value,
node.bitcoind_work.value):
print >> sys.stderr, '#' * 40
print >> sys.stderr, '>>> Warning: ' + warning
print >> sys.stderr, '#' * 40
if this_str != last_str or time.time() > last_time + 15:
print this_str
last_str = this_str
last_time = time.time()
except:
log.err()
status_thread()
except:
reactor.stop()
log.err(None, 'Fatal error:')
else:
if len(self.searchText) == self.cols - 2: return
self.searchText = self.searchText + chr(c)
self.stdscr.addstr(
self.rows - 1, 0,
self.searchText + (' ' * (self.cols - len(self.searchText) - 2)))
self.stdscr.move(self.rows - 1, len(self.searchText))
self.paintStatus(self.statusText + ' %d' % len(self.searchText))
self.stdscr.refresh()
def close(self):
""" clean up """
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
if __name__ == '__main__':
stdscr = curses.initscr() # initialize curses
screen = Screen(stdscr) # create Screen object
stdscr.refresh()
ircFactory = IRCFactory(screen)
reactor.addReader(screen) # add screen object as a reader to the reactor
reactor.connectTCP("irc.freenode.net", 6667, ircFactory) # connect to IRC
reactor.run() # have fun!
screen.close()
class SerialD():
cuenta=0
def __init__(self):
self.datos=None;
self.ser_acm0 = serial.Serial()
self.ser_acm0.baudrate = 115200
self.ser_acm0.port = '/dev/ttyACM0'
self.sensores=[0,0,0,0,0]
def start(self):
try:
self.ser_acm0.open()
except:
self.ser_acm0.port='/dev/ttyUSB0'
self.ser_acm0.open()
self.hilo=threading.Thread(target=self.update, args=())
self.hilo.start()
def end(self):
self.ser_acm0.close()
def update(self):
while self.ser_acm0.isOpen():
self.ser_acm0.flush() #espera a exista un dato
datos=self.ser_acm0.readline()
if (datos.decode('cp1250').replace('\r\n','')=='a'):
time.sleep(0.1)
def press(self,key):
#print(key.encode('cp1250'))
self.ser_acm0.write(key.encode('cp1250'))#codifica y envia
class AppProtocol(WebSocketClientProtocol):
def onOpen(self):
self.seri=SerialD()
print("Abierto")
def onConnect(self, response):
print("server conectado")
def onConnecting(self, transport_details):
print("Conectando")
return None # ask for defaults
def onMessage(self, payload, isBinary):
text_data_json = json.loads(payload.decode('utf8'))
if(text_data_json['type']=='MC'):
print("MC")
self.seri.start()
self._loop = LoopingCall(self.envioSerial)
self._loop.start(0.1)
elif(text_data_json['type']=='MD'):
subprocess.call('/usr/bin/pm2 restart 0',shell=True)
print("MD")
else:
message = text_data_json['message']
print(message)
self.seri.press(str(message))
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed")
def envioSerial(self):
self.sendMessage(json.dumps({'userFrom':'2','userTo': '1','type':'sensores','message':self.seri.sensores}).encode('utf8'))
class AppFactory(WebSocketClientFactory, ReconnectingClientFactory):
protocol = AppProtocol
def clientConnectionFailed(self, connector, reason):
print("Unable connect to the server")
self.retry(connector)
subprocess.call('/usr/bin/pm2 restart 0',shell=True)
def clientConnectionLost(self, connector, reason):
print("Lost connection and retrying...")
self.retry(connector)
subprocess.call('/usr/bin/pm2 restart 0',shell=True)
if __name__ == '__main__':
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
factory = AppFactory(u"ws://ritaportal.udistrital.edu.co:10207/jordan")
reactor.connectTCP(server, port, factory)
reactor.run()
def gnutella_connect(port, ip):
for i in range(0, 100):
if i != port:
reactor.connectTCP("127.0.0.1", 8000 + i,
Sender.GnutellaFactory(True))
def connectTCP(self, *arg, **kw):
return reactor.connectTCP(*arg,
bindAddress=(network_interface.get(), 0),
**kw)
# -*- coding: utf-8 -*-
from twisted.internet import protocol, reactor
class Echo(protocol.Protocol):
def connectionMade(self):
self.transport.write('Hello Server!')
print 'Connection established!'
def dataReceived(self, data):
print data
class EchoFactory(protocol.ClientFactory):
def buildProtocol(self, addr):
return Echo()
def clientConnectionFailed(self, connector, reason):
print 'Connection failed!'
print reason.getErrorMessage()
reactor.stop()
if __name__ == '__main__':
print 'Connecting...'
reactor.connectTCP('192.168.0.32', 1234, EchoFactory())
reactor.run()
from twisted.internet import protocol, reactor
HOST = 'localhost'
PORT = 21567
class TSClntProtocol(protocol.Protocol):
def sendDate(self):
data = input('> ')
if data:
print('...sending %s...'%data)
self.transport.write(data)
else:
self.transport.loseConnection()
def connectionMade(self):
self.sendDate()
def dataReceived(self, data):
print(data)
self.sendDate()
class TSClntFactory(protocol.ClientFactory):
protocol = TSClntProtocol
clientConnectionLost = clientConnectionFailed = \
lambda self, connector, reason: reactor.stop()
reactor.connectTCP(HOST, PORT, TSClntFactory())
reactor.run()
self.transport.write(data)
class GameClientFactory(ClientFactory):
def __init__(self, world):
self.world = world
def startedConnecting(self, connector):
print 'Started to connect.'
def buildProtocol(self, addr):
print 'Connected.'
return GameClient(self, self.world)
def clientConnectionLost(self, connector, reason):
print 'Lost connection. Reason:', reason
# connector.connect()
def clientConnectionFailed(self, connector, reason):
print 'Connection failed. Reason:', reason
w = World(reactor, isServer)
if isServer:
reactor.listenTCP(8123, ServerFactory(w))
else:
reactor.connectTCP('localhost', 8123, GameClientFactory(w))
LoopingCall(w.taskMgr.step).start(1 / 60)
reactor.run()
password = arg
#create application
app = QtWidgets.QApplication(sys.argv)
#add qt4 reactor
try:
import qt5reactor
qt5reactor.install()
except:
if "twisted.internet.reactor" in sys.modules:
del sys.modules["twisted.internet.reactor"]
import qt5reactor
qt5reactor.install()
from twisted.internet import reactor
for arg in args:
if ':' in arg:
ip, port = arg.split(':')
else:
ip, port = arg, "5900"
reactor.connectTCP(
ip, int(port), RFBScreenShotFactory(password,
path + "%s.jpg" % ip))
reactor.runReturn()
app.exec_()
class botFactory(protocol.ClientFactory):
global conf_file
def __init__(self):
self.config = Config(conf_file)
def buildProtocol(self, addr):
p = bot(self.config)
p.factory = self
return p
def clientConnectionLost(self, connector, reason):
print "Connection lost. Reconnecting..."
connector.connect()
def clientConnectionFailed(self, connector, reason):
print "connection failed:", reason
reactor.stop()
if __name__ == '__main__':
print "Starting Pybot Version: " + str(version)
f = botFactory()
reactor.connectTCP(network, port, f)
print "Connecting..."
reactor.run()
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8789, factory)
return factory.login(self.credentials).addCallback(self._connected)
def connect(self):
tronHost = self.actor.actorConfig['tron']['host']
tronPort = self.actor.actorConfig['tron']['cmdrPort']
reactor.connectTCP(tronHost, tronPort, self.connector)
print "Writing message", key
i = value[0].index('BODY') + 2
msg = email.message_from_string(value[0][i])
destfd.write(msg.as_string(unixfrom=1))
destfd.write("\n")
self.uidlist.add(int(uid))
def deletemessages(self, data=None):
print "Deleting messages", str(self.uidlist)
d = self.proto.addFlags(str(self.uidlist), ["\\Deleted"], uid=1)
d.addCallback(lambda x: self.proto.expunge())
return d
def logout(self, data=None):
return self.proto.logout()
def stopreactor(self, data=None):
reactor.stop()
def errorhappened(self, failure):
print "An error occured:", failure.getErrorMessage()
d = self.logout()
d.addBoth(self.stopreactor)
return failure
print "WARNING: this program will delete all mail from the INBOX!"
password = getpass.getpass("Enter password for %s on %s: " % \
(sys.argv[2], sys.argv[1]))
reactor.connectTCP(sys.argv[1], 143, IMAPFactory(sys.argv[2], password))
reactor.run()
def connectTCP(self, *arg, **kw):
return reactor.connectTCP(*arg,
bindAddress=(self.config.get(
'network_interface', ''), 0),
**kw)
def initiateFileTransfer(self, filename, port):
log.debug('Downloading {} from port {}'.format(filename, port))
filepath = os.path.join(self.output_directory, filename)
session = FileReceiverFactory(filepath, self)
connector = reactor.connectTCP(self.config.host, port, session)
self.transfers_in_progress[session] = connector
def __init__(self, url, outputfile, contextFactory=None, *args, **kwargs):
scheme, host, port, path = client._parse(url)
self.factory = HTTPProgressDownloader(url, outputfile, *args, **kwargs)
self.connection = reactor.connectTCP(host, port, self.factory)
self.transport.abortConnection()
return
self.send_outgoing_data()
if close_connection:
self.transport.loseConnection()
def send_outgoing_data(self):
# This is more complicated than it should because we want to print all outgoing data here.
# Normally, self.transport.write(self.conn.data_to_send()) would suffice.
output = self.conn.data_to_send()
if output:
print('>>> ' + output.decode('utf-8').replace('\r\n', '\r\n>>> ').rstrip('> \r\n'))
self.transport.write(output)
class IRCClientFactory(ClientFactory):
def buildProtocol(self, addr):
return IRCProtocol(args.nickname, args.channel, args.message)
parser = ArgumentParser(description='A sample IRC client')
parser.add_argument('host', help='address of irc server (foo.bar.baz or foo.bar.baz:port)')
parser.add_argument('nickname', help='nickname to register as')
parser.add_argument('channel', help='channel to join once registered')
parser.add_argument('message', help='message to send once joined')
args = parser.parse_args()
host, _, port = args.host.partition(':')
reactor.connectTCP(host, int(port or 6667), IRCClientFactory())
reactor.run()
def main():
"""Program entry."""
f = EchoClientFactory()
reactor.connectTCP("localhost", 5001, f)
reactor.run()
def requestBirthdayList(self, addr):
print("[Birthday Reminder] requesting birthday list from", addr[0])
reactor.connectTCP(addr[0], 7374, TransferClientFactory(self, "requestingList"))
def main():
log.startLogging(sys.stdout)
reactor.connectTCP(config['host'], config['port'], RelayFactory())
reactor.run()
Do something clever here
"""
pass
def buildProtocol(self, addr):
p = MarketBot()
p.factory = self
return p
def clientConnectionLost(self, connector, reason):
"""If we get disconnected, reconnect to server."""
connector.connect()
def clientConnectionFailed(self, connector, reason):
print "connection failed:", reason
reactor.stop()
if __name__ == '__main__':
# initialize logging
log.startLogging(sys.stdout)
# create factory protocol and application
f = MarketBotFactory()
# connect factory to this host and port
reactor.connectTCP(LOCAL_FORWARD_IP, 8888, f)
# run bot
reactor.run()
def sendPingResponse(self, addr):
print("[Birthday Reminder] sending ping response to", addr[0])
reactor.connectTCP(addr[0], 7374, TransferClientFactory(self, "pong"))
def connect(host, port, options, verifyHostKey, userAuthObject):
d = defer.Deferred()
factory = SSHClientFactory(d, options, verifyHostKey, userAuthObject)
reactor.connectTCP(host, port, factory)
return d
def propagate_to_neighbors(self, line):
for server in SERVER_HERD[self.name]:
port = PORTS[server]
reactor.connectTCP('localhost', port, ClientFactory("AT " + line))
logging.info("Sent message: {0} to the following servers {1}".format(
"AT " + line, str(SERVER_HERD[self.name])))
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {}\n".format(reason))
time.sleep(3)
reactor.connectTCP("127.0.0.1", 9000, factory)
class EchoClient(protocol.Protocol):
def __init__(self, input):
self.input = input
def connectionMade(self):
self.transport.write(self.input.input)
def dataReceived(self, data):
print "Server said:", data
self.transport.loseConnection()
class EchoFactory(protocol.ClientFactory):
def __init__(self, input):
self.input = input
def buildProtocol(self, addr):
return EchoClient(self)
def clientConnectionFailed(self, connector, reason):
print "Connection failed."
reactor.stop()
def clientConnectionLost(self, connector, reason):
print "Connection lost."
reactor.stop()
reactor.connectTCP("localhost", 8000, EchoFactory("Hello Asshole"))
reactor.run()
def deliverJob(self):
# returns a Deferred that fires when the job has been delivered
if self.connect == "ssh":
tryhost = self.getopt("host")
tryport = self.getopt("port")
tryuser = self.getopt("username")
trydir = self.getopt("jobdir")
buildbotbin = self.getopt("buildbotbin")
ssh_command = self.getopt("ssh")
if not ssh_command:
ssh_commands = which("ssh")
if not ssh_commands:
raise RuntimeError(
"couldn't find ssh executable, make sure "
"it is available in the PATH")
argv = [ssh_commands[0]]
else:
# Split the string on whitespace to allow passing options in
# ssh command too, but preserving whitespace inside quotes to
# allow using paths with spaces in them which is common under
# Windows. And because Windows uses backslashes in paths, we
# can't just use shlex.split there as it would interpret them
# specially, so do it by hand.
if runtime.platformType == 'win32':
# Note that regex here matches the arguments, not the
# separators, as it's simpler to do it like this. And then we
# just need to get all of them together using the slice and
# also remove the quotes from those that were quoted.
argv = [
string.strip(a, '"') for a in re.split(
r'''([^" ]+|"[^"]+")''', ssh_command)[1::2]
]
else:
# Do use standard tokenization logic under POSIX.
argv = shlex.split(ssh_command)
if tryuser:
argv += ["-l", tryuser]
if tryport:
argv += ["-p", tryport]
argv += [tryhost, buildbotbin, "tryserver", "--jobdir", trydir]
pp = RemoteTryPP(self.jobfile)
reactor.spawnProcess(pp, argv[0], argv, os.environ)
d = pp.d
return d
if self.connect == "pb":
user = self.getopt("username")
passwd = self.getopt("passwd")
master = self.getopt("master")
tryhost, tryport = master.split(":")
tryport = int(tryport)
f = pb.PBClientFactory()
d = f.login(credentials.UsernamePassword(user, passwd))
reactor.connectTCP(tryhost, tryport, f)
d.addCallback(self._deliverJob_pb)
return d
raise RuntimeError(
"unknown connecttype '%s', should be 'ssh' or 'pb'" % self.connect)
def main():
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8800, factory)
def1 = factory.login(credentials.UsernamePassword("user1", "pass1"))
def1.addCallback(connected)
reactor.run()
def main():
from optparse import OptionParser
parser = OptionParser(usage="usage: %prog [options] channels")
# IRC connection options
parser.add_option("-s",
"--server",
action="store",
dest="server",
default="irc.freenode.net",
help="IRC server to connect to")
parser.add_option("-p",
"--port",
action="store",
type="int",
dest="port",
default=None,
help="IRC server to connect to")
parser.add_option("--ssl",
action="store_true",
dest="ssl",
default=False,
help="use SSL")
parser.add_option("--password",
action="store",
dest="password",
default=None,
help="server password")
parser.add_option("-n",
"--nick",
action="store",
dest="nick",
default="karmabot",
help="nickname to use")
# Bot options
parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="enable verbose output")
parser.add_option("-d",
"--data",
action="store",
dest="filename",
default="karma.json",
help="karma data file name")
parser.add_option("-t",
"--trust",
action="append",
dest="trusted",
default=[],
help="trusted hostmasks")
parser.add_option("-f",
"--facets",
action="append",
dest="facets",
default=[],
help="additional facets to load")
(options, channels) = parser.parse_args()
if not channels:
parser.error("You must supply some channels to join.")
else:
log.msg("Channels to join: %s" % channels)
if options.verbose:
log.startLogging(sys.stdout)
if not options.port:
options.port = 6667 if not options.ssl else 9999
factory = KarmaBotFactory(options.filename, options.nick, channels,
options.trusted, options.password,
options.facets)
if not options.ssl:
reactor.connectTCP(options.server, options.port, factory)
else:
reactor.connectSSL(options.server, options.port, factory,
ssl.ClientContextFactory())
reactor.run()
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {}\n".format(reason))
time.sleep(3)
reactor.connectTCP("127.0.0.1", 9000, factory)
def choose_resource_path():
global dlroot
if name == "nt":
if not path.exists(dlroot):
mkdir(dlroot)
if name == "posix":
dlroot = path.abspath(".")
########
# main #
########
if __name__ == '__main__':
choose_resource_path()
# log.startLogging(stdout)
log.startLogging(open(path.join(dlroot, 'log_phi.txt'), 'a'))
factory = WebSocketClientFactory(u"ws://127.0.0.1:9000", debug=False)
factory.protocol = MyWorkerProtocol
reactor.connectTCP("127.0.0.1", 9000, factory)
reactor.run()
