def onConnect():
if not options['noshell']:
conn.openChannel(SSHSession())
if options.localForwards:
for localPort, hostport in options.localForwards:
reactor.listenTCP(localPort,
forwarding.SSHListenForwardingFactory(conn,
hostport,
SSHListenClientForwardingChannel))
if options.remoteForwards:
for remotePort, hostport in options.remoteForwards:
log.msg('asking for remote forwarding for %s:%s' %
(remotePort, hostport))
data = forwarding.packGlobal_tcpip_forward(
('0.0.0.0', remotePort))
d = conn.sendGlobalRequest('tcpip-forward', data)
conn.remoteForwards[remotePort] = hostport
if options['fork']:
if os.fork():
os._exit(0)
os.setsid()
for i in range(3):
try:
os.close(i)
except OSError, e:
import errno
if e.errno != errno.EBADF:
raise
def start(self): self.zeroconf.publish() try: self.atconn = reactor.listenTCP(AIRTUNES_PORT, self.atsite, interface="::") except Exception: print "[SIFTeam OpenAirPlay] cannot bind airtunes server on ipv6 interface" self.atconn = None if self.atconn is None: try: self.atconn = reactor.listenTCP(AIRTUNES_PORT, self.atsite) except Exception: self.atconn = None self.apconn = None print "[SIFTeam OpenAirPlay] cannot start airtunes server" return try: self.apconn = reactor.listenTCP(AIRPLAY_PORT, self.apsite, interface="::") except Exception: print "[SIFTeam OpenAirPlay] cannot bind airplay server on ipv6 interface" self.apconn = None if self.apconn is None: try: self.apconn = reactor.listenTCP(AIRPLAY_PORT, self.apsite) except Exception: self.atconn.stopListening() self.atconn = None self.apconn = None print "[SIFTeam OpenAirPlay] cannot start airplay server" return print "[SIFTeam OpenAirPlay] server started"
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 __init__(self, password = None, port = 9000):
'''
Creates and Agent instance and attemps to connect
to the AgentMaster. If connection works the Client Hello message
is sent.
@type password: string
@param password: Password to use
'''
from twisted.internet import reactor
agent = AgentXmlRpc()
agent._password = password
agent._monitors = []
agent._publishers = {}
agent._id = None
print "] Peach Agent\n"
if agent._password != None:
print "\n //-> Listening on [%s] with password [%s]\n" % (port, agent._password)
else:
print "\n //-> Listening on [%s] with no password\n" % (port)
reactor.listenTCP(port, server.Site(agent))
reactor.run()
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(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 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 _testServerStartStop(self, ignored, f, p1):
self.assertEquals((f.started, f.stopped), (1,0))
# listen on two more ports
p2 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n2 = p2.getHost().port
self.ports.append(p2)
p3 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n3 = p3.getHost().port
self.ports.append(p3)
d = loopUntil(lambda :(p2.connected == 1 and p3.connected == 1))
def cleanup(x):
self.assertEquals((f.started, f.stopped), (1, 0))
# close two ports
d1 = defer.maybeDeferred(p1.stopListening)
d2 = defer.maybeDeferred(p2.stopListening)
return defer.gatherResults([d1, d2])
def assert1(ignored):
self.assertEquals((f.started, f.stopped), (1, 0))
return p3.stopListening()
def assert2(ignored):
self.assertEquals((f.started, f.stopped), (1, 1))
return self.cleanPorts(*self.ports)
d.addCallback(cleanup)
d.addCallback(assert1)
d.addCallback(assert2)
return d
def init_api(self):
log.msg('Starting HTTP on %s...' % self.interface)
root = resource.Resource()
root.putChild("send", APISendResource(self))
site = server.Site(root, logPath='/dev/null')
host, port = self.interface.split(':')
reactor.listenTCP(int(port), site, interface=host)
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 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 createForwardServer(self, session): from twisted.internet import reactor server_factory = forwardServerFactory(session, self) rndm = self.randomPort() reactor.listenTCP(rndm, server_factory) print 'listening at:',rndm return rndm
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 init_tests(self):
""" Initialize testing infrastructure - sockets, resource limits, etc. """
# Init Twisted factory.
self.server_factory = network.TestServerFactory(controller = self)
#self.client_factory = TestClientFactory(controller = self)
ports = sorted(self.test_ports)
log.notice("Binding to test ports: %s", ", ".join(map(str, ports)))
# Sort to try privileged ports first, since sets have no
# guaranteed ordering.
for port in ports:
reactor.listenTCP(port, self.server_factory)
# Set RLIMIT_NOFILE to its hard limit; we want to be able to
# use as many file descriptors as the system will allow.
# NOTE: Your soft/hard limits are inherited from the root user!
# The root user does NOT always have unlimited file descriptors.
# Take this into account when editing /etc/security/limits.conf.
(soft, hard) = resource.getrlimit(resource.RLIMIT_NOFILE)
log.verbose1("RLIMIT_NOFILE: soft = %d, hard = %d", soft, hard)
if soft < hard:
log.debug("Increasing RLIMIT_NOFILE soft limit to %d.", hard)
resource.setrlimit(resource.RLIMIT_NOFILE, (hard, hard))
log.debug("Initializing test threads.")
# TODO: Configure me!
scheduler_class = getattr(scheduler, config.scheduler)
self.scheduler = scheduler_class(controller = self,
max_pending_factor = config.max_pending_factor,
export_interval = config.export_interval)
T = threading.Thread
self.schedule_thread = T(target = Controller.test_schedule_thread,
name = "Scheduler", args = (self,))
self.watchdog_thread = T(target = Controller.watchdog,
name = "Watchdog", args = (self,))
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 __init__(self):
# create a Command Queue, Client Manager, and Default Data Context
self.commandQueue=CommandQueue()
self.clientManager=ClientManager()
self.dataContexts={'default':DataContext('default')}
# create a TCP socket listener (called a factory by twisted)
self.listener=GlabServerFactory()
self.listener.parent=self
# associate the CommandProtocol as a response method on that socket
self.listener.protocol=CommandProtocol
# tell the twisted reactor what port to listen on, and which factory to use for response protocols
global port
reactor.listenTCP(port, self.listener)
def hello(): print 'Listening on port', port
reactor.callWhenRunning(hello)
# associate the Command Queue and ClienManager with the socket listener
self.listener.associateCommandQueue(self.commandQueue)
self.listener.associateClientManager(self.clientManager)
# create a periodic command queue execution
self.queueCommand=task.LoopingCall(self.commandQueue.popexecute)
self.queueCommand.start(0.03)
self.initdisplay()
#self.refreshdisplay=task.LoopingCall(self.display.refresh)
#self.refreshdisplay.start(0.5)
# run the main response loop through twisted framework
reactor.run()
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_address = listener_config.get("bind_address", "")
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(self)
elif name == "federation":
resources.update({
FEDERATION_PREFIX: TransportLayerServer(self),
})
root_resource = create_resource_tree(resources, Resource())
reactor.listenTCP(
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag,),
site_tag,
listener_config,
root_resource,
),
interface=bind_address
)
logger.info("Synapse federation reader now listening on port %d", port)
def main(args):
parent = map(Proxy, args.parent_url)
aux_urls = args.aux_urls or ['http://*****:*****@127.0.0.1:8342/']
auxs = [Proxy(url) for url in aux_urls]
if args.merkle_size is None:
for i in range(8):
if (1<<i) > len(aux_urls):
args.merkle_size = i
logger.info('merkle size = %d', i)
break
if len(aux_urls) > args.merkle_size:
raise ValueError('the merkle size must be at least as large as the number of aux chains')
if args.merkle_size > 1 and not have_merkletree:
raise ValueError('Missing merkletree module. Only a single subchain will work.')
if args.pidfile:
pidfile = open(args.pidfile, 'w')
pidfile.write(str(os.getpid()))
pidfile.close()
listener = Listener(parent, auxs, args.merkle_size, args.rewrite_target)
listener.update_aux_process()
reactor.listenTCP(args.worker_port, server.Site(listener))
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "hp:ndv", ["help", "port=", "no-server", "debug", "version"])
except getopt.GetoptError:
print_help()
server = True
for o, a in opts:
if o in ("-h", "--help"):
print_help()
if o in ("-d", "--debug"):
g_display.window.set_title('Session Exchange: Debug Mode')
g_data.debug_mode = True
if o in ("-p", "--port"):
g_data.port = int(a)
if o in ("-n", "--no-server"):
server = False
if o in ("-v", "--version"):
print VERSION
sys.exit(2)
if (server):
try:
reactor.listenTCP(g_data.port, ExchangeServerFactory())
except twisted.internet.error.CannotListenError:
print "Can not listen on a port number under 1024 unless run as root"
sys.exit(2)
reactor.run()
g_data.close()
def run(self):
self.factory = get_factory(WebSocketServerFactory)("ws://0.0.0.0:%i" % self.port, debug=False)
self.factory.protocol = get_protocol(WebSocketServerProtocol)
reactor.listenTCP(self.port, self.factory)
reactor.callInThread(self.backend_reader)
reactor.callLater(1, self.keepalive_sender)
reactor.run()
def __init__(self, config, port=None):
super(IdentityServer, self).__init__(config)
self.plugin_mapping = config["plugin_mapping"]
self.setupMySQL(config)
self.setupIdentityQueue(config)
self.cassandra_cf_identity = config["cassandra_cf_identity"]
self.cassandra_cf_connections = config["cassandra_cf_connections"]
self.cassandra_cf_recommendations = config["cassandra_cf_recommendations"]
self.cassandra_cf_reverse_recommendations = config["cassandra_cf_reverse_recommendations"]
self.cassandra_client = CassandraClusterPool(
config["cassandra_servers"],
keyspace=config["cassandra_keyspace"],
pool_size=len(config["cassandra_servers"]) * 2)
self.cassandra_client.startService()
resource = Resource()
self.function_resource = Resource()
resource.putChild("function", self.function_resource)
if port is None:
port = config["identity_server_port"]
self.site_port = reactor.listenTCP(port, server.Site(resource))
self.expose(self.updateConnections)
self.expose(self.updateAllConnections)
self.expose(self.updateAllIdentities)
self.expose(self.getRecommendations)
self.expose(self.getReverseRecommendations)
self.expose(self.updateIdentity)
# setup manhole
manhole_namespace = {
'service': self,
'globals': globals(),
}
reactor.listenTCP(config["manhole_identity_port"], self.getManholeFactory(manhole_namespace, admin=config["manhole_password"]))
def _setupDistribServer(self, child):
"""
Set up a resource on a distrib site using L{ResourcePublisher}.
@param child: The resource to publish using distrib.
@return: A tuple consisting of the host and port on which to contact
the created site.
"""
distribRoot = resource.Resource()
distribRoot.putChild("child", child)
distribSite = server.Site(distribRoot)
self.f1 = distribFactory = PBServerFactory(
distrib.ResourcePublisher(distribSite))
distribPort = reactor.listenTCP(
0, distribFactory, interface="127.0.0.1")
self.addCleanup(distribPort.stopListening)
addr = distribPort.getHost()
self.sub = mainRoot = distrib.ResourceSubscription(
addr.host, addr.port)
mainSite = server.Site(mainRoot)
mainPort = reactor.listenTCP(0, mainSite, interface="127.0.0.1")
self.addCleanup(mainPort.stopListening)
mainAddr = mainPort.getHost()
return mainPort, mainAddr
def do_listening(): print "Listening for sensors..." reactor.listenTCP(SENSORPORT, SensorFactory()) try: reactor.run(installSignalHandlers=0) except ReactorAlreadyRunning, e: pass
def init(args):
# hook events
if args["--kill"]:
s_events.gotRequest += kill
if args["--auth"]:
s_events.gotRequest += auth
if args["--inject"]:
c_events.gotResponseTree += inject
if args["--beef"]:
c_events.gotResponseTree += beef
if args["--cats"]:
c_events.gotResponseTree += cats
if args["--upsidedown"]:
c_events.gotResponseImage += upsidedown
# start servers
if args["--cats"] or args["--inject"]:
datafolder = os.path.join(os.path.dirname(__file__), "data")
reactor.listenTCP(FILEPORT, fileserver.Site( \
fileserver.Data(datafolder)))
log.info("starting file server on %s:%s" %(IP, FILEPORT))
if args["--beef"]:
Popen(["gnome-terminal", "-e", "./startbeef"])
log.info("starting beef server on %s" %BEEFPORT)
def startup_routine(self):
indexContent = False
yes = set(['', 'Y', 'y', 'Yes', 'yes', 'YES'])
no = set(['N', 'n', 'No', 'no', 'NO'])
index_on_startup = False
print("Type 'help' for help.")
while True:
print(">> ", end="")
user_input = str(raw_input())
if user_input == 'help': # Print available commands to user.
print()
print(" <command> - <description>")
print(" help - Help.")
print(" reset - Reset index database.")
print(" init - Index all articles from content service on startup.")
print(" start - Start service.")
print(" exit - Quit.")
print()
elif user_input == 'reset': # Clearing tables in the index database.
print("This will delete any existing data and reset the database.")
print("Are you sure you want to continue? [Y/n] ", end="")
while True:
user_input = str(raw_input())
if user_input in yes:
self.index_database.make_tables("wordfreq", {"articleid" : "VARCHAR", "word" : "VARCHAR", "frequency" : "INTEGER"}, "(articleid, word)")
print("Reset.")
break
else:
print("Abort.")
break
elif user_input == 'init': # Toggle on/off indexing on startup.
while True:
print("Do you want to index all the articles on startup? [Y/n] ", end="")
user_input = str(raw_input())
if user_input in yes:
index_on_startup = True
print("Indexing will begin on start.")
break
elif user_input in no:
print("Indexing will not begin on start.")
index_on_startup = False
break
else:
print("Abort.")
break
elif user_input == 'start': # Start indexing service.
print("Starting index service. Use Ctrl + c to quit.")
if index_on_startup:
host = self.get_service_ip(config.content_module_name)
self.index_all_articles(host)
reactor.listenTCP(config.server_port, server.Site(self))
reactor.run()
break
elif user_input == 'exit': # End program.
break
elif user_input == '': # Yes is default on return.
continue
else:
print(user_input + ": command not found")
continue
def run(**settings):
"""Start the application.
Parameters:
host: Interface to listen on. [default: 0.0.0.0]
port: TCP port to listen on. [default: 8888]
log: The log file to use, the default is sys.stdout.
base_handler: The class or factory for request handlers. The default
is cyclone.web.RequestHandler.
more_handlers: A regular list of tuples containing regex -> handler
All other parameters are passed directly to the `cyclone.web.Application`
constructor.
"""
port = settings.get("port", 8888)
interface = settings.get("host", "0.0.0.0")
log.startLogging(settings.pop("log", sys.stdout))
reactor.listenTCP(port, create_app(**settings), interface=interface)
reactor.run(installSignalHandlers = False)
def main(keys_path, username_get=None, gid=None, port=2022):
settings.username_get = username_get
settings.gid = gid
key_path = keys_path + '/id_rsa'
if not os.path.exists(key_path):
subprocess.check_call(['ssh-keygen', '-f', key_path,
'-t', 'rsa', '-N', ''])
with open(key_path) as privateBlobFile:
privateBlob = privateBlobFile.read()
privateKey = Key.fromString(data=privateBlob)
with open(key_path + '.pub') as publicBlobFile:
publicBlob = publicBlobFile.read()
publicKey = Key.fromString(data=publicBlob)
factory = SSHFactory()
factory.privateKeys = {'ssh-rsa': privateKey}
factory.publicKeys = {'ssh-rsa': publicKey}
factory.portal = Portal(KeyRealm())
factory.portal.registerChecker(KeyChecker())
reactor.listenTCP(port, factory)
reactor.run()
def splash_server(portnum, slots, network_manager, get_splash_proxy_factory=None,
js_profiles_path=None, disable_proxy=False, proxy_portnum=None):
from twisted.internet import reactor
from twisted.web.server import Site
from splash.resources import Root
from splash.pool import RenderPool
from twisted.python import log
slots = defaults.SLOTS if slots is None else slots
log.msg("slots=%s" % slots)
pool = RenderPool(
slots=slots,
network_manager=network_manager,
get_splash_proxy_factory=get_splash_proxy_factory,
js_profiles_path=js_profiles_path
)
# HTTP API
root = Root(pool)
factory = Site(root)
reactor.listenTCP(portnum, factory)
# HTTP Proxy
if disable_proxy is False:
from splash.proxy_server import SplashProxyFactory
splash_proxy_factory = SplashProxyFactory(pool)
proxy_portnum = defaults.PROXY_PORT if proxy_portnum is None else proxy_portnum
reactor.listenTCP(proxy_portnum, splash_proxy_factory)
def __init__(self, save_dir=".",
listen_port=6881,
enable_DHT=False,
remote_debugging=False):
"""
@param remote_degugging enables telnet login via port 9999 with a
username and password of 'admin'
"""
log.startLogging(sys.stdout) # Start logging to stdout
self.save_dir = save_dir
self.listen_port = listen_port
self.enable_DHT = enable_DHT
self.tasks = {}
self.btServer = BTServerFactories(self.listen_port)
reactor.listenTCP(self.listen_port, self.btServer)
if enable_DHT:
log.msg("Turning DHT on.")
self.dht = DHTProtocol()
reactor.listenUDP(self.listen_port, self.dht)
if remote_debugging:
log.msg("Turning remote debugging on. You may login via telnet " +\
"on port 9999 username & password are 'admin'")
import twisted.manhole.telnet
dbg = twisted.manhole.telnet.ShellFactory()
dbg.username = "******"
dbg.password = "******"
dbg.namespace['app'] = self
reactor.listenTCP(9999, dbg)
def GetworkProxy_main(cb):
log.info("Stratum proxy version %s Connecting to Pool..." % version.VERSION)
# Connect to Stratum pool
f = SocketTransportClientFactory(settings.HOSTNAME, settings.LISTEN_SOCKET_TRANSPORT,
debug=False, proxy=None, event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f, cmd='', no_midstate=settings.GW_DISABLE_MIDSTATE, real_target=settings.GW_SEND_REAL_TARGET)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connects to the pool
yield f.on_connect
# Setup getwork listener
gw_site = Site(getwork_listener.Root(job_registry, workers,
stratum_host=settings.HOSTNAME, stratum_port=settings.LISTEN_SOCKET_TRANSPORT,
custom_lp=False, custom_stratum=False,
custom_user=False, custom_password=False
))
gw_site.noisy = False
reactor.listenTCP(settings.GW_PORT, gw_site, interface='0.0.0.0')
log.info("Getwork Proxy is online, Port: %d" % (settings.GW_PORT))
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from twisted.internet.defer import inlineCallbacks, returnValue
from klein import Klein
from autobahn.twisted.wamp import Application
app = Klein()
wampapp = Application()
@app.route('/square/submit', methods=['POST'])
@inlineCallbacks
def square_submit(request):
x = int(request.args.get('x', [0])[0])
res = yield wampapp.session.call(u'com.example.square', x)
returnValue("{} squared is {}".format(x, res))
if __name__ == "__main__":
import sys
from twisted.python import log
from twisted.web.server import Site
from twisted.internet import reactor
log.startLogging(sys.stdout)
reactor.listenTCP(8080, Site(app.resource()))
wampapp.run(u"ws://127.0.0.1:9000", u"realm1", standalone=False)
def main():
reactor.disconnectAll()
failover = False
if settings.POOL_FAILOVER_ENABLE:
failover = settings.failover_pool
settings.failover_pool = not settings.failover_pool
pool_host = settings.POOL_HOST
pool_port = settings.POOL_PORT
if failover and settings.POOL_FAILOVER_ENABLE:
pool_host = settings.POOL_HOST_FAILOVER
pool_port = settings.POOL_PORT_FAILOVER
log.warning("Monero Stratum proxy version: %s" % version.VERSION)
log.warning("Trying to connect to Stratum pool at %s:%d" %
(pool_host, pool_port))
# Connect to Stratum pool, main monitoring connection
f = SocketTransportClientFactory(
pool_host,
pool_port,
debug=settings.DEBUG,
proxy=None,
event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
f.on_connect.addCallback(on_connect)
f.on_disconnect.addCallback(on_disconnect)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connect to the pool
try:
yield f.on_connect
except TransportException:
log.warning(
"First pool server must be online first time to start failover")
return
# Setup stratum listener
stratum_listener.StratumProxyService._set_upstream_factory(f)
stratum_listener.StratumProxyService._set_custom_user(
settings.CUSTOM_USER, settings.CUSTOM_PASSWORD,
settings.ENABLE_WORKER_ID, settings.WORKER_ID_FROM_IP)
reactor.listenTCP(settings.STRATUM_PORT,
SocketTransportFactory(
debug=settings.DEBUG,
event_handler=ServiceEventHandler),
interface=settings.STRATUM_HOST)
# Setup multicast responder
reactor.listenMulticast(3333,
multicast_responder.MulticastResponder(
(pool_host, pool_port), settings.STRATUM_PORT),
listenMultiple=True)
log.warning(
"-----------------------------------------------------------------------"
)
if settings.STRATUM_HOST == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d (stratum)" %
settings.STRATUM_PORT)
else:
log.warning("LISTENING FOR MINERS ON stratum+tcp://%s:%d (stratum)" % \
(settings.STRATUM_HOST, settings.STRATUM_PORT))
log.warning(
"-----------------------------------------------------------------------"
)
#coding:utf8 from twisted.internet import reactor from syncplay.server import SyncFactory reactor.listenTCP(8999, SyncFactory()) reactor.run()
"""
Chat server
"""
from twisted.internet.protocol import Factory
from twisted.internet import reactor
from protocol import Chat
class ChatFactory(Factory):
"""
build chat protocol.
"""
def __init__(self):
"""
factory initialization.
"""
self.users = {}
def buildProtocol(self, addr):
"""
call Chat
"""
return Chat(self.users)
reactor.listenTCP(8123, ChatFactory())
reactor.run()
print("badsignature")
newtrans = transaction(
sender=payloaded["sender"],
senderwallet=wllt,
receiver=payloaded["receiver"],
prevblockhash=transaction.objects.all().last(
).blockhash,
blockhash=payloaded["blockhash"],
amount=Decimal(payloaded["amount"]),
nonce=payloaded["nonce"],
first_timestamp=payloaded["timestamp"],
P2PKH=payloaded["P2PKH"],
verification=True).save()
else:
print("other message")
BroadcastServerFactory.broadcast(payloaded)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
print("start")
ServerFactory = BroadcastServerFactory
factory = ServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = BroadcastServerProtocol
reactor.listenTCP(9000, factory)
reactor.run()
plugin_module = 'plugins.' + service_config.get(service, 'plugin')
plugin = importlib.import_module(plugin_module)
service_object = None
if args.d is False:
if int(low_port) < 1024:
if display_low_port_message:
print 'Your service configuration suggests that you want to run on at least one low port!'
print 'To enable port redirection run the following ipt-kit (https://github.com/foospidy/ipt-kit) commands as root:'
print ''
display_low_port_message = False
try:
if protocol.lower() == 'tcp':
# run tcp service
service_object = reactor.listenTCP(int(port), plugin.pluginFactory(service))
else:
# run udp service
service_object = reactor.listenUDP(int(port), plugin.pluginMain(service, get_ip_address(), port))
if service_object:
# stop services from listening immediately if not starting in daemon mode.
if args.d is False:
service_object.stopListening()
# save service objects to array, to be used by HoneyPy Console
services[0].append(service)
services[1].append(service_object)
except Exception as e:
print str(e) + '\n'
msg = ""
if command == "iam":
self.name = content
self.curr_clients[self.name] = self
msg = self.name + " has joined"
self.message(msg)
elif command == "msg":
msg = self.name + ": " + content
print msg
self.message(msg)
else:
if command in self.curr_clients:
self.curr_clients[command].message(self.name +": "+ content)
#for c in self.factory.clients:
# if self.currentCleint == c:
# print c
# c.message(msg)
def message(self, message):
self.transport.write(message + '\n')
factory = Factory()
factory.protocol = IphoneChat
factory.clients = []
factory.protocol.curr_clients = {}
reactor.listenTCP(80, factory)
print "Iphone Chat server started"
reactor.run()
def setUp(self):
xmlrpc = Test()
addIntrospection(xmlrpc)
self.p = reactor.listenTCP(0, server.Site(xmlrpc),interface="127.0.0.1")
self.port = self.p.getHost().port
self.factories = []
def setUp(self):
self.p = reactor.listenTCP(
0, server.Site(Test(allowNone=True)), interface="127.0.0.1")
self.port = self.p.getHost().port
def setUp(self):
self.resource = static.File(__file__)
self.resource.isLeaf = True
self.port = reactor.listenTCP(0, server.Site(self.resource),
interface='127.0.0.1')
log.msg("Received response from proxied service: " + repr(response))
return defer.succeed(response)
if __name__ == '__main__':
"""
Demonstration LDAP proxy; listens on localhost:10389; passes all requests
to localhost:8080 and logs responses..
"""
from ldaptor.protocols.ldap.ldapclient import LDAPClient
from twisted.internet import protocol, reactor
from functools import partial
import sys
log.startLogging(sys.stderr)
factory = protocol.ServerFactory()
proxiedEndpointStr = 'tcp:host=localhost:port=8080'
use_tls = False
clientConnector = partial(ldapconnector.connectToLDAPEndpoint, reactor,
proxiedEndpointStr, LDAPClient)
def buildProtocol():
proto = ExampleProxy()
proto.clientConnector = clientConnector
proto.use_tls = use_tls
return proto
factory.protocol = buildProtocol
reactor.listenTCP(10389, factory)
reactor.run()
def setUp(self):
self.p = reactor.listenTCP(0, server.Site(TestAuthHeader()),
interface="127.0.0.1")
self.port = self.p.getHost().port
self.factories = []
from twisted.spread import pb
from twisted.internet import reactor
class Two(pb.Referenceable):
def remote_print(self, arg):
print("two.print was given", arg)
class One(pb.Root):
def __init__(self, two):
# pb.Root.__init__(self) # pb.Root doesn't implement __init__
self.two = two
def remote_getTwo(self):
print("One.getTwo(), returning my two called", self.two)
return self.two
def remote_checkTwo(self, newtwo):
print("One.checkTwo(): comparing my two", self.two)
print("One.checkTwo(): against your two", newtwo)
if self.two == newtwo:
print("One.checkTwo(): our twos are the same")
two = Two()
root_obj = One(two)
reactor.listenTCP(8800, pb.PBServerFactory(root_obj))
reactor.run()
def start(self):
site = server.Site(self)
reactor.listenTCP(7000, site)
return reactor.run()
def pluginReactor(self, strippingFactory):
reactor.listenTCP(3141, strippingFactory)
from twisted.internet import protocol, reactor
from time import ctime
PORT = 2345
class TSServProtocol(protocol.Protocol):
def connectionMade(self):
clnt = self.clnt = self.transport.getPeer().host
print('...connected from:', clnt)
def dataReceived(self, data):
self.transport.write(ctime().encode())
factory = protocol.Factory()
factory.protocol = TSServProtocol
print('waiting for connection...')
reactor.listenTCP(PORT, factory)
reactor.run()
"""Authentication/authorization backend using the 'login' PAM service"""
credentialInterfaces = IUsernamePassword,
implements(ICredentialsChecker)
def requestAvatarId(self, credentials):
if pam.authenticate(credentials.username, credentials.password):
return defer.succeed(credentials.username)
return defer.fail(UnauthorizedLogin("invalid password"))
class UnixSSHdFactory(factory.SSHFactory):
publicKeys = {'ssh-rsa': keys.Key.fromString(data=publicKey)}
privateKeys = {'ssh-rsa': keys.Key.fromString(data=privateKey)}
services = {
'ssh-userauth': userauth.SSHUserAuthServer,
'ssh-connection': connection.SSHConnection
}
# Components have already been registered in twisted.conch.unix
portal = portal.Portal(UnixSSHRealm())
portal.registerChecker(PamPasswordDatabase()) # Supports PAM
portal.registerChecker(SSHPublicKeyDatabase()) # Supports PKI
UnixSSHdFactory.portal = portal
if __name__ == '__main__':
reactor.listenTCP(5022, UnixSSHdFactory())
reactor.run()
if self.authenticate(credentials[0], credentials[1]):
print "Permission granted"
command = 'su %s -c "%s"' % ("david", command)
print "Running: %s" % command
process = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
out, nothing = process.communicate()
print out
#return the result
self.transport.write(out)
else:
print "Permission denied"
self.transport.write("Permission denied")
class ImpersonateFactory(Factory):
def __init__(self, venv=None):
self.key = "cL7eNdb3yJCkw1zlvizrZuUdbplTmsFD"
def buildProtocol(self, addr):
return Impersonate(self)
reactor.listenTCP(8123, ImpersonateFactory(sys.argv[1]))
reactor.run()
def start(self):
self._listener = reactor.listenTCP(GeneralConfig.http_port, self._site)
def send(self, message):
self.remote.callRemote("print", message)
class Group(pb.Viewable):
def __init__(self, groupname, allowMattress):
self.name = groupname
self.allowMattress = allowMattress
self.users = []
def addUser(self, user):
self.users.append(user)
def view_send(self, from_user, message):
if not self.allowMattress and "mattress" in message:
raise ValueError, "Don't say that word"
for user in self.users:
user.send("<%s> says: %s" % (from_user.name, message))
realm = ChatRealm()
realm.server = ChatServer()
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
checker.addUser("alice", "1234")
checker.addUser("bob", "secret")
checker.addUser("carol", "fido")
p = portal.Portal(realm, [checker])
reactor.listenTCP(8800, pb.PBServerFactory(p))
reactor.run()
if f3:
f3.on_connect.addCallback(on_connect)
f3.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f3)
# Block until proxy connect to the pool
try:
yield f.on_connect
except TransportException:
log.warning("First pool server must be online first time during start")
return
conn = reactor.listenTCP(settings.PORT, Site(getwork_listener.Root(job_registry, settings.ENABLE_WORKER_ID)), interface=settings.HOST)
try:
conn.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # Enable keepalive packets
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 60) # Seconds before sending keepalive probes
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, 1) # Interval in seconds between keepalive probes
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, 5) # Failed keepalive probles before declaring other end dead
except:
pass # Some socket features are not available on all platforms (you can guess which one)
log.warning("-----------------------------------------------------------------------")
if settings.HOST == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d" % settings.PORT)
else:
log.warning("LISTENING FOR MINERS ON http://%s:%d" % (settings.HOST, settings.PORT))
log.warning("-----------------------------------------------------------------------")
ilsc.init_database()
appBackend.init_schedulers()
scheduler.add_job(appBackend.cleanup_everything, 'cron', id=f"leon_der_profi", hour=appConfig.app['cleancron'], minute=0)
scheduler.start()
if appConfig.app['cleanonstart']:
appBackend.checkout_all()
appBackend.cleanup_everything()
#appBackend.inject_random_userdata()#just for testing
try:
if appConfig.http['usessl']:
priv = appConfig.http['serverpriv']
cacert = appConfig.http['servercacert']
certdata = ssl.DefaultOpenSSLContextFactory(priv, cacert)
reactor.listenSSL(appConfig.http['port'], Site(WSGIResource(reactor, reactor.getThreadPool(), flaskApp)),certdata)
reactor.listenSSL(appConfig.websocket['port'], appBackend.get_websocket_site(),certdata)
else:
reactor.listenTCP(appConfig.http['port'], Site(WSGIResource(reactor, reactor.getThreadPool(), flaskApp)))
reactor.listenTCP(appConfig.websocket['port'], appBackend.get_websocket_site())
except Exception as e:
logging.warning(str(e))
print(e)
if __name__ == "__main__":
try:
reactor.run()
except Exception as e:
logging.warning(str(e))
print(e)
close = zdefs.Close ()
close.closeReason = zdefs.CloseReason.get_num_from_name (
'responseToPeer')
self.send_PDU ('close', close)
self.transport.loseConnection ()
if __name__ == '__main__':
if 0:
from PyZ3950 import z3950
print rpn_q_to_amazon (
('type_1', z3950.mk_simple_query ('Among the gently mad')))
print rpn_q_to_amazon (('type_1', z3950.mk_compound_query ()))
else:
amazon.setLicense (amazon.getLicense ())
factory = protocol.Factory ()
factory.protocol = Z3950Server
reactor.listenTCP (2100, factory)
reactor.run ()
log.startLogging(sys.stdout)
##
# create a Twisted Web resource for our WebSocket server
##
wsFactory = WebSocketServerFactory(u"ws://127.0.0.1:8080",
debug=debug,
debugCodePaths=debug)
wsFactory.protocol = EchoServerProtocol
wsResource = WebSocketResource(wsFactory)
##
# create a Twisted Web WSGI resource for our Flask server
##
wsgiResource = WSGIResource(reactor, reactor.getThreadPool(), app)
##
# create a root resource serving everything via WSGI/Flask, but
# the path "/ws" served by our WebSocket stuff
##
rootResource = WSGIRootResource(wsgiResource, {'ws': wsResource})
##
# create a Twisted Web Site and run everything
##
site = Site(rootResource)
reactor.listenTCP(8080, site)
reactor.run()
def esc_markup(msg):
return (msg.replace('&', '&').replace('[', '&bl;').replace(']', '&br'))
class Chat(protocol.Protocol):
def connectionMade(self):
self.color = colors.pop()
colors.insert(0, self.color)
def dataReceived(self, data):
transports.add(self.transport)
if ':' not in data:
return
user, msg = data.split(':', 1)
for t in transports:
if t is not self.transport:
t.write('[b][color={}]{}:[/color][/b]{}'.format(
self.color, user, esc_markup(msg)))
class ChatFactory(protocol.Factory):
def buildProtocol(self, addr):
return Chat()
reactor.listenTCP(9096, ChatFactory())
reactor.run()
print 'Connecting to %s:%s' % (dest_addr, dest_port)
reactor.connectTCP(dest_addr, dest_port,
RemoteFactory(self.session))
self.buf = self.buf[self.data_len:]
self.data_len = 0
self.stage = 2
else:
self.session.recv_seqcache.put(
self.data_seq, self.buf[:self.data_len])
#print 'red a seq '+ str(self.data_seq) + ' ' + str(len(self.buf[:self.data_len]))
self.buf = self.buf[self.data_len:]
self.data_len = 0
self.session.send_to_remote()
else:
break
def sendData(self, data):
self.transport.write(data)
class ServerFactory(ServerFactory):
def __init__(self):
self.dct_session = {}
def buildProtocol(self, addr):
return Server(self.dct_session)
reactor.listenTCP(config.SERVER_PORT, ServerFactory())
reactor.run()
def seleccionarPuertoParaCrear(ventana, letra):
global volverAlMenuUnirseRED
pygame.init()
pygame.display.set_caption('Ta-Te-Ti de Carlitos')
ventana = pygame.display.set_mode((800, 600))
pygame.key.set_repeat(150, 50)
fuenteParaMenu = pygame.font.Font('bibliottt/AtoZ.ttf', 40)
opcionMenu = [
Opcion('Menu', (650, 540), 'menu', funcionParaSalirAlMenuCrearRED,
fuenteParaMenu, ventana)
]
fuenteInput = pygame.font.Font(None, 40)
inputTexto = pygame.Rect(209, 300, 250, 40)
color = pygame.Color(250, 0, 0)
cantidadMaximaDigitos = int(5)
texto = 'Ej: 25000 o 8484'
IPSERVENT = get_lan_ip()
puertoEscuchado = None
volverAlMenuUnirseRED = False
while not volverAlMenuUnirseRED:
if len(texto) is 0:
texto = 'Ej: 25000 o 8484'
evento = pygame.event.get()
#print len(texto)
for e in evento:
if e.type == pygame.QUIT:
try:
reactor.stop()
except:
pass
os._exit(0)
if e.type == pygame.KEYDOWN:
if texto is 'Ej: 25000 o 8484':
texto = ''
if e.key == pygame.K_RETURN:
try:
puertoEscuchado = reactor.listenTCP(
int(texto), Fabrica())
banderaDePuerto = True
except Exception as e:
banderaDePuerto = False
print e
if banderaDePuerto:
volverAlMenuUnirseRED = SERVENTATETI(ventana, letra)
texto = ''
elif e.key == pygame.K_BACKSPACE:
texto = texto[:-1]
else:
if len(texto) < cantidadMaximaDigitos and\
e.unicode in '0 1 2 3 4 5 6 7 8 9 . :'.split():
texto += e.unicode
try:
puertoEscuchado.stopListening()
except:
pass
ventana.fill(colorGris)
fuenteParaUnirse = pygame.font.Font('bibliottt/AtoZ.ttf', 24)
textoUnirseAUnaPartidaUNO = 'escriba el puerto en el que'
textoUnirseAUnaPartidaFFUNO = fuenteParaUnirse.render(
textoUnirseAUnaPartidaUNO, True, colorRojo)
ventana.blit(textoUnirseAUnaPartidaFFUNO, (209, 200))
textoUnirseAUnaPartidaDOS = 'quiere crear su servidor de tateti'
textoUnirseAUnaPartidaFFDOS = fuenteParaUnirse.render(
textoUnirseAUnaPartidaDOS, True, colorRojo)
ventana.blit(textoUnirseAUnaPartidaFFDOS, (209, 230))
fuenteParaUnirseDOS = pygame.font.Font(None, 24)
textoUnirseAUnaPartidaTRES = '(1024<puerto<65535, si el puerto esta siendo utilizado intente con otro)'
textoUnirseAUnaPartidaTRES = fuenteParaUnirseDOS.render(
textoUnirseAUnaPartidaTRES, True, colorRojo)
ventana.blit(textoUnirseAUnaPartidaTRES, (209, 260))
fuenteParaTextoIp = pygame.font.Font(None, 24)
textoSobreIP = 'Tu ip local es: ' + str(IPSERVENT)
textoSobreIP = fuenteParaTextoIp.render(textoSobreIP, True, colorRojo)
ventana.blit(textoSobreIP, (209, 400))
# me quedé acá
if texto is 'Ej: 25000 o 8484':
superficieTexto = fuenteInput.render(texto, True, colorPlaceholder)
else:
superficieTexto = fuenteInput.render(texto, True, color)
widthMaxTexto = int(250)
inputTexto.w = widthMaxTexto
ventana.blit(superficieTexto, (inputTexto.x + 4, inputTexto.y + 8))
pygame.draw.rect(ventana, color, inputTexto, 3)
for o in opcionMenu:
if o.rect.collidepoint(pygame.mouse.get_pos()):
o.hover = True
if pygame.mouse.get_pressed()[0]:
o.funcion(ventana)
volverAlMenuUnirseRED = True
else:
o.hover = False
o.imprimir()
pygame.display.flip()
return True
"""
self.clients = [] # создаем пустой список клиентов
self.messages = []
print("*" * 10, "Server started - [OK]",
"*" * 10) # уведомление в консоль сервера
def startFactory(self):
"""Запуск прослушивания клиентов (уведомление в консоль)"""
print("[ * ] Start listening ...") # уведомление в консоль сервера
def notify_all_users(self, message: str):
"""
Отправка сообщения всем клиентам чата
:param message: Текст сообщения
"""
data = message.encode() # закодируем текст в двоичное представление
# отправим всем подключенным клиентам
for user in self.clients:
user.sendLine(data)
if __name__ == '__main__':
# параметры прослушивания
reactor.listenTCP(7410, Server())
# запускаем реактор
reactor.run()
clientFactory = class_(self.method, rest, self.clientproto, headers, s, self)
# if self.uri == 'http://music.163.com/eapi/song/like':
# print rest, headers, s
# if self.uri == 'http://music.163.com/eapi/v1/playlist/manipulate/tracks':
# print rest, headers, s
return host, port, clientFactory
def process(self):
if self.uri == 'music.163.com:443':
print('DEBUG: Abort on request: ' + self.uri)
self.channel._respondToBadRequestAndDisconnect()
return
host, port, clientFactory = self.process_prepare()
if self.uri == 'http://music.163.com/eapi/song/enhance/player/url':
print('request intercepted: ' + self.uri)
#mainland_proxy.set_to_default()
mainland_proxy.status = -1
self.reactor.connectTCP(mainland_proxy.ip, mainland_proxy.port, clientFactory)
return
self.reactor.connectTCP(host, port, clientFactory)
class NeteaseMusicProxy(proxy.Proxy):
requestFactory = NeteaseMusicProxyRequest
class NeteaseMusicProxyFactory(http.HTTPFactory):
protocol = NeteaseMusicProxy
mainland_proxy = MainlandProxy()
reactor.listenTCP(32794, NeteaseMusicProxyFactory())
reactor.run()
class MyRequestHandler(http.Request):
pages = {
'/': '<h1>Home</h1>Home page',
'/test': '<h1>Test</h1>Test page',
}
def process(self):
if self.pages.has_key(self.path):
self.write(self.pages[self.path])
else:
self.setResponseCode(http.NOT_FOUND)
self.write(
"<h1>Not Found</h1>Sorry, no such page.")
self.finish()
class MyHttp(http.HTTPChannel):
requestFactory = MyRequestHandler
class MyHttpFactory(http.HTTPFactory):
protocol = MyHttp
if __name__ == "__main__":
from twisted.internet import reactor
reactor.listenTCP(8000, MyHttpFactory())
reactor.run()
