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 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 __init__(self, lm, port=12346, n=0):
"""n indicates the n-gram size, if set to 0 (which is default), the server will expect to only receive whole sentence, if set to a particular value, it will only expect n-grams of that value"""
if n == 0:
reactor.listenTCP(port, LMSentenceFactory(lm))
else:
reactor.listenTCP(port, LMNGramFactory(lm))
reactor.run()
def run():
with LoggingContext("run"):
logger.info("Running")
change_resource_limit(config.soft_file_limit)
if config.gc_thresholds:
gc.set_threshold(*config.gc_thresholds)
reactor.run()
def run(self):
framelog = os.path.join(self.basedir, "driver.log")
log.startLogging(open(framelog, "a"), setStdout=False)
log.msg("CHECK_MEMORY(mode=%s) STARTING" % self.mode)
#logfile = open(os.path.join(self.testdir, "log"), "w")
#flo = log.FileLogObserver(logfile)
#log.startLoggingWithObserver(flo.emit, setStdout=False)
d = fireEventually()
d.addCallback(lambda res: self.setUp())
d.addCallback(lambda res: self.record_initial_memusage())
d.addCallback(lambda res: self.make_nodes())
d.addCallback(lambda res: self.wait_for_client_connected())
d.addCallback(lambda res: self.do_test())
d.addBoth(self.tearDown)
def _err(err):
self.failed = err
log.err(err)
print err
d.addErrback(_err)
def _done(res):
reactor.stop()
return res
d.addBoth(_done)
reactor.run()
if self.failed:
# raiseException doesn't work for CopiedFailures
self.failed.raiseException()
def run(port, hostname, interface, verbosity):
if verbosity == 0: # -q
level = logging.CRITICAL
elif verbosity == 1: # default
level = logging.WARNING
elif verbosity == 2: # -v
level = logging.INFO
else: # -v -v
level = logging.DEBUG
logging.basicConfig(level=level)
if hostname:
if not hostname.startswith('http://'):
hostname = 'http://%s' % (hostname,)
sep = hostname.find('/')
if sep != -1:
hostname = hostname[:sep]
if port != 80 and not ':' in hostname:
hostname = "http://%s:%d/" % (hostname, port)
else:
hostname = "http://%s/" % hostname
logging.info('Hostname set to %s' % hostname)
pong = PongGame()
reactor.listenTCP(port, HttpFactory(hostname, pong), interface=interface)
reactor.run()
def run(self):
"""
Start serving webpages from the local web server
"""
log.debug("start web server running")
webDir = self.config.webDir
self.root.putChild("images", static.File(webDir+"/images"))
self.root.putChild("previews", static.File(webDir+"/previews"))
self.root.putChild("css", static.File(webDir+"/css"))
self.root.putChild("scripts", static.File(webDir+"/scripts"))
self.root.putChild("style", static.File(webDir+"/style"))
self.root.putChild("docs", static.File(webDir+"/docs"))
self.root.putChild("temp_print_dirs",
static.File(webDir+"/temp_print_dirs"))
xulDir = self.config.xulDir
self.root.putChild("xulscripts", static.File(xulDir+"/scripts"))
self.root.putChild("xultemplates", static.File(xulDir+"/templates"))
self.root.putChild("templates", static.File(webDir+"/templates"))
self.root.putChild("editor", self.editor)
self.root.putChild("preferences", self.preferences)
self.root.putChild("about", self.about)
if self.config.port >= 0:
log.info("run() using eXe port# %d", self.config.port)
reactor.run()
else:
log.error("ERROR: webserver's run() called, but a valid port was not available.")
def next_step(self):
# We already sent the details, but may still be on the same step.
# Also, if the user didn't choose to "register now", respect his
# decision
if not self.model.register_now or self.wizard.link_request_done:
return FinishInstallationStep(self.wizard)
webapi = WebService()
response = webapi.link_registration(
self.model.name, self.model.email, self.model.phone)
response.addCallback(self._on_response_done)
response.addErrback(self._on_response_error)
# FIXME: This is a hack, remove it when we can avoid
# calling dialog.run()
if not reactor.running:
reactor.run()
self.send_progress.show()
self.send_progress.set_text(_('Sending...'))
self.send_progress.set_pulse_step(0.05)
self.wizard.next_button.set_sensitive(False)
glib.timeout_add(50, self._pulse)
# Cancel the request after 30 seconds without a reply
glib.timeout_add(30000, self._cancel_request)
# Stay on the same step while sending the details
return self
def main(): factory = protocol.ServerFactory() # 实例化一个ServerFactory对象 factory.protocol = Echo # 重写protocol # reactor(反应堆)就是twisted的事件驱动，是twisted的核心. reactor.listenTCP(1234, factory) # 将factory回调函数注册到reactor中，reactor监听指定端口，根据状态来触发factory中不同的方法 reactor.run() # 启动一个TCP服务器， 监听1234端口，reactor则开始监听。
def main():
boots = (('router.bittorrent.com', 6881),)
p = BittorrentProtocol(boots)
# lc = LoopingCall(monitor, p)
# lc.start(5)
reactor.listenUDP(6881, p)
reactor.run()
def run(self):
self.factory = HTTPFactory(
self.channel_layer,
self.action_logger,
timeout=self.http_timeout,
websocket_timeout=self.websocket_timeout,
ping_interval=self.ping_interval,
ws_protocols=self.ws_protocols,
root_path=self.root_path,
)
# Redirect the Twisted log to nowhere
globalLogBeginner.beginLoggingTo([lambda _: None], redirectStandardIO=False, discardBuffer=True)
# Listen on a socket
if self.unix_socket:
reactor.listenUNIX(self.unix_socket, self.factory)
elif self.file_descriptor:
# socket returns the same socket if supplied with a fileno
sock = socket.socket(fileno=self.file_descriptor)
reactor.adoptStreamPort(self.file_descriptor, sock.family, self.factory)
else:
reactor.listenTCP(self.port, self.factory, interface=self.host)
if "twisted" in self.channel_layer.extensions:
logging.info("Using native Twisted mode on channel layer")
reactor.callLater(0, self.backend_reader_twisted)
else:
logging.info("Using busy-loop synchronous mode on channel layer")
reactor.callLater(0, self.backend_reader_sync)
reactor.callLater(2, self.timeout_checker)
reactor.run(installSignalHandlers=self.signal_handlers)
def wrapper(*args, **kwds):
# Ignore SIGINT to avoid it being captured in the child process
# when pressing ctrl+c on the terminal to close the server
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, _sigterm_handler)
f(*args, **kwds)
reactor.run(False)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--port')
parser.add_argument('--store')
parser.add_argument('--retrieve')
parser.add_argument('--connect', default=None)
args = parser.parse_args()
port = int(args.port)
service = ChordService()
if (args.connect):
dst = args.connect.split(':')
service.AddToRoutingTable(IPv4Address('TCP', dst[0], int(dst[1])))
if (args.store):
key, value = args.store.split(':')
service.StoreValue(key, value)
if (args.retrieve):
def EchoValue(value):
print('Retrieved value: {}.'.format(value))
d = service.GetValue(args.retrieve)
d.addCallback(EchoValue)
f = pb.PBServerFactory(service)
reactor.listenTCP(port, f)
reactor.run()
def run(self, *args, **kw):
""""""
log.info("broker.run")
from twisted.internet import reactor
reactor.exitcode = 0
reactor.run()
return reactor.exitcode
def test_priorization(self):
webdriver = Mock()
settings = self.settings(WEBDRIVER_BROWSER=webdriver)
webdriver.get.side_effect = self._wait
webdriver.page_source = u''
dispatcher.connect(self._stop_reactor, signal=signals.spider_closed)
crawler = Crawler(Settings(values=settings))
crawler.configure()
spider = self.Spider(name='test', domain='testdomain')
crawler.crawl(spider)
crawler.start()
log.start(loglevel='ERROR')
reactor.run()
assert webdriver.get.mock_calls == [
call('http://testdomain/path?wr=0'),
call('http://testdomain/path?wr=0&wa=0'),
call('http://testdomain/path?wr=0&wa=1'),
call('http://testdomain/path?wr=1'),
call('http://testdomain/path?wr=1&wa=0'),
call('http://testdomain/path?wr=1&wa=1'),
call('http://testdomain/path?wr=0&wa=0&wr=0'),
call('http://testdomain/path?wr=0&wa=1&wr=0'),
call('http://testdomain/path?wr=1&wa=0&wr=0'),
call('http://testdomain/path?wr=1&wa=1&wr=0')]
def main():
# app=QApplication(sys.argv)
app.setStyle("cleanlooks")
d = im(app)
client_twisted.clientUi=d
#pylint: disable=E1101
reactor.run()
def run(self):
# If umask = 0077, created files will be rw for effective user only
# If umask = 0007, they will be rw for effective user and group only
os.umask(self.config.umask)
os.setegid(self.config.egid)
os.seteuid(self.config.euid)
# Daemonize early
if self.daemon:
self.lock.acquire()
self.daemonize()
# Do all kind of initialization
try:
ret = self.initialize()
finally:
# Tell the father how to return, and let him return (release)
if self.daemon:
self.state = ret
self.lock.release()
if ret:
return ret
reactor.run()
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 add_bank(self):
task = Administration(self.creds, "add bank", self.details)
task.runEngine()
try:
reactor.run()
except:
pass
def add_settings(self):
task = Administration(self.creds, "add settings", self.details)
task.runEngine()
try:
reactor.run()
except:
pass
def launch_stdout_downloader():
from twisted.internet import reactor
logging.basicConfig(level=logging.WARNING, filename="dl.log")
if len(sys.argv) == 3:
downloader = StdoutDownloader(int(sys.argv[2]), [])
elif len(sys.argv) == 5:
downloader = StdoutDownloader(int(sys.argv[2]), [(sys.argv[3], int(sys.argv[4]))])
else:
print "Usage: lbrynet-stdout-downloader <sd_hash> <peer_port> <dht_node_port>" \
" [<dht_bootstrap_host> <dht_bootstrap port>]"
sys.exit(1)
def start_stdout_downloader():
return downloader.start_download(sys.argv[1])
def print_error(err):
logging.warning(err.getErrorMessage())
def shut_down():
reactor.stop()
d = task.deferLater(reactor, 0, downloader.start)
d.addCallback(lambda _: start_stdout_downloader())
d.addErrback(print_error)
d.addCallback(lambda _: shut_down())
reactor.addSystemEventTrigger('before', 'shutdown', downloader.shut_down)
reactor.run()
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 main():
from twisted.internet import reactor
from twisted.python import log
import logging
log.PythonLoggingObserver().start()
logging.getLogger().setLevel(level=logging.DEBUG)
LOG.setLevel(level=logging.DEBUG)
api_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
api_secret = "XXXXXXXXXXXX"
flickr = TwistedFlickrAPI(api_key, api_secret)
#flickr.authenticate_console("write"
# ).addCallback(log.msg, "<- got token"
# ).addBoth(lambda _: reactor.callLater(0, reactor.stop)
# )
#flickr.upload("test.jpg", is_public="0"
# ).addBoth(log.msg
# ).addBoth(lambda _: reactor.callLater(0, reactor.stop)
# )
flickr.photos_search(user_id='73509078@N00', per_page='10'
).addBoth(log.msg
).addBoth(lambda _: reactor.callLater(0, reactor.stop)
)
reactor.run()
def poetry_main():
addresses = parse_args()
from twisted.internet import reactor
poems = []
errors = []
def got_poem(poem):
poems.append(poem)
def poem_failed(err):
print >>sys.stderr, 'Poem failed:', err
errors.append(err)
def poem_done(_):
if len(poems) + len(errors) == len(addresses):
reactor.stop()
for address in addresses:
host, port = address
d = get_poetry(host, port)
d.addCallbacks(got_poem, poem_failed)
d.addBoth(poem_done)
reactor.run()
for poem in poems:
print poem
def getList():
# For the sample client, below:
from twisted.internet import reactor
from twisted.internet.protocol import ClientCreator
creator = ClientCreator(reactor, amp.AMP)
host = '127.0.0.1'
import sys
if len(sys.argv) > 1:
host = sys.argv[1]
d = creator.connectTCP(host, 62308)
def connected(ampProto):
return ampProto.callRemote(GatewayAMPCommand, command=command)
d.addCallback(connected)
def resulted(result):
return result['result']
d.addCallback(resulted)
def done(result):
print('Done: %s' % (result,))
reactor.stop()
d.addCallback(done)
reactor.run()
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 run(create_publisher, host='', port=80):
"""Runs a Twisted HTTP server server that publishes a Quixote
application."""
publisher = create_publisher()
factory = QuixoteFactory(publisher)
reactor.listenTCP(port, factory, interface=host)
reactor.run()
def nda_loop():
ndutil.setTimezone()
ndlCom = NdlCom('nDroid-Executer', '127.0.0.1', 12322)
ndlCom.doCom('Initiating')
ndlCom.doCom('Loading Config')
cnfManager = CnfManager()
cnfManager.load('./nde.cnf')
cnfData = cnfManager.getCnfData()
nsQueue = Queue()
nsLock = threading.Lock()
netManager = NetManager()
netManager.setNdlCom(ndlCom)
netManager.setNsQueue(nsQueue, nsLock)
ndlCom.doCom('Starting Threads')
scheduler = Scheduler([ndlCom, nsQueue, nsLock], 'Scheduler')
scheduler.start()
reactor.listenUDP(cnfData['comPort'], netManager)
ndlCom.doCom('Listening Com Port')
reactor.run()
scheduler.join()
def main():
global cbUrls, tsunamiUrl
from optparse import OptionParser
parser = OptionParser()
parser.add_option(
"-t",
"--tsunami",
dest="tsunami",
type="string",
default="http://127.0.0.1:9000",
help="tsunami announce url. default: http://127.0.0.1:9000"
)
parser.add_option(
"-p",
"--port",
dest="port",
type="int",
default=5000,
help="port the RestQ demonstration resource should bind to. default: 5000"
)
options = parser.parse_args()[0]
cbUrls = {
'connect':'http://localhost:%s/connect'%options.port,
'disconnect':'http://localhost:%s/disconnect'%options.port,
'subscribe':'http://localhost:%s/subscribe'%options.port,
'unsubscribe':'http://localhost:%s/unsubscribe'%options.port,
'send':'http://localhost:%s/send'%options.port
}
tsunamiUrl = options.tsunami
site = server.Site(RestQDummyResource())
print 'running on %s'%options.port
reactor.listenTCP(options.port, site)
reactor.run()
def exec_test(fun, params=None, protocol=None, timeout=None,
make_conn=True):
reactor.callWhenRunning (exec_test_deferred, fun, params, protocol, timeout,
make_conn)
reactor.run()
def destroy(self, widget, data=None):
reactor.stop()
class PprzUDPProtocol(DatagramProtocol):
cb_recv_data = False
def __init__(self, in_port, out_port, cb_recv_data):
self.port = in_port
self.out_port = out_port
self.cb_recv_data = cb_recv_data
def startProtocol(self):
self.transport.socket.setsockopt(SOL_SOCKET, SO_BROADCAST, True)
def sendData(self, data):
self.transport.write(data, ('127.255.255.255', self.out_port))
def datagramReceived(self, datagram, addr):
if self.cb_recv_data is not None:
self.cb_recv_data(datagram)
if __name__ == "__main__":
from twisted.internet import reactor
from twisted.internet.serialport import SerialPort
IridiumCtrl()
reactor.run()
def main():
f = EchoFactory()
reactor.connectTCP("172.20.20.85", 11000, f)
reactor.run()
def main():
foo = Foo()
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8800, factory)
factory.getRootObject().addCallback(foo.step1)
reactor.run()
def reactor_runner(self):
reactor.run()
def run():
configure_logging()
runner = CrawlerRunner(get_project_settings())
d = runner.crawl(HMSpider)
d.addBoth(lambda _: reactor.stop())
reactor.run() # the script will block here until the crawling is finished
def main():
protocol = EchoClientDatagramProtocol()
t = reactor.listenUDP(0, protocol)
reactor.run()
def run_in_scheduled_mode():
logger.info('Running in scheduled mode')
signal.signal(signal.SIGINT, handle_sigint)
crawl()
reactor.run()
def start_webserver(options,
protocol=vtk_wamp.ServerProtocol,
disableLogging=False):
"""
Starts the web-server with the given protocol. Options must be an object
with the following members:
options.host : the interface for the web-server to listen on
options.port : port number for the web-server to listen on
options.timeout : timeout for reaping process on idle in seconds
options.content : root for web-pages to serve.
"""
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
import sys
if not disableLogging:
log.startLogging(sys.stdout)
contextFactory = None
use_SSL = False
if options.sslKey and options.sslCert:
use_SSL = True
wsProtocol = "wss"
from twisted.internet import ssl
contextFactory = ssl.DefaultOpenSSLContextFactory(
options.sslKey, options.sslCert)
else:
wsProtocol = "ws"
# Create WAMP router factory
from autobahn.twisted.wamp import RouterFactory
router_factory = RouterFactory()
# create a user DB
authdb = vtk_wamp.AuthDb()
# create a WAMP router session factory
from autobahn.twisted.wamp import RouterSessionFactory
session_factory = RouterSessionFactory(router_factory)
session_factory.session = vtk_wamp.CustomWampCraRouterSession
session_factory.authdb = authdb
# Create ApplicationSession and register protocols
appSession = protocol(types.ComponentConfig(realm="vtkweb"))
appSession.setAuthDB(authdb)
session_factory.add(appSession)
# create a WAMP-over-WebSocket transport server factory
transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \
url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \
debug = options.debug, \
debug_wamp = options.debug, \
timeout = options.timeout )
root = Resource()
# Do we serve static content or just websocket ?
if len(options.content) > 0:
# Static HTTP + WebSocket
root = File(options.content)
# Handle possibly complex ws endpoint
if not options.nows:
wsResource = WebSocketResource(transport_factory)
handle_complex_resource_path(options.ws, root, wsResource)
# Handle binary push WebSocket for images
if not options.nobws:
wsbFactory = WebSocketServerFactory( \
url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \
debug = options.debug)
wsbFactory.protocol = vtk_wamp.ImagePushBinaryWebSocketServerProtocol
wsbResource = WebSocketResource(wsbFactory)
handle_complex_resource_path('wsb', root, wsbResource)
# Handle possibly complex lp endpoint
if not options.nolp:
lpResource = WampLongPollResource(session_factory,
timeout=options.timeout,
debug=options.debug)
#killAfter = 30000,
#queueLimitBytes = 1024 * 1024,
#queueLimitMessages = 1000,
#debug=True,
#reactor=reactor)
handle_complex_resource_path(options.lp, root, lpResource)
if options.uploadPath != None:
from upload import UploadPage
uploadResource = UploadPage(options.uploadPath)
root.putChild("upload", uploadResource)
if len(options.fsEndpoints) > 3:
for fsResourceInfo in options.fsEndpoints.split('|'):
infoSplit = fsResourceInfo.split('=')
handle_complex_resource_path(infoSplit[0], root,
File(infoSplit[1]))
site = Site(root)
if use_SSL:
reactor.listenSSL(options.port, site, contextFactory)
else:
reactor.listenTCP(options.port, site)
# flush ready line
sys.stdout.flush()
# Work around to force the output buffer to be flushed
# This allow the process launcher to parse the output and
# wait for "Start factory" to know that the WebServer
# is running.
if options.forceFlush:
for i in range(200):
log.msg("+" * 80, logLevel=logging.CRITICAL)
# Initialize testing: checks if we're doing a test and sets it up
testing.initialize(options, reactor, stop_webserver)
# Start the reactor
if options.nosignalhandlers:
reactor.run(installSignalHandlers=0)
else:
reactor.run()
# Give the testing module a chance to finalize, if necessary
testing.finalize()
def run_in_single_run_mode():
logger.info('Running in single run mode')
runner.crawl(OlxSpider)
d: Deferred = runner.join()
d.addBoth(lambda _: reactor.stop())
reactor.run()
def requesthandler(self,dynamic=True, sych= False):
reactor.listenTCP(self.port, MyHTTPFactory())
reactor.run()
def prepare_twisted_service():
LOG.info('Prepare twisted services')
# check all peers
all_peers = {}
# check running mode
if not CONF.standalone:
# rabbitmq factory
rabbit_mq_factory = PikaFactory(url=CONF.rabbit_mq.rabbit_url)
rabbit_mq_factory.peer_list = CONF.bgp.running_config.keys()
rabbit_mq_factory.connect()
# mongodb connection
if CONF.database.use_replica:
mongo_connection = MongoApi(
connection_url=CONF.database.connection,
db_name=CONF.database.dbname,
use_replica=CONF.database.use_replica,
replica_name=CONF.database.replica_name,
read_preference=CONF.database.read_preference,
write_concern=CONF.database.write_concern,
w_timeout=CONF.database.write_concern_timeout)
else:
mongo_connection = MongoApi(
connection_url=CONF.database.connection,
db_name=CONF.database.dbname)
# check api bind host
if CONF.rest.bind_host == '0.0.0.0':
LOG.error(
'please use the exactly rest host ip address when not running in standalone mode'
)
sys.exit()
# TODO load channel filter and peer policy
else:
rabbit_mq_factory = None
mongo_connection = None
for peer in CONF.bgp.running_config:
LOG.info('Get peer %s configuration', peer)
if not CONF.standalone:
if CONF.bgp.running_config[peer]['local_addr'] == '0.0.0.0':
LOG.error(
'please use the exactly local bgp ip address when not running in standalone mode'
)
sys.exit()
if CONF.message.write_disk:
msg_file_path_for_peer = os.path.join(CONF.message.write_dir,
peer.lower())
if not os.path.exists(msg_file_path_for_peer):
os.makedirs(msg_file_path_for_peer)
LOG.info('Create dir %s for peer %s', msg_file_path_for_peer,
peer)
LOG.info('BGP message file path is %s', msg_file_path_for_peer)
else:
msg_file_path_for_peer = None
LOG.info('Create BGPPeering instance')
afi_safi_list = [
bgp_cons.AFI_SAFI_STR_DICT[afi_safi]
for afi_safi in CONF.bgp.running_config[peer]['afi_safi']
]
CONF.bgp.running_config[peer]['afi_safi'] = afi_safi_list
CONF.bgp.running_config[peer]['capability']['local'][
'afi_safi'] = afi_safi_list
bgp_peering = BGPPeering(
myasn=CONF.bgp.running_config[peer]['local_as'],
myaddr=CONF.bgp.running_config[peer]['local_addr'],
peerasn=CONF.bgp.running_config[peer]['remote_as'],
peeraddr=CONF.bgp.running_config[peer]['remote_addr'],
tag=CONF.bgp.running_config[peer]['tag'],
afisafi=CONF.bgp.running_config[peer]['afi_safi'],
msgpath=msg_file_path_for_peer,
md5=CONF.bgp.running_config[peer]['md5'],
channel=rabbit_mq_factory,
mongo_conn=mongo_connection)
all_peers[peer] = bgp_peering
CONF.bgp.running_config[peer]['factory'] = bgp_peering
# register to database and check agent role
if not CONF.standalone:
register_to_db(peer_ip=peer, mongo_api=mongo_connection)
if not CONF.bgp.running_config[peer]['tag']:
LOG.error(
'Please point out the role tag(SRC,DST or BOTH)for not running in standalone mode'
)
sys.exit()
load_channel_filter_from_db(peer_ip=peer,
mongo_api=mongo_connection)
# Starting api server
if sys.version_info[0] == 2:
from twisted.web.wsgi import WSGIResource
LOG.info("Prepare RESTAPI service")
resource = WSGIResource(reactor, reactor.getThreadPool(), app)
site = Site(resource)
try:
reactor.listenTCP(CONF.rest.bind_port,
site,
interface=CONF.rest.bind_host)
LOG.info("serving RESTAPI on http://%s:%s", CONF.rest.bind_host,
CONF.rest.bind_port)
except Exception as e:
LOG.error(e, exc_info=True)
sys.exit()
for peer in all_peers:
LOG.info('start peer, peer address=%s', peer)
all_peers[peer].automatic_start()
reactor.run()
def run(self, reactor):
reactor.run(installSignalHandlers=ServerConfig.backend.installSignalHandlers)
'''
Created on 12/set/2014
@author: riccardo
'''
from twisted.cred import checkers, portal
from twisted.internet import reactor
from twisted.words import service
wordsRealm = service.InMemoryWordsRealm("example.com")
wordsRealm.createGroupOnRequest = True
checker = checkers.FilePasswordDB("passwords.txt")
portal = portal.Portal(wordsRealm, [checker])
reactor.listenTCP(6667, service.IRCFactory(wordsRealm,
portal)) # @UndefinedVariable
reactor.run() # @UndefinedVariable
def run(self):
# Starts listening for client to connect
reactor.listenTCP(self.commandPort1,
ServerCommandConnectionFactory(self))
reactor.run()
def createserver(self):
#pConnect to the server
factory = MyClientFactory()
reactor.connectTCP(self.host, self.port, factory)
reactor.run()
def in_thread():
# Uncomment to enable tracing of log context changes.
# sys.settrace(logcontext_tracer)
with LoggingContext("run"):
change_resource_limit(hs.config.soft_file_limit)
reactor.run()
def download_from_sitemap(enlaces,ruta_d):
runner= CrawlerRunner({'USER_AGENT': 'Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0'})
d=runner.crawl(MySpider,url=enlaces,ruta=ruta_d,a=(),kw={})
d.addBoth(lambda _: reactor.stop())
reactor.run()
def _wait(self, d, running=_wait_is_running):
"""Take a Deferred that only ever callbacks. Block until it happens."""
if running:
raise RuntimeError("_wait is not reentrant")
from twisted.internet import reactor
results = []
def append(any):
if results is not None:
results.append(any)
def crash(ign):
if results is not None:
reactor.crash()
crash = utils.suppressWarnings(
crash,
util.suppress(message=r"reactor\.crash cannot be used.*",
category=DeprecationWarning),
)
def stop():
reactor.crash()
stop = utils.suppressWarnings(
stop,
util.suppress(message=r"reactor\.crash cannot be used.*",
category=DeprecationWarning),
)
running.append(None)
try:
d.addBoth(append)
if results:
# d might have already been fired, in which case append is
# called synchronously. Avoid any reactor stuff.
return
d.addBoth(crash)
reactor.stop = stop
try:
reactor.run()
finally:
del reactor.stop
# If the reactor was crashed elsewhere due to a timeout, hopefully
# that crasher also reported an error. Just return.
# _timedOut is most likely to be set when d has fired but hasn't
# completed its callback chain (see self._run)
if results or self._timedOut: # defined in run() and _run()
return
# If the timeout didn't happen, and we didn't get a result or
# a failure, then the user probably aborted the test, so let's
# just raise KeyboardInterrupt.
# FIXME: imagine this:
# web/test/test_webclient.py:
# exc = self.assertRaises(error.Error, wait, method(url))
#
# wait() will raise KeyboardInterrupt, and assertRaises will
# swallow it. Therefore, wait() raising KeyboardInterrupt is
# insufficient to stop trial. A suggested solution is to have
# this code set a "stop trial" flag, or otherwise notify trial
# that it should really try to stop as soon as possible.
raise KeyboardInterrupt()
finally:
results = None
running.pop()
def runReactor():
reactor.run(installSignalHandlers=False)
def run(self):
def signal_handler(*args):
logger.info('Received SIGTERM, shutting down.')
logger.info("Stopping threads, please wait...")
# teardown()
if self.raw_report_processor.isAlive():
self.raw_report_processor.stop()
self.timer.stop()
log_path = os.path.join(CONST_FARADAY_HOME_PATH, 'logs',
'access-logging.log')
site = twisted.web.server.Site(self.__root_resource,
logPath=log_path,
logFormatter=proxiedLogFormatter)
site.displayTracebacks = False
if self.__ssl_enabled:
ssl_context = self.__load_ssl_certs()
self.__listen_func = functools.partial(reactor.listenSSL,
contextFactory=ssl_context)
else:
self.__listen_func = reactor.listenTCP
try:
self.install_signal()
# start threads and processes
self.raw_report_processor = ReportsManager(
REPORTS_QUEUE, name="ReportsManager-Thread", daemon=True)
self.raw_report_processor.start()
self.timer = TimerClass()
self.timer.start()
# web and static content
self.__listen_func(self.__listen_port,
site,
interface=self.__bind_address)
# websockets
if faraday.server.config.websocket_ssl.enabled:
try:
contextFactory = ssl.DefaultOpenSSLContextFactory(
faraday.server.config.websocket_ssl.keyfile.strip(
'\''),
faraday.server.config.websocket_ssl.certificate.strip(
'\''))
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address,
contextFactory=contextFactory)
except SSLError as e:
logger.error(
'Could not start websockets due to a SSL Config error. Some web functionality will not be available'
)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
else:
try:
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
logger.info('Faraday Server is ready')
reactor.addSystemEventTrigger('before', 'shutdown', signal_handler)
reactor.run()
except error.CannotListenError as e:
logger.error(e)
sys.exit(1)
except Exception as e:
logger.error(
'Something went wrong when trying to setup the Web UI')
logger.exception(e)
sys.exit(1)
# Create new session
os.setsid()
if os.fork() != 0:
os._exit(0)
os.chdir('/')
fd = os.open('/dev/null', os.O_RDONLY)
os.dup2(fd, sys.__stdin__.fileno())
os.close(fd)
fd = os.open('/var/log/sippy.log',
os.O_WRONLY | os.O_CREAT | os.O_APPEND)
os.dup2(fd, sys.__stdout__.fileno())
os.dup2(fd, sys.__stderr__.fileno())
os.close(fd)
SipConf.my_uaname = 'Sippy B2BUA (Simple)'
SipConf.allow_formats = (0, 8, 18, 100, 101)
global_config['_sip_address'] = SipConf.my_address
global_config['_sip_port'] = SipConf.my_port
if laddr != None:
global_config['_sip_address'] = laddr
if lport != None:
global_config['_sip_port'] = lport
global_config['_sip_logger'] = SipLogger('b2bua')
cmap = CallMap(global_config)
global_config['_sip_tm'] = SipTransactionManager(global_config,
cmap.recvRequest)
reactor.run(installSignalHandlers=True)
def start():
"""The primary entry point for launching the daemon."""
# postpone loading the config file to after the CLI arguments
# have been parsed, as they may contain an alternate config file location
conf.initialize_settings(load_conf_file=False)
parser = argparse.ArgumentParser(description="Launch lbrynet-daemon")
parser.add_argument(
"--conf",
help="specify an alternative configuration file",
type=str,
default=None
)
parser.add_argument(
"--wallet",
help="lbryum or ptc for testing, default lbryum",
type=str,
default=conf.settings['wallet']
)
parser.add_argument(
"--http-auth", dest="useauth", action="store_true", default=conf.settings['use_auth_http']
)
parser.add_argument(
'--quiet', dest='quiet', action="store_true",
help='Disable all console output.'
)
parser.add_argument(
'--verbose', nargs="*",
help=('Enable debug output. Optionally specify loggers for which debug output '
'should selectively be applied.')
)
parser.add_argument(
'--version', action="store_true",
help='Show daemon version and quit'
)
args = parser.parse_args()
update_settings_from_args(args)
conf.settings.load_conf_file_settings()
if args.version:
version = system_info.get_platform(get_ip=False)
version['installation_id'] = conf.settings.installation_id
print utils.json_dumps_pretty(version)
return
lbrynet_log = conf.settings.get_log_filename()
log_support.configure_logging(lbrynet_log, not args.quiet, args.verbose)
log.debug('Final Settings: %s', conf.settings.get_current_settings_dict())
try:
log.debug('Checking for an existing lbrynet daemon instance')
JSONRPCProxy.from_url(conf.settings.get_api_connection_string()).status()
log.info("lbrynet-daemon is already running")
return
except Exception:
log.debug('No lbrynet instance found, continuing to start')
log.info("Starting lbrynet-daemon from command line")
if test_internet_connection():
analytics_manager = analytics.Manager.new_instance()
start_server_and_listen(args.useauth, analytics_manager)
reactor.run()
else:
log.info("Not connected to internet, unable to start")
def start(self) -> None:
self.server.start()
self.https_server.start()
self.thread = threading.Thread(
target=lambda: reactor.run(installSignalHandlers=0))
self.thread.start()
def start():
parser = argparse.ArgumentParser(description="Launch lbrynet-daemon")
parser.add_argument("--wallet",
help="lbrycrd or lbryum, default lbryum",
type=str,
default='')
parser.add_argument("--ui", help="path to custom UI folder", default=None)
parser.add_argument(
"--branch",
help="Branch of lbry-web-ui repo to use, defaults on master")
parser.add_argument('--no-launch', dest='launchui', action="store_false")
parser.add_argument('--log-to-console',
dest='logtoconsole',
action="store_true")
parser.add_argument('--quiet', dest='quiet', action="store_true")
parser.set_defaults(branch=False,
launchui=True,
logtoconsole=False,
quiet=False)
args = parser.parse_args()
log_support.configure_file_handler(lbrynet_log)
log_support.configure_loggly_handler()
if args.logtoconsole:
log_support.configure_console(level='DEBUG')
log_support.disable_third_party_loggers()
log_support.disable_noisy_loggers()
try:
JSONRPCProxy.from_url(API_CONNECTION_STRING).is_running()
log.info("lbrynet-daemon is already running")
if not args.logtoconsole:
print "lbrynet-daemon is already running"
if args.launchui:
webbrowser.open(UI_ADDRESS)
return
except:
pass
log.info("Starting lbrynet-daemon from command line")
if not args.logtoconsole and not args.quiet:
print "Starting lbrynet-daemon from command line"
print "To view activity, view the log file here: " + lbrynet_log
print "Web UI is available at http://%s:%i" % (API_INTERFACE, API_PORT)
print "JSONRPC API is available at " + API_CONNECTION_STRING
print "To quit press ctrl-c or call 'stop' via the API"
if test_internet_connection():
lbry = LBRYDaemonServer()
d = lbry.start(
branch=args.branch if args.branch else DEFAULT_UI_BRANCH,
user_specified=args.ui,
wallet=args.wallet,
branch_specified=True if args.branch else False)
if args.launchui:
d.addCallback(lambda _: webbrowser.open(UI_ADDRESS))
lbrynet_server = server.Site(lbry.root)
lbrynet_server.requestFactory = LBRYDaemonRequest
reactor.listenTCP(API_PORT, lbrynet_server, interface=API_INTERFACE)
reactor.run()
if not args.logtoconsole and not args.quiet:
print "\nClosing lbrynet-daemon"
else:
log.info("Not connected to internet, unable to start")
if not args.logtoconsole:
print "Not connected to internet, unable to start"
return
def portthread():
while 1:
if win.zhuangtai == 1:
reactor.listenTCP(int(win.port), ChatFactory())
reactor.run()
time.sleep(1)
continue
if o == '-S':
sippy_path = a.strip()
continue
if o == '-o':
fname = a.strip()
if fname == '-':
file_out = sys.stdout
else:
file_out = file(fname, 'w')
if o == '-t':
timeout = float(a.strip())
continue
if sippy_path != None:
sys.path.insert(0, sippy_path)
from sippy.Cli_server_local import Cli_server_local
from sippy.Cli_server_tcp import Cli_server_tcp
from sippy.Timeout import Timeout
ch = cli_handler(file_out)
if stype == 'unix':
cs = Cli_server_local(ch.command_received, spath)
else:
cs = Cli_server_tcp(ch.command_received, spath)
if timeout != None:
Timeout(ch.done, timeout)
reactor.run(installSignalHandlers=1)
sys.exit(ch.rval)
def main():
global f
f = EchoFactory()
reactor.connectTCP("localhost", 8000, f)
reactor.callInThread(promp_metod)
reactor.run()
def start(self):
_transport = self.make_control_transport()
reactor.run() # < ------ Blocking Call (Reactor)
def main():
import argparse,json
from twisted.python.logfile import DailyLogFile
parser = argparse.ArgumentParser()
parser.add_argument('-dict','--dictfile', type=str,default=None,dest='dictfile',help='dict file')
parser.add_argument('-auth','--authport', type=int,default=0,dest='authport',help='auth port')
parser.add_argument('-acct','--acctport', type=int,default=0,dest='acctport',help='acct port')
parser.add_argument('-admin','--adminport', type=int,default=0,dest='adminport',help='admin port')
parser.add_argument('-c','--conf', type=str,default=None,dest='conf',help='conf file')
parser.add_argument('-d','--debug', nargs='?',type=bool,default=False,dest='debug',help='debug')
args = parser.parse_args(sys.argv[1:])
if not args.conf or not os.path.exists(args.conf):
print 'no config file user -c or --conf cfgfile'
return
_config = json.loads(open(args.conf).read())
_database = _config['database']
_radiusd = _config['radiusd']
# init args
if args.authport:_radiusd['authport'] = args.authport
if args.acctport:_radiusd['acctport'] = args.acctport
if args.adminport:_radiusd['adminport'] = args.adminport
if args.dictfile:_radiusd['dictfile'] = args.dictfile
if args.debug:_radiusd['debug'] = bool(args.debug)
#init dbconfig
settings.db_config.update(**_config)
store.__cache_timeout__ = _radiusd['cache_timeout']
# start logging
log.startLogging(sys.stdout)
_trace = UserTrace()
_runstat = statistics.RunStat()
_middleware = middleware.Middleware()
_debug = _radiusd['debug'] or settings.debug
# init coa clients
_coa_clients = {}
for bas in store.list_bas():
_coa_clients[bas['ip_addr']] = CoAClient(
bas,dictionary.Dictionary(_radiusd['dictfile']),debug=_debug)
def start_servers():
auth_protocol = RADIUSAccess(
dict=_radiusd['dictfile'],trace=_trace,midware=_middleware,
runstat=_runstat,debug=_debug
)
acct_protocol = RADIUSAccounting(
dict=_radiusd['dictfile'],trace=_trace,midware=_middleware,
runstat=_runstat,debug=_debug
)
reactor.listenUDP(_radiusd['authport'], auth_protocol)
reactor.listenUDP(_radiusd['acctport'], acct_protocol)
_task = task.LoopingCall(auth_protocol.process_delay)
_task.start(2.7)
from autobahn.twisted.websocket import WebSocketServerFactory
factory = WebSocketServerFactory("ws://0.0.0.0:%s"%args.adminport, debug = False)
factory.protocol = AdminServerProtocol
factory.protocol.user_trace = _trace
factory.protocol.midware = _middleware
factory.protocol.runstat = _runstat
factory.protocol.coa_clients = _coa_clients
reactor.listenTCP(_radiusd['adminport'], factory)
start_servers()
reactor.run()
