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