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()
