def main_tcp(instrument, args): logging.info('Listening to %s:%s', args.host, args.port) Handler = create_TCPInstrumentHandler(instrument) server = socketserver.TCPServer((args.host, args.port), Handler) server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) return server
}) parser = argparse.ArgumentParser() parser.add_argument('--bind', '-b', default='', metavar='ADDRESS', help='Specify alternate bind address ' '[default: all interfaces]') parser.add_argument('port', action='store', default=8000, type=int, nargs='?', help='Specify alternate port [default: 8000]') args = parser.parse_args() PORT = args.port BIND = args.bind HOST = BIND if HOST == '': HOST = 'localhost' Handler = SimpleHTTPRequestHandler with socketserver.TCPServer((BIND, PORT), Handler) as httpd: serve_message = "Serving HTTP on {host} port {port} (http://{host}:{port}/) ..." print(serve_message.format(host=HOST, port=PORT)) httpd.serve_forever()
try: if not command: command = 'missing command key' raise ValueError action = command[:1] # "+"=announce , "-"=withdraw ip = ipaddress.ip_network(command[1:]) # IP in CIDR notation (e.g 1.1.1.1/32) if action in ('+', '-'): message = '{} route {} next-hop {}\n'.format( 'announce' if action == '+' else 'withdraw', ip, os.environ['MY_NODE_IP']) stdout.write(message) stdout.flush() self.createResponse('Success: %s' % message) else: raise ValueError except ValueError: stdout.write(command) stdout.flush() self.createResponse("""Failure: invalid syntax '%s' Correct syntax: <+-><IP/MASK> e.g.: command=\"+1.1.1.1/32\" or command=\"-20.20.20.0/24\" """ % command) handler = ServerHandler httpd = socketserver.TCPServer(('', PORT), handler) stdout.write('serving at port %s\n' % PORT) stdout.flush() httpd.serve_forever()
def serve(): schedule_pings() server = socketserver.TCPServer(address, TCPHandler) server.serve_forever()
# encode:utf-8 import socketserver class MyTcpHandler(socketserver.BaseRequestHandler): def handle(self): # self.data = self.request.recv(1024).strip() self.data = self.request.recv(1024) print("{} wrote:".format(self.client_address[0])) print(self.data) self.request.sendall(self.data.upper()) if __name__ == "__main__": HOST, PORT = "192.168.0.109", 8888 with socketserver.TCPServer((HOST, PORT), MyTcpHandler) as server: server.serve_forever()
# -*- coding: utf-8 -*- #test on python 3.4 ,python of lower version has different module organization. import http.server from http.server import HTTPServer, BaseHTTPRequestHandler import socketserver PORT = 8081 Handler = http.server.SimpleHTTPRequestHandler Handler.extensions_map = { '.manifest': 'text/cache-manifest', '.html': 'text/html', '.png': 'image/png', '.jpg': 'image/jpg', '.svg': 'image/svg+xml', '.css': 'text/css', '.js': 'application/x-javascript', '.wasm': 'application/wasm', '': 'application/octet-stream', # Default } httpd = socketserver.TCPServer(("", PORT), Handler) print("serving at port", PORT) httpd.serve_forever()
group = GroupCoordinatorDaemon.listeners_by_pid listeners = GroupCoordinatorDaemon.pids_by_listener # remove any old memberships for the same student if student_id in students and students[student_id] != process_id: old_pid = students[student_id] del group[old_pid] students[student_id] = process_id # add this entry into group membership group[process_id] = listener # also remove any old memberships which claimed this same listener (host, port) pair if listener in listeners and listeners[listener] != process_id: old_pid = listeners[listener] if old_pid in group: del group[old_pid] listeners[listener] = process_id return group if __name__ == '__main__': if len(sys.argv) != 2: print("Usage: python gcd2.py GCDPORT") exit(1) port = int(sys.argv[1]) print(port) with socketserver.TCPServer(('', port), GroupCoordinatorDaemon) as server: server.serve_forever()
def test_context_manager(self): with socketserver.TCPServer( (HOST, 0), socketserver.StreamRequestHandler) as server: pass self.assertEqual(-1, server.socket.fileno())
def main(): args = parse_args() with socketserver.TCPServer(("", args.port), Handler) as MyServer: print("serving at port", args.port) MyServer.serve_forever()
self.send_response(200) extension = path.rfind(".") mime_type = mime[path[extension:]] self.send_header("Content-type", mime_type) self.end_headers() self.wfile.write(fh.read()) except FileNotFoundError: self.send_response(404) self.send_header("Content-type", "text/plain") self.end_headers() self.wfile.write(b"not found") else: self.send_response(403) self.send_header("Content-type", "text/plain") self.end_headers() self.wfile.write(b"invalid request") except Exception as err: print(err) if __name__ == '__main__': if len(sys.argv) > 1: port = int(sys.argv[1]) else: port = 3000 with socketserver.TCPServer(("", port), FileServer) as server: print("listening on port", port) try: server.serve_forever() except KeyboardInterrupt: pass
in the HTTP protocol request""" # We just print a message print("GET received!") # IN this simple server version: # We are NOT processing the client's request # We are NOT generating any response message return # ------------------------ # - Server MAIN program # ------------------------ # -- Set the new handler Handler = TestHandler # -- Open the socket server with socketserver.TCPServer(("127.0.0.1", PORT), Handler) as httpd: print("Serving at PORT", PORT) # -- Main loop: Attend the client. Whenever there is a new # -- clint, the handler is called try: httpd.serve_forever() except KeyboardInterrupt: print("") print("Stopped by the user") httpd.server_close()
"{level} is not a valid log level".format(level=args.log)) logging.basicConfig(level=num_log_level) log = logging.getLogger('push2masymos') log.info("push2masymos started") # loads the main config from file config = load_config(args.config) # update default settings, with the config vars settings.update(config["settings"]) # generate http paths # prepare and start HTTP server request_handler = RequestHandler request_handler.path_dict = generate_paths() httpd = socketserver.TCPServer(("", settings["http_port"]), RequestHandler) # creates a separate thread, to handle the httpd and starts it httpd_thread = threading.Thread(target=httpd.serve_forever) httpd_thread.start() # do the actual pushing if args.no_push is not True: log.info("start pushing models to masymos") push_models() else: log.info("skip pushing") if args.daemon is True or args.no_push is True: # needs to daemonize # wait for httpd thread
<style type = ""text/css"">\ \ body {background-image : url(""http://www.iotbpm.com/wp-content/uploads/2020/01/RaspberryPi_IoT_Tron-768x334.png""); background-repeat : no-repeat; background-color : powderblue;}\ h1{color:black; font-family : arial;}\ p{color:black; font-family : verdana;}\ </style>\ </head>\ <body><p style=""text-align:right;"">" html = html + f"LED 0 - Device is {LED0}<br>" html = html + f"<a href=\"/DEV0=ON\"\"><button>Device 0 ON </button></a> <a href=\"/DEV0=OFF\"\"><button>Device 0 OFF </button></a><br><br>" html = html + f"LED 1 - Device is {LED1}<br>" html = html + f"<a href=\"/DEV1=ON\"\"><button>Device 1 ON </button></a> <a href=\"/DEV1=OFF\"\"><button>Device 1 OFF </button></a><br><br>" html = html + f"\ </p></body>\ </html>" # Writing the HTML contents with UTF-8 self.wfile.write(bytes(html, "utf8")) return # Create an object of the above class handler_object = MyHttpRequestHandler PORT = 8084 my_server = socketserver.TCPServer(("", PORT), handler_object) # Star the server my_server.serve_forever()
def main(): address = ('', 10001) http_server = socketserver.TCPServer(address, HttpRequestHandler) http_server.serve_forever()
import http.server import socketserver PORT = 8080 handler = http.server.SimpleHTTPRequestHandler # serves files from current directory and # any sub directories with socketserver.TCPServer( ("", PORT), handler) as httpd: # this is just file opening notation print("serving at port", PORT) httpd.serve_forever() # it's tcpwhere you pass the ip and the port # you also have the handler # tutorial : https://www.afternerd.com/blog/python-http-server/ # now build one from scratch # made in c : https://medium.com/from-the-scratch/http-server-what-do-you-need-to-know-to-build-a-simple-http-server-from-scratch-d1ef8945e4fa
import http.server import socketserver handler = http.server.SimpleHTTPRequestHandler with socketserver.TCPServer(("", 1234), handler) as httpd: httpd.serve_forever()
for i in range(0, commands_len): splitted = commands[i].split(' ') command = splitted[0] args = [] if( len(splitted) > 1 ): args = commands[i].split(' ')[1:] if( self.is_connected == False ): if( command == self.password ): self.request.sendall(str.encode(self.greeting_message)) self.is_connected = True else: break else: if( command in self.available_commands.keys() ): self.available_commands[command](args) elif( command in custom_commands.keys() ): self.onCustomCommand(custom_commands[command]) with open(CUSTOM_COMMANDS_FILE, 'r') as commands_file: custom_commands = json.load(commands_file) print(str(custom_commands)) print(str(custom_commands.keys())) socketserver.TCPServer.allow_reuse_address = True server = socketserver.TCPServer((LISTENING_ADDRESS, SERVER_PORT), MyTCPHandler) server.serve_forever()
import http.server import socketserver PORT = 8080 class redirectHandler(http.server.SimpleHTTPRequestHandler): def do_GET(self): self.do_redirect('remove') self.do_redirect('update') super(redirectHandler, self).do_GET() def do_redirect(self, path): if self.path == '/service/%s/1970-01-01T00:00:00' % path: self.send_response(301) self.send_header('Location', '/service/v2/%s/1970-01-01T00:00:00/' % path) self.end_headers() with socketserver.TCPServer(("", PORT), redirectHandler) as httpd: print("serving at port", PORT) httpd.serve_forever()
# @classmethod # def test(cls): # """ # # # :return: # """ # pass if __name__ == "__main__": HOST, PORT = "localhost", 9999 # Create the server, binding to localhost on port 9999 server = socketserver.TCPServer((HOST, PORT), MyTCPHandler) # Activate the server; this will keep running until you # interrupt the program with Ctrl-C server.serve_forever() # class Session(socketserver.BaseRequestHandler): # def handle(self): # header = self.request.recv(4) # message_length, = unpack('>I', header) # print(message_length) # # message = self.request.recv(message_length) # pb_message = foo_pb2.Person() # pb_message.ParseFromString(message) #
import http.server import socketserver PORT = 8888 class MyHTTPRequestHandler(http.server.SimpleHTTPRequestHandler): def end_headers(self): self.send_header("Access-Control-Allow-Origin", "*") super().end_headers() with socketserver.TCPServer(("", PORT), MyHTTPRequestHandler) as httpd: httpd.serve_forever()
server = Server(watcher=sphinx_autobuild.LivereloadWatchdogWatcher()) server.watch(source_folder, builder) server.watch(build_folder) builder.build() server.serve(port=8000, host='0.0.0.0', root=build_folder) else: # Building once when server starts builder = sphinx_autobuild.SphinxBuilder( outdir=build_folder, args=['-b', 'html', source_folder, build_folder] + sys.argv[1:]) builder.build() sys.argv = ['nouser', '8000'] if configuration.get('credentials')['username'] is not None: auth = configuration.get( 'credentials')['username'] + ':' + configuration.get( 'credentials')['password'] key = base64.b64encode(auth.encode('utf-8')) with pushd(build_folder): http.server.test(AuthHandler, http.server.HTTPServer) else: with pushd(build_folder): Handler = http.server.SimpleHTTPRequestHandler httpd = socketserver.TCPServer(('', 8000), Handler) httpd.serve_forever()
def accuracy2_visualizer(args): model_name = args.model_name data_type = args.data_type num_per_page = args.num_per_page data_dir = args.data_dir run_id = args.run_id.zfill(2) step = args.step eval_path =os.path.join("out", model_name, run_id, "eval", "{}-{}.json".format(data_type, str(step).zfill(6))) eval_ = json.load(open(eval_path, 'r')) _id = 0 html_dir = "/tmp/list_results%d" % _id while os.path.exists(html_dir): _id += 1 html_dir = "/tmp/list_results%d" % _id if os.path.exists(html_dir): shutil.rmtree(html_dir) os.mkdir(html_dir) cur_dir = os.path.dirname(os.path.realpath(__file__)) templates_dir = os.path.join(cur_dir, 'templates') env = Environment(loader=FileSystemLoader(templates_dir)) env.globals.update(zip=zip, reversed=reversed) template = env.get_template(args.template_name) data_path = os.path.join(data_dir, "data_{}.json".format(data_type)) shared_path = os.path.join(data_dir, "shared_{}.json".format(data_type)) data = json.load(open(data_path, 'r')) shared = json.load(open(shared_path, 'r')) rows = [] for i, (idx, yi, ypi) in enumerate(zip(*[eval_[key] for key in ('idxs', 'y', 'yp')])): id_, q, rx = (data[key][idx] for key in ('ids', 'q', '*x')) x = shared['x'][rx[0]][rx[1]] ques = [" ".join(q)] para = [[word for word in sent] for sent in x] row = { 'id': id_, 'title': "Hello world!", 'ques': ques, 'para': para, 'y': yi, 'y2': yi, 'yp': ypi, 'yp2': ypi, 'a': "" } rows.append(row) if i % num_per_page == 0: html_path = os.path.join(html_dir, "%s.html" % str(i).zfill(8)) if (i + 1) % num_per_page == 0 or (i + 1) == len(eval_['y']): var_dict = {'title': "Accuracy Visualization", 'rows': rows } with open(html_path, "wb") as f: f.write(template.render(**var_dict).encode('UTF-8')) rows = [] os.chdir(html_dir) port = args.port host = args.host # Overriding to suppress log message class MyHandler(http.server.SimpleHTTPRequestHandler): def log_message(self, format, *args): pass handler = MyHandler httpd = socketserver.TCPServer((host, port), handler) if args.open == 'True': os.system("open http://%s:%d" % (args.host, args.port)) print("serving at %s:%d" % (host, port)) httpd.serve_forever()
def main(): server = socketserver.TCPServer(("localhost", 9995), MessageHandler) print("Server div running ...") server.serve_forever()
def main(): server = socketserver.TCPServer((protocolUtils.host, protocolUtils.port), MessageHandler) print("Server interm layer running ...") server.serve_forever()
x1 = int(x1/2) x2 = int(-k[2] * k[1] + x1) y2 = y1-k[2] # cv2.line(image,(x1,y1),(x2,y2),(0,0,255),2) cv2.line(masked_img,(x1,y1),(x2,y2),(100),2) with open('rawvideo.jpg', 'wb') as File: File.write(data) with open('mask.jpg', 'wb') as File: result, masked_data = cv2.imencode('.jpg', masked_img, [int(cv2.IMWRITE_JPEG_QUALITY), 90]) File.write(masked_data) print('m : {}'.format(k[1])) print('forward : {}'.format(k[2])) send = {"action": k[0], "markers" : mark_result, "cascade" : cas_result} self.wfile.write( bytes(json.dumps(send), encoding='utf8')) self.wfile.write(b'\n') if __name__ == '__main__': with socketserver.TCPServer(("0.0.0.0", PORT), Handler, bind_and_activate=False) as httpd: httpd.server = httpd httpd.allow_reuse_address = True httpd.server_bind() httpd.server_activate() print("HTTPServer Serving at port", PORT) httpd.serve_forever()
# update signed_queries signed_query_store[query_id]['signed_by'].append(source_id) signed_query_store[query_id]['signed'] = query logger.debug(signed_query_store) logger.info("%s got %s queries", source_id, len(signed_query_store)) if __name__ == "__main__": parser = argparse.ArgumentParser(description="Query server") parser.add_argument('--debug', nargs='?', const=True, default=False, help="Debug logging") args = parser.parse_args() level = logging.INFO if args.debug: level = logging.DEBUG logging.basicConfig( level=level, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s') server = socketserver.TCPServer( (config.QUERY_SERVER_HOST, config.QUERY_SERVER_PORT), QueryHandler) server.serve_forever()
def serve_file(filename, address="", port=45114, content_type=None): class FileHandler(BaseHTTPRequestHandler): def format_size(self, size): for size_unity in ["B", "KB", "MB", "GB", "TB"]: if size < 1024: return size, size_unity size = size / 1024 return size * 1024, size_unity def log_message(self, format, *args, **kwargs): size, size_unity = self.format_size(stats.st_size) format += " {} - {:0.2f} {}".format(content_type, size, size_unity) return super(FileHandler, self).log_message(format, *args, **kwargs) def do_GET(self): # noqa if "Range" not in self.headers: first, last = 0, stats.st_size else: try: first, last = parse_byte_range(self.headers["Range"]) except ValueError: self.send_error(400, "Invalid byte range") return None if last is None or last >= stats.st_size: last = stats.st_size - 1 response_length = last - first + 1 try: if "Range" not in self.headers: self.send_response(200) else: self.send_response(206) self.send_header( "Content-Range", "bytes %s-%s/%s" % (first, last, stats.st_size)) self.send_header("Accept-Ranges", "bytes") self.send_header("Content-type", content_type) self.send_header("Content-Length", str(response_length)) self.send_header("Access-Control-Allow-Origin", "*") self.send_header( "Last-Modified", time.strftime("%a %d %b %Y %H:%M:%S GMT", time.localtime(stats.st_mtime))) self.end_headers() mediafile = open(str(mediapath), "rb") copy_byte_range(mediafile, self.wfile, first, last) except ConnectionResetError: # This is supposed to happen when the Chromecast seeks or stops. pass except: # noqa traceback.print_exc() mediafile.close() if content_type is None: content_type = "video/mp4" mediapath = Path(filename) stats = mediapath.stat() httpd = socketserver.TCPServer((address, port), FileHandler) httpd.serve_forever() httpd.server_close()
import socketserver import http.server import ssl import os httpd = socketserver.TCPServer(('0.0.0.0', 443), http.server.SimpleHTTPRequestHandler) context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) context.load_cert_chain('cert.pem', 'key.pem') httpd.socket = context.wrap_socket(httpd.socket) share_path = r"C:\Users\Public" os.chdir(share_path) httpd.serve_forever()
parser = argparse.ArgumentParser(description='Watch and serve documentation.') parser.add_argument('--host,h', dest='host', type=str, default=None) parser.add_argument('--port,p', dest='port', type=str, default=5500) parser.add_argument('--watch', dest='watch', default=False, action='store_true') args = parser.parse_args() if args.watch: from livereload import Server, shell server = Server() server.watch('source/*.rst', shell('make html', cwd='.')) server.serve(port=args.port, host=args.host, root='build/html') else: import http.server import socketserver host = args.host if args.host is not None else "127.0.0.1" port = args.port Handler = lambda request, client_address, server: http.server.SimpleHTTPRequestHandler( request, client_address, server, directory='build/html') with socketserver.TCPServer((host, port), Handler) as httpd: print("Serving on http://%s:%d" % (host, port)) httpd.serve_forever()
im = Image.open(io.BytesIO(post_data)) im = im.resize((SIZE, SIZE)) buf = io.BytesIO() im.save(buf, format='JPEG') st2 = time.clock_gettime(time.CLOCK_REALTIME) tt2 = time.clock_gettime(time.CLOCK_THREAD_CPUTIME_ID) buf.seek(0) buffed = buf.read() st3 = time.clock_gettime(time.CLOCK_REALTIME) tt3 = time.clock_gettime(time.CLOCK_THREAD_CPUTIME_ID) self.send_response(200) self.send_header("Time", ', '.join([str(int(1000000000 * x)) for x in [st1-st0, st2-st1, st3-st2]])) self.send_header("Thread-Time", ', '.join([str(int(1000000000 * x)) for x in [tt1-tt0, tt2-tt1, tt3-tt2]])) self.send_header("Server-UUID", SERVERID) self.send_header("Content-Type", "image/jpeg") self.end_headers() self.wfile.write(buffed) except Exception as e: self.send_error(500, message=str(e)) if __name__ == "__main__": with socketserver.TCPServer(("", PORT), handler) as httpd: print("serving at port", PORT) httpd.serve_forever()