def serve_web(ip=None, port=None, directory=BASE_DIR):
handler = SimpleHTTPRequestHandler
ip = ip or get_ip()
if port is not None:
server = TCPServer((ip, port), handler)
else:
# Otherwise, try to find a port
for port in range(8000, 9000):
try:
server = TCPServer((ip, port), handler)
break
except socket.error:
pass
def server_thread():
log("Starting web server on http://{ip}:{port:d} for directory {dir}".format(ip=ip, port=port, dir=directory))
os.chdir(directory)
server.serve_forever()
# Start this thread in the background
thread = threading.Thread(target=server_thread)
thread.setDaemon(True)
thread.start()
time.sleep(0.5)
return server, ip, port
def __init__(self):
# init kodi helper (for logging)
self.kodi_helper = KodiHelper()
self.last_schedule_check = datetime.now()
self.schedule_check_interval = int(
self.kodi_helper.get_setting('schedule_check_interval'))
self.startidle = 0
self.freq = int('0' + self.kodi_helper.get_setting('auto_update'))
# pick & store a port for the MSL service
msl_port = select_unused_port()
self.kodi_helper.set_setting('msl_service_port', str(msl_port))
self.kodi_helper.log(msg='[MSL] Picked Port: ' + str(msl_port))
# pick & store a port for the internal Netflix HTTP proxy service
ns_port = select_unused_port()
self.kodi_helper.set_setting('netflix_service_port', str(ns_port))
self.kodi_helper.log(msg='[NS] Picked Port: ' + str(ns_port))
# server defaults
TCPServer.allow_reuse_address = True
# configure the MSL Server
self.msl_server = TCPServer(('127.0.0.1', msl_port),
MSLHttpRequestHandler)
self.msl_server.server_activate()
self.msl_server.timeout = 1
# configure the Netflix Data Server
self.ns_server = TCPServer(('127.0.0.1', ns_port),
NetflixHttpRequestHandler)
self.ns_server.server_activate()
self.ns_server.timeout = 1
def run(self):
server = TCPServer(self.addr, self.app)
try:
self.logger.info('Maria System Start at %s:%s' % self.addr)
server.serve_forever()
except KeyboardInterrupt:
self.logger.info('Maria System Stopped')
def _start(self):
try:
logger.info("Starting HTTP server on port {}".format(self.http_port))
self.httpd = TCPServer(("", self.http_port), CustomRequestHandler)
self.httpd.serve_forever()
except Exception as e:
logger.exception(e)
def main():
host = ''
port = 2048
addr = (host, port)
thread.start_new_thread(timer_thread, ())
server = TCPServer(addr, MyRequestHandler)
server.serve_forever()
def run(self, requestHandlerMethod):
class RequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.wfile.write("maya tdd server\n")
def log_message(self, format, *args):
return
def do_POST(self):
request = self.rfile.read(int(self.headers['Content-Length']))
request = json.loads(request)
result = requestHandlerMethod(request)
self.send_response(200)
self.end_headers()
self.wfile.write(json.dumps(result).encode("utf-8"))
self.instance = TCPServer(("", self.port), RequestHandler, bind_and_activate=False)
self.instance.allow_reuse_address = True
self.instance.server_bind()
self.instance.server_activate()
self.instance_thread = threading.Thread(target=self.instance.serve_forever)
self.instance_thread.start()
def referenceHttpServer(self, port, request):
def server(httpd):
httpd.serve_forever()
class Handler(BaseHTTPRequestHandler):
def log_message(*args, **kwargs):
pass
def do_GET(self, *args, **kwargs):
request.append({
'command': self.command,
'path': self.path,
'headers': self.headers
})
self.send_response(200, "GET RESPONSE")
def do_POST(self, *args, **kwargs):
request.append({
'command':
self.command,
'path':
self.path,
'headers':
self.headers,
'body':
self.rfile.read(int(self.headers["Content-Length"]))
})
self.send_response(200, "POST RESPONSE")
self.httpd = TCPServer(("", port), Handler)
thread = Thread(None, lambda: server(self.httpd))
thread.start()
def open(self):
self.netAdapter = TCPServer((self.address, self.port), jeedom_socket_handler)
if self.netAdapter:
logging.debug("Socket interface started")
threading.Thread(target=self.loopNetServer, args=()).start()
else:
logging.debug("Cannot start socket interface")
def main():
smsolver = small_solvers(queue_local, Usersolver, poly_small_threads)
# Reuse the port to debug
TCPServer.allow_reuse_address = True
ss = TCPServer(('0.0.0.0', portnumber), PHC_Server)
print 'server is listening to', portnumber
try:
print 'press ctrl c to stop server'
ss.serve_forever()
except KeyboardInterrupt:
print ' ctrl c pressed, closing server'
if queue:
print 'writing recover file'
save_queue(queue)
print 'closing solver threads'
for i in range(poly_small_threads):
smsolver[i]._Thread__stop()
print 'server closed'
ss.socket.close()
def get_current_pose_joints(server_ip, server_port, ur_ip, tool_angle_axis):
global script
script = script.replace("{SERVER_ADDRESS}", server_ip)
script = script.replace("{PORT}", str(server_port))
script = script.replace(
"{TCP}",
str([
tool_angle_axis[i] if i >= 3 else tool_angle_axis[i] / 1000.
for i in range(len(tool_angle_axis))
]))
print script
ur_available = is_available(ur_ip)
if ur_available:
# start server
server = TCPServer((server_ip, server_port), MyTCPHandler)
send_script(ur_ip, script)
# send file
try:
server.serve_forever()
except:
return list_str_to_list(server.rcv_msg)
def proxyServer(self, port, request):
def server(httpd):
httpd.serve_forever()
class Proxy(BaseHTTPRequestHandler):
def log_message(*args, **kwargs):
pass
def do_CONNECT(self):
request.append({
'command': self.command,
'path': self.path,
'headers': self.headers
})
self.send_response(200, "Connection established")
self.end_headers()
origRequest = self.connection.recv(4096)
path = "http://" + self.path + origRequest.split()[1]
self.wfile.write(urlopen(path).read())
self.wfile.flush()
self.connection.close()
httpd = TCPServer(("", port), Proxy)
thread = Thread(None, lambda: server(httpd))
thread.daemon = True
thread.start()
def worker():
try:
httpd = TCPServer(("", 8000), RequestHandler)
print("Serving at port", 8000)
httpd.serve_forever()
except:
print("Server Error")
def init(self):
Logger.info("Gateway init")
if version[0] != 2 or version[1] < 6 or (version[1] == 7 and version[2] in [1, 2]):
Logger.error("Gateway:: incompatibility with current Python machine '%d.%d.%d'" % version[:3])
return False
fpem = os.path.join(Config.general.conf_dir, "gateway.pem")
if os.path.exists(fpem):
self.ssl_ctx = SSL.Context(SSL.SSLv23_METHOD)
self.ssl_ctx.use_privatekey_file(fpem)
self.ssl_ctx.use_certificate_file(fpem)
self.ssl_ctx.load_verify_locations(fpem)
else:
Logger.error("Gateway role need a certificate (%s)" % fpem)
return False
addr = (Config.address, Config.port)
try:
GatewayTCPHandler.role = self
self.server = TCPServer(addr, GatewayTCPHandler, bind_and_activate=False)
self.server.allow_reuse_address = Config.general.server_allow_reuse_address
self.server.server_bind()
self.server.server_activate()
except socket.error, e:
Logger.error("Gateway:: socket init: %s" % e)
return False
def get_server(cls, port):
"""
Call httpd.shutdown() to stop the server
"""
httpd = TCPServer(("", port), TestWebServerHandler)
return httpd
def serve(path=settings.OUTPUT_DIR, port=8000):
old_working_dir = getcwd()
chdir(path)
new_working_dir = getcwd()
httpd = TCPServer(("", port), SimpleHTTPRequestHandler)
print 'Starting development server rooted at %s' % new_working_dir
httpd.serve_forever()
def _start_web_server():
global http_server
try:
from SimpleHTTPServer import SimpleHTTPRequestHandler
from SocketServer import TCPServer
except ImportError:
from http.server import SimpleHTTPRequestHandler
from socketserver import TCPServer
try:
handler = SimpleHTTPRequestHandler
handler.directory = os.path.join(
os.path.dirname(__file__), "..", "..")
http_server = TCPServer(
("", 8000), handler, bind_and_activate=False)
http_server.daemon_threads = True
http_server.allow_reuse_address = True
http_server.server_bind()
http_server.server_activate()
http_server_ready.set()
http_server.serve_forever()
except:
import traceback
traceback.print_exc()
finally:
http_server = None
http_server_ready.set()
def launch(path):
"""Start a server to view an exported D3PO bundle, and open a browser.
:param path: The TLD of the bundle
"""
from SocketServer import TCPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
from random import randrange
from socket import error
import webbrowser
from threading import Thread
os.chdir(path)
while True:
try:
PORT = randrange(8000, 9000)
server = TCPServer(("", PORT), SimpleHTTPRequestHandler, False)
server.allow_reuse_address = True
server.server_bind()
break
except error: # port already taken
pass
print('Serving D3PO on port 0.0.0.0:%i' % PORT)
server.server_activate()
thread = Thread(target=server.serve_forever)
thread.setDaemon(True) # do not prevent shutdown
thread.start()
webbrowser.open('http://0.0.0.0:%i' % PORT)
def f_RUN():
print("Root directory: " + ROOT_DIR)
print("Main directory: " + MAIN_DIR)
httpd = TCPServer((s_INTERFACE,n_PORT),c_HANDLER)
s_ip, _p = httpd.server_address
print("IP: " + s_ip + ":" + str(_p))
while b_RUNNING:
httpd.handle_request()
def start_wsKeyboard_server(port=DEFAULT_PORT):
httpd = TCPServer(('', port), WsKeyboardRequestHandler)
for address in get_addresses():
print 'ws://%s:%d/' % (address, port)
httpd.serve_forever()
def __init__(self):
signalling_queue.clear();
TCPServer.allow_reuse_address = True;
self.__start_flag = False;
self.__http_handler = http_action_handler;
self.__server = TCPServer(("", 8080), self.__http_handler);
def run_test_server():
while True:
try:
server = TCPServer((SERVER_ADDRESS, SERVER_PORT), Tester)
break
except Exception, e:
print e
sleep(1)
def create_tcp_server_by_socketserver():
class MyRequestHandler(StreamRequestHandler):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCPServer(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
def main():
server = TCPServer(("127.0.0.1", 2121), Dispatcher)
print "I'm waiting for commands..."
try:
server.serve_forever()
finally:
print "Goodbye!"
def _prepare(self):
log.debug("Preparing callback daemon and registering hook object")
self._done = False
self._daemon = TCPServer((self.IP_ADDRESS, 0), HooksHttpHandler)
_, port = self._daemon.server_address
self.hooks_uri = '{}:{}'.format(self.IP_ADDRESS, port)
log.debug("Hooks uri is: %s", self.hooks_uri)
def __init__(self, ip="", port=8080):
self.__ip = ip
self.__port = port
self.__statistical_logger = statistical_logger()
self.__handler = http_handler
self.__server = TCPServer((ip, port), self.__handler)
self.__media_server = media_server("", configuration.get_media_port())
def __init__(self, address='localhost', port=55004):
self.Address = address
self.Port = port
self.netAdapter = TCPServer((self.Address, self.Port),
NetRequestHandler)
if self.netAdapter:
self.netAdapterRegistered = True
threading.Thread(target=self.loopNetServer, args=()).start()
def __init__(self, output_handler):
threading.Thread.__init__(self)
self.handshake = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(8))
self.close_key = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(8))
self._server = TCPServer(('127.0.0.1', 0), lambda r, c, s: HandShakeHandler(r, c, s, (self.handshake, self.close_key), output_handler), False)
self._server.server_bind()
self.port = self._server.server_address[1]
def setup_http_server(self):
# pick a free port
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", 0))
self.port = sock.getsockname()[1]
sock.close()
# Temporarily change the directory to the profile directory.
os.chdir(self.gecko_profile_dir)
self.httpd = TCPServer((self.host, self.port), ProfileServingHTTPRequestHandler)
def __init__(self):
global settings
# threading.Thread.__init__(self)
super(SublimeServerThread, self).__init__()
if not mimetypes.inited:
mimetypes.init() # try to read system mime.types
SublimeServer.extensions_map = mimetypes.types_map.copy()
SublimeServer.extensions_map.update(settings.get('mimetypes'))
self.httpd = TCPServer(("", settings.get('port')), SublimeServer)
self.setName(self.__class__.__name__)
def __init__(self, bind_address, dispatcher):
""" Creates a TCP server to listen for messages from the Babble node.
:param bind_address: tuple consisting of ip and port where the application is listening
:type bind_address: tuple(ip:str, port:int)
:param dispatcher:
"""
self.bind_address = bind_address # type: tuple
self.tcp_server = TCPServer(self.bind_address,
dispatcher) # type: TCPServer
