def __init__(self, port, coherence, unittests=False): log.LogAble.__init__(self) self.coherence = coherence from coherence.web.ui import Web, IWeb, WebUI from twisted.web import server, resource from twisted.python.components import registerAdapter def resource_factory(original): return WebUI(IWeb, original) registerAdapter(resource_factory, Web, resource.IResource) self.web_root_resource = WebUI(coherence) if not unittests: site_cls = server.Site else: from tests.web_utils import DummySite site_cls = DummySite self.site = site_cls(self.web_root_resource) self.endpoint = endpoints.TCP4ServerEndpoint(reactor, port) self._endpoint_listen(coherence, port) self.ws_endpoint = endpoints.TCP4ServerEndpoint(reactor, 9000) self._ws_endpoint_listen(coherence)
def main(): log_file = logfile.LogFile.fromFullPath('log/serverlog.log') log.addObserver(log.FileLogObserver(log_file).emit) print("===== PSO2Proxy vGIT %s =====" % config.proxy_ver) time_string = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) print("[ServerStart] Trying to start server at %s" % time_string) if myIp == "0.0.0.0": print("==== ERROR 001 ====") print("You have NOT configured the IP address for PSO2Proxy!") print( "Please edit cfg/pso2proxy.config.yml and change myIpAddr to your IP public IP address " "(Not LAN address if you're on a LAN!) ") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) if bindIp == "0.0.0.0": interface_ip = myIp else: interface_ip = bindIp if not os.path.isfile("keys/myKey.pem"): print("==== ERROR 002 ====") print("You do NOT have your local RSA private key installed to 'keys/myKey.pem'!") print("Please see README.md's section on RSA keys for more information.") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) if not os.path.isfile("keys/SEGAKey.pem"): print("==== ERROR 003 ====") print("You do NOT have a SEGA RSA public key installed to 'keys/SEGAKey.pem'!") print("Please see README.md's section on RSA keys for more information.") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) for shipNum in range(0, 10): # PSO2 Checks all ships round robin, so sadly for max compatibility we have to open these no matter what ships are enabled... ship_endpoint = endpoints.TCP4ServerEndpoint(reactor, 12099 + (100 * shipNum), interface=interface_ip) ship_endpoint.listen(ShipAdvertiserFactory()) for shipNum in config.globalConfig.get_key('enabledShips'): query_endpoint = endpoints.TCP4ServerEndpoint(reactor, 12000 + (100 * shipNum), interface=interface_ip) query_endpoint.listen(BlockScraperFactory()) print("[ShipProxy] Bound port %i for ship %i query server!" % ((12000 + (100 * shipNum)), shipNum)) query_endpoint = endpoints.TCP4ServerEndpoint(reactor, 13000, interface=interface_ip) query_endpoint.listen(BlockScraperFactory()) stdio.StandardIO(ServerConsole()) print("[ShipProxy] Loading plugins...") import glob for plug in glob.glob("plugins/*.py"): plug = plug[:-3] plug = plug.replace(os.sep, '.') print("[ShipProxy] Importing %s..." % plug) __import__(plug) for f in plugin_manager.onStart: f() reactor.suggestThreadPoolSize(30) reactor.run() data.clients.dbManager.close_db() for f in plugin_manager.onStop: f()
def my_room_info_packet(context, data): data = bytearray(data) o1, o2, o3, o4 = struct.unpack_from('BBBB', buffer(data), 0x20) ip_string = "%i.%i.%i.%i" % (o1, o2, o3, o4) port = struct.unpack_from('H', buffer(data), 0x28)[0] if port not in blocks.blockList: if verbose: print("[BlockPacket] Discovered a 'My Room' block at %s:%i!" % (ip_string, port)) blocks.blockList[port] = (ip_string, "My Room", port) if port not in blocks.listeningPorts: from ShipProxy import ProxyFactory if bindIp == "0.0.0.0": interface_ip = myIp else: interface_ip = bindIp block_endpoint = endpoints.TCP4ServerEndpoint(reactor, port, interface=interface_ip) block_endpoint.listen(ProxyFactory()) print("[ShipProxy] Opened listen socked on port %i for new ship." % port) blocks.listeningPorts.append(port) struct.pack_into('BBBB', data, 0x20, int(i0), int(i1), int(i2), int(i3)) context.peer.changingBlocks = True return str(data)
def _toEndpoint(description, certificate=None): """ Create an endpoint based on a description. @type description: L{bytes} @param description: An endpoint description string or a TCP port number. @type certificate: L{bytes} or L{None} @param certificate: The name of a file containing an SSL certificate. @rtype: L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} provider @return: An endpoint. """ from twisted.internet import reactor try: port = int(description) except ValueError: return endpoints.serverFromString(reactor, description) warnings.warn( "Specifying plain ports and/or a certificate is deprecated since " "Twisted 11.0; use endpoint descriptions instead.", category=DeprecationWarning, stacklevel=3) if certificate: from twisted.internet.ssl import DefaultOpenSSLContextFactory ctx = DefaultOpenSSLContextFactory(certificate, certificate) return endpoints.SSL4ServerEndpoint(reactor, port, ctx) return endpoints.TCP4ServerEndpoint(reactor, port)
def block_reply_packet(context, data): data = bytearray(data) o1, o2, o3, o4 = struct.unpack_from('BBBB', buffer(data), 0x14) ip_string = "%i.%i.%i.%i" % (o1, o2, o3, o4) struct.pack_into('BBBB', data, 0x14, int(i0), int(i1), int(i2), int(i3)) port = struct.unpack_from("H", buffer(data), 0x18)[0] if context.peer.transport.getHost().port > 12999: port += 1000 struct.pack_into("H", data, (0x14 + 0x04), port) if port not in blocks.blockList: blocks.blockList[port] = (ip_string, "PVP Arena", port) #not really sure if it's proper way if port in blocks.blockList and port not in blocks.listeningPorts: from ShipProxy import ProxyFactory if bindIp == "0.0.0.0": interface_ip = myIp else: interface_ip = bindIp block_endpoint = endpoints.TCP4ServerEndpoint(reactor, port, interface=interface_ip) block_endpoint.listen(ProxyFactory()) print("[ShipProxy] Opened listen socked on port %i for new ship." % port) blocks.listeningPorts.append(port) if verbose: print("[ShipProxy] rewriting block ip address in query response.") context.peer.changingBlocks = True return str(data)
def main(): """ start up twisted reactor """ parser = argparse.ArgumentParser( description='VMWare metrics exporter for Prometheus') parser.add_argument('-c', '--config', dest='config_file', default=None, help="configuration file") parser.add_argument('-p', '--port', dest='port', type=int, default=9272, help="HTTP port to expose metrics") args = parser.parse_args() # Start up the server to expose the metrics. root = VMWareMetricsResource() root.configure(args) root.putChild(b'metrics', VMWareMetricsResource()) root.putChild(b'healthz', VMWareMetricsResource()) factory = Site(root) log("Starting web server on port {}".format(args.port)) endpoint = endpoints.TCP4ServerEndpoint(reactor, args.port) endpoint.listen(factory) reactor.run()
def __init__(self, svr_host, svr_port, listen_host, listen_port): # Error checking: make sure that local_port is sane super(Qe2Client, self).__init__() self.uuid = uuid.uuid4().bytes self.svr_host = svr_host self.svr_port = svr_port # top_addr: the address we listen on for the app connection # self.top_addr = (listen_host, listen_port) # We don't have a top half yet. We'll get one when we accept # the connection from the app # self.top = None self.top_factory = Factory() self.top_factory.protocol = Qe2ClientTop self.top_factory.endpoint = self endpoint = endpoints.TCP4ServerEndpoint(reactor, listen_port, interface=listen_host) endpoint.listen(self.top_factory)
def _setup_relay(self, error, advertise_version=None): self.sp = service.MultiService() self.sp.startService() # need to talk to twisted team about only using unicode in # endpoints.serverFromString db = create_channel_db(":memory:") self._usage_db = create_usage_db(":memory:") self._rendezvous = make_server(db, advertise_version=advertise_version, signal_error=error, usage_db=self._usage_db) ep = endpoints.TCP4ServerEndpoint(reactor, 0, interface="127.0.0.1") site = make_web_server(self._rendezvous, log_requests=False) # self._lp = yield ep.listen(site) s = MyInternetService(ep, site) s.setServiceParent(self.sp) self.rdv_ws_port = yield s.getPort() self._relay_server = s # self._rendezvous = s._rendezvous self.relayurl = u"ws://127.0.0.1:%d/v1" % self.rdv_ws_port # ws://127.0.0.1:%d/wormhole-relay/ws self.transitport = allocate_tcp_port() ep = endpoints.serverFromString( reactor, "tcp:%d:interface=127.0.0.1" % self.transitport) self._transit_server = f = Transit(blur_usage=None, log_file=None, usage_db=None) internet.StreamServerEndpointService(ep, f).setServiceParent(self.sp) self.transit = u"tcp:127.0.0.1:%d" % self.transitport
def __init__(self): super().__init__() self.active = False self.factoryws = ToScreenFactory(self) self.protinst = None endpoint = endpoints.TCP4ServerEndpoint(reactor, 8000) endpoint.listen(self.factoryws)
def start_gui(interface4, port, mockdevices): import calvinextras import inspect import os.path from twisted.web.server import Site from twisted.web.static import File from twisted.internet import endpoints, reactor from calvin.utilities import calvinconfig # find installation path of calvinextras package extras_path = os.path.dirname(inspect.getfile(calvinextras)) # build path to gui files gui_path = os.path.join(extras_path, "CalvinGUI", "Build", "GUI") gui_config_path = os.path.join(extras_path, "CalvinGUI", "calvin.conf") if mockdevices: # Patch config _conf = calvinconfig.get() delta_config = _conf.config_at_path(gui_config_path) _conf.update_config(delta_config) # Add endpoint to twisted reactor resource = File(gui_path) factory = Site(resource) endpoint = endpoints.TCP4ServerEndpoint(reactor, interface=interface4, port=port) endpoint.listen(factory) _log.info("Calvin GUI server listening on http://{}:{}".format(interface4, port))
def main(argv=None): """ Main entry point. """ parser = ArgumentParser(description='vCD metrics exporter for Prometheus') parser.add_argument('-c', '--config', dest='config_file', default=None, help="configuration file") parser.add_argument('-p', '--port', dest='port', type=int, default=9274, help="HTTP port to expose metrics") args = parser.parse_args(argv or sys.argv[1:]) # Flag for improvements # reactor.suggestThreadPoolSize(25) root = Resource() root.putChild(b'healthz', HealthzResource()) root.putChild(b'metrics', MetricsResource()) root.putChild(b'vcd', VcdApplicationResource(args)) factory = Site(root) endpoint = endpoints.TCP4ServerEndpoint(reactor, args.port) endpoint.listen(factory) reactor.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('dir', nargs='?', default='.', help="the directory to serve") parser.add_argument('-p', '--port', type=int, default=8000, help="the port to listen on") parser.add_argument('-r', '--raw', type=str, nargs='?', const=None, default=argparse.SUPPRESS, help="the port to listen on") args = parser.parse_args() if 'raw' not in args: resource = DirPage(args.dir) dir = args.dir else: if args.raw is None: args.raw = sys.stdin.read() resource = TextPage(args.raw) dir = None factory = server.Site(resource) endpoint = endpoints.TCP4ServerEndpoint(reactor, args.port) endpoint.listen(factory) reactor.resolve(socket.getfqdn()).addCallback(printStatus(dir, args.port)) reactor.run()
def dstConnected(self, protocol): """ We've connected to the dst, start listening for srcs """ if self.tunnel_type == 'tls-uni': pass # Handshake not completed at this point for tls-uni else: print "CCP has connected to CT, starting CCP server..." self.dstProto = protocol # We're the producer for the dst transport protocol.transport.registerProducer(self, True) # Next let's get the server going endpoint = endpoints.TCP4ServerEndpoint(reactor, self.src_addr[1], interface=self.src_addr[0]) deferred = endpoint.listen(self.srcFactory) deferred.addErrback(self.dstServerFailed) if self.tunnel_type == 'tls-uni': pass # Handshake not completed at this point for tls-uni else: self.signals.emit('CT_CONNECTED') print 'Curveball ready'
def run_scrAPI(): resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) site = server.Site(resource) http_server = endpoints.TCP4ServerEndpoint(reactor, 5005) http_server.listen(site) reactor.run() return reactor
def __init__(self, port, key_collection): """ Simple Sentman server (just a draft right now) """ self.log = logging.getLogger('cb.sentman.server') # ensure that the port type/value are sane # if type(port) != int: err_str = 'port must be an int (not %s)' % type(port) self.log.warn(err_str) raise TypeError(err_str) # TODO: More checks of sanity: make sure that port is valid self.port = port # ensure that the key_collection is valid. # (it can be empty, but it can't be something bogus. It has # to be an instance of SentmanKeyCollection) # if not isinstance(key_collection, SentmanKeyCollection): raise TypeError('key_collection must be a SentmanKeyCollection') self.factory = Factory() self.factory.protocol = SentmanServerProtocol self.factory.key_collection = key_collection endpoint = endpoints.TCP4ServerEndpoint(reactor, port, backlog=20, interface='127.0.0.1') endpoint.listen(self.factory)
def start_if_not_running(): """ Checks if the process is running, if not, starts it! """ pids = get_matching_pids(APP_NAME, exclude_self=True) # Will remove own PID pids = filter(bool, pids) if not pids: # No match! Implies we need to fire up the listener logging.info("[STARTING] Raspiled Listener with PID %s" % str(os.getpid())) # First the web factory = RaspiledControlSite(timeout=8) # 8s timeout try: pi_port = int(RESOLVED_USER_SETTINGS.get('pi_port', 9090)) except (TypeError, ValueError): raise ConfigurationError( "You have an invalid value for 'pi_port' in your settings. This needs to be a valid port number (integer)." ) endpoint = endpoints.TCP4ServerEndpoint(reactor, pi_port) endpoint.listen(factory) # factory.setup_broadcasting(reactor) # Uncomment to broadcast stuff over network! reactor.run() else: logging.info("Raspiled Listener already running with PID %s" % ", ".join(pids))
def __init__(self, chain, state, p2pFactory): # Get working directory cwd = os.getcwd() self.cwd = cwd self.chain = chain self.state = state self.p2pFactory = p2pFactory self.wallet = wallet.Wallet(self.chain, self.state) # Start local web server and define routes resource = File(self.cwd + '/web-wallet') resource.putChild("webwallet-addresses", showAddresses(self.wallet)) resource.putChild("webwallet-create-new-address", newAddress(self.wallet)) resource.putChild("webwallet-send", sendQuanta(self.chain, self.state, self.p2pFactory)) resource.putChild("webwallet-mempool", memPoolSize(self.chain)) resource.putChild("webwallet-sync", syncStatus(self.p2pFactory)) resource.putChild("webwallet-recover", recoverAddress(self.wallet, self.chain)) factory = Site(resource) endpoint = endpoints.TCP4ServerEndpoint(reactor, 8888, interface='127.0.0.1') endpoint.listen(factory)
def startFuzzServer(listenPort): print "Starting HTTP Server. Please point the web browser to be tested at http://127.0.0.1:" + str(listenPort) resource = FuzzPage() factory = Site(resource) endpoint = endpoints.TCP4ServerEndpoint(reactor, listenPort) endpoint.listen(factory) reactor.run() return 0
def create_listener(self, proto): self._update_onion(self.hiddenservice.dir) self.tcp_endpoint = endpoints.TCP4ServerEndpoint(self.reactor, self.listen_port, interface='127.0.0.1') d = self.tcp_endpoint.listen(self.protocolfactory) d.addCallback(self._add_attributes).addErrback(self._retry_local_port) return d
def start(self): log.debug('starting') # setup a basic web server for test control self.control_endpoint = endpoints.TCP4ServerEndpoint(reactor, 18880) self.control_endpoint.listen(self.get_test_control_site()) log.info('started')
def main(): from twisted.internet import reactor root = resource.Resource() root.putChild('RPC2', XMLRPCQuoter()) root.putChild('SOAP', SOAPQuoter()) endpoint = endpoints.TCP4ServerEndpoint(reactor, 7080) endpoint.listen(server.Site(root)) reactor.run()
def main(reactor): certData = getModule(__name__).filePath.sibling('server.pem').getContent() cert = ssl.PrivateCertificate.loadPEM(certData) factory = protocol.Factory.forProtocol(TLSServer) factory.options = cert.options() endpoint = endpoints.TCP4ServerEndpoint(reactor, 8000) endpoint.listen(factory) return defer.Deferred()
def listen(): for i, key in enumerate(_get_service_keys(os.environ)): host = os.environ[key] port = int(os.environ[key[:-4] + "PORT"]) service = endpoints.TCP4ServerEndpoint(reactor, 2000 + i) service.listen(ProxyFactory(host, port)) print("Connecting port {} to {}:{} ({})".format( 2000 + i, host, port, key))
def scrape_block_packet(ship_ip, ship_port, destination_ip): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) log.msg("[BlockQuery] Scraping %s:%i for a initial block..." % (ship_ip, ship_port)) s.settimeout(30) try: s.connect((ship_ip, ship_port)) except socket.error as e: log.msg("[BlockQuery] Scraping %s:%i connect return an error: %s" % (ship_ip, ship_port, e)) return None except Exception as e: log.msg("[BlockQuery] Scraping %s:%i connect return an error: %s" % (ship_ip, ship_port, sys.exc_info()[0])) return None data = io.BytesIO() try: data.write(s.recv(4)) except socket.error as e: log.msg("[BlockQuery] Scraping %s:%i write return an error: %s" % (ship_ip, ship_port, e)) return None except Exception as e: log.msg("[BlockQuery] Scraping %s:%i write return an error: %s" % (ship_ip, ship_port, sys.exc_info()[0])) return None actual_size = struct.unpack_from('i', data.getvalue(), 0x0)[0] try: data.write(s.recv(actual_size - 4)) except socket.error as e: log.msg("[BlockQuery] Scraping %s:%i recv return an error: %s" % (ship_ip, ship_port, e)) return None except Exception as e: log.msg("[BlockQuery] Scraping %s:%i recv return an error: %s" % (ship_ip, ship_port, sys.exc_info()[0])) return None s.close() data.flush() data = bytearray(data.getvalue()) name = data[0x24:0x64].decode('utf-16le') # namelog = name.encode('ascii', errors='ignore').rstrip('\0') o1, o2, o3, o4, port = struct.unpack_from('BBBBH', buffer(data), 0x68) ip_string = '%i.%i.%i.%i' % (o1, o2, o3, o4) if ship_ip == blockShipList[13000]: # Shared ship hack port += 1000 # Bump port up to 13000 struct.pack_into('H', data, (0x68 + 0x04), port) if port not in blocks.blockList: # log.msg("[BlockList] Discovered new block %s at addr %s:%i! Recording..." % (namelog, ip_string, port)) blocks.blockList[port] = (ip_string, name) if port not in blocks.listeningPorts: from ShipProxy import ProxyFactory if bindIp == "0.0.0.0": interface_ip = myIp else: interface_ip = bindIp block_endpoint = endpoints.TCP4ServerEndpoint(reactor, port, interface=interface_ip) # twisted.internet.error.CannotListenError: Couldn't listen on 0.0.0.0:12468: [Errno 98] Address already in use. block_endpoint.listen(ProxyFactory()) print("[ShipProxy] Opened listen socked on port %i for new ship." % port) blocks.listeningPorts.append(port) o1, o2, o3, o4 = destination_ip.split(".") struct.pack_into('BBBB', data, 0x68, int(o1), int(o2), int(o3), int(o4)) return str(data)
def test_endpoint(self): tubA, tubB = self.makeTubs() portnum = util.allocate_tcp_port() ep = endpoints.TCP4ServerEndpoint(reactor, portnum, interface="127.0.0.1") tubA.listenOn(ep) tubA.setLocation("tcp:127.0.0.1:%d" % portnum) furl = tubA.registerReference(Target()) yield tubB.getReference(furl)
def twisted_server(): dirname = os.path.dirname(os.path.abspath(__file__)) resource = File(os.path.join(dirname,'app/reactApp/build')) factory = Site(resource) PORT = 9000 endpoint = endpoints.TCP4ServerEndpoint(reactor, PORT) endpoint.listen(factory) print "serving at port", PORT reactor.run()
def __init__(self, srcaddr): self.srcFactory = Factory() self.srcFactory.protocol = TestProtocol self.srcFactory.server = self endpoint = endpoints.TCP4ServerEndpoint(reactor, srcaddr[1], interface=srcaddr[0]) endpoint.listen(self.srcFactory)
def _setup_relay(self, blur_usage=None, log_file=None, usage_db=None): ep = endpoints.TCP4ServerEndpoint(reactor, 0, interface="127.0.0.1") self._transit_server = Transit(blur_usage=blur_usage, log_file=log_file, usage_db=usage_db) self._lp = yield ep.listen(self._transit_server) addr = self._lp.getHost() # ws://127.0.0.1:%d/wormhole-relay/ws self.transit = u"tcp:127.0.0.1:%d" % addr.port
def setup_server(): config = yaml.load(open('./config/config.yml', 'r')) server_port = 8080 if 'rpc' in config: server_port = config['rpc']['server_port'] site = server.Site(RPCInterface()) endpoint = endpoints.TCP4ServerEndpoint(reactor, server_port) endpoint.listen(site)
def main(): """ Run a test server at localhost:8880. """ factory = Site(setupTestServerResource()) endpoint = endpoints.TCP4ServerEndpoint(reactor, 8880) endpoint.listen(factory) # noinspection PyUnresolvedReferences reactor.run()