def run():
server_address = ('127.0.0.1', 80)
http = HTTPServer(server_address, MyhttprequestHandler)
http.serve_forever()
self.end_headers()
if code not in ERRORS:
r = {"response": response, "code": code}
else:
r = {
"error": response or ERRORS.get(code, "Unknown Error"),
"code": code
}
context.update(r)
logging.info(context)
self.wfile.write(json.dumps(r))
return
if __name__ == "__main__":
op = OptionParser()
op.add_option("-p", "--port", action="store", type=int, default=8080)
op.add_option("-l", "--log", action="store", default=None)
(opts, args) = op.parse_args()
logging.basicConfig(filename=opts.log,
level=logging.INFO,
format='[%(asctime)s] %(levelname).1s %(message)s',
datefmt='%Y.%m.%d %H:%M:%S')
server = HTTPServer(("localhost", opts.port), MainHTTPHandler)
logging.info("Starting server at %s" % opts.port)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
<h3 align=\'center\'>(From Server - 1)</h3> \
</body> \
</html>'
class GetHandler(BaseHTTPRequestHandler):
global student_message, staff_message
def do_GET(self):
client_address = self.client_address
parsed_path = urlparse.urlparse(self.path)
print "Client IP: ", client_address
ipaddr = '200.0.0.2'
if ipaddr in client_address:
print "Inside"
message = staff_message
else:
message = student_message
self.send_response(200)
self.end_headers()
self.wfile.write(message)
return
if __name__ == '__main__':
from BaseHTTPServer import HTTPServer
server = HTTPServer(('', 80), GetHandler)
print 'Starting server, use <Ctrl-C> to stop'
server.serve_forever()
return
#Handler for the POST requests
def do_POST(self):
self.send_response(200)
message = self.rfile.read(int(
self.headers.getheader('Content-Length')))
X_COORD, Y_COORD = getCoords(message)
#here is where we need to call battleship
res = {key1: X_COORD, key2: Y_COORD}
print res
self.send_header('Content-type', 'text/html')
self.end_headers()
# Send the html message
self.wfile.write(res)
return
try:
#Create a web server and define the handler to manage the
#incoming request
server = HTTPServer((HOST, PORT), myHandler)
print 'Started httpserver on port', PORT
#Wait forever for incoming http requests
server.serve_forever()
except KeyboardInterrupt:
print '^C received, shutting down the web server'
server.socket.close()
user_name = ret_dict.get('user_name')
self.response(
'POST', 'text/plain',
'isValid=true\n' + 'userName='******'\n')
elif action == 'register':
self.response('POST', 'text/plain', 'isRegSuccess=true\n')
else:
if action == 'userAuthentication':
self.response('POST', 'text/plain', 'isValid=false\n')
elif action == 'register':
self.response('POST', 'text/plain', 'isRegSuccess=false\n')
else:
Log.w(self.TAG, 'no action in POST param')
def response(self, request_type, content_type, send_buffer=""):
charset = 'UTF-8'
content = send_buffer.encode(charset)
self.send_response(200)
self.send_header('Content-type', content_type + ';charset=' + charset)
self.end_headers()
self.wfile.write(content)
if __name__ == '__main__':
from BaseHTTPServer import HTTPServer
server = HTTPServer((HOST, PORT), RequestHandler)
print 'Server is started, using Ctrl+C to stop'
server.serve_forever()
out = '<div style="text-align: center; font-family: \'arial\';">'
try:
# Access the 'message' variable from data (name in form)
f = data['message']
out += '<p>' + ''.join(f) + '</p>'
out += '<a href="/echo.html">New Message?</a>'
except:
out += '<p>Cannot make sense of the submitted form.</p>'
out += '<a href="/echo.html">Fix it!</a>'
out += '</div>'
self.wfile.write(out)
if __name__ == '__main__':
try:
# Create a web server and define our handler to manage the
# incoming request
server = HTTPServer(('', PORT_NUMBER), SimpleHttpPostHandler)
print('Started httpserver on port ', PORT_NUMBER)
#Wait forever for incoming http requests
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down the web server')
server.socket.close()
print "Converted"
xml_str = parse.getHRXML(filepath)
print xml_str
logging.info("Parsed tree..." + xml_str)
print "Parsed tree...", xml_str
return xml_str
dispatcher = SoapDispatcher(
'my_dispatcher',
location="http://localhost:8088/",
action='http://localhost:8088/', # SOAPAction
namespace="http://example.com/sample.wsdl",
prefix="ns0",
# trace = True,
ns=True)
dispatcher.register_function('Filehandler',
filehandler,
returns={'parsedData': str},
args={
'filedata': str,
'filename': str
})
print "Starting server..."
httpd = HTTPServer(("", 8088), SOAPHandler)
httpd.dispatcher = dispatcher
httpd.serve_forever()
self.wfile.write('Client: %s\n' % str(self.client_address))
self.wfile.write('User-agent: %s\n' % str(self.headers['user-agent']))
self.wfile.write('Path: %s\n' % self.path)
self.wfile.write('Form data:\n')
# Echo back information about what was posted in the form
for field in form.keys():
field_item = form[field]
if field_item.filename:
# The field contains an uploaded file
file_data = field_item.file.read()
file_len = len(file_data)
del file_data
self.wfile.write('\tUploaded %s as "%s" (%d bytes)\n' % \
(field, field_item.filename, file_len))
else:
# Regular form value
self.wfile.write('\t%s=%s\n' % (field, form[field].value))
return
try:
if __name__ == '__main__':
from BaseHTTPServer import HTTPServer
server = HTTPServer(('localhost', 8080), GetHandler)
print('Starting server, use <Ctrl-C> to stop')
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down the web server')
server.socket.close()
devnull = open(os.devnull, 'w')
p=subprocess.Popen(["openssl","ts","-reply","-config","TSA.cnf","-queryfile", t.name],stdout=subprocess.PIPE,stderr=devnull)
(out,err) = p.communicate()
t.close()
p.wait()
if ( p.returncode == 0 ):
self.send_response(200,'OK')
self.send_header('Content-Type','application/timestamp-response')
self.send_header('Content-Length',len(out))
self.end_headers()
self.wfile.write(out);
else:
send_error(400)
finally:
t.close()
devnull.close()
return
def send_error(self, code):
self.send_response(code)
self.end_headers()
if __name__ == '__main__':
from BaseHTTPServer import HTTPServer
server = HTTPServer(('localhost', 9999), TSHandler)
print 'Starting server...'
server.serve_forever()
def servev4():
server = HTTPServer(('0.0.0.0', 81), SimpleHTTPRequestHandler)
server.serve_forever()
self.send_error(404, 'File Not Found: %s' % self.path)
def _set_headers(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_HEAD(self):
self._set_headers()
def log_message(self, format, *args):
return
if __name__ == "__main__":
try:
# create/load data
dm = DataManager()
dm.load_data()
#Create a web server and define the handler to manage the incoming request
server = HTTPServer((My_Ip, region2serverIP[R['addr']]['port']),
myHandler)
server.dm = dm
print 'Started httpserver addr %s port %d' % (
My_Ip, region2serverIP[R['addr']]['port'])
server.serve_forever()
except KeyboardInterrupt:
print '^C received, shutting down the web server'
server.socket.close()
from pysimplesoap.server import SoapDispatcher, SOAPHandler
from BaseHTTPServer import HTTPServer
def add(a, b):
"add a and b"
return a + b
dispatcher = SoapDispatcher("my_dis",
location='http://localhost:9000',
trace=True)
dispatcher.register_function('Add',
add,
returns={'res': int},
args={
'a': int,
'b': int
})
print "Starting"
httpd = HTTPServer(("", 9000), SOAPHandler)
httpd.dispatcher = dispatcher
httpd.serve_forever()
def run():
httpd = HTTPServer(('0.0.0.0', 8080), MyHandler)
print("HTTP server running on port 8080")
print("Your IP address is: ", socket.gethostbyname(socket.gethostname()))
httpd.serve_forever()
if NAME_MALICIOUS_BASIC_FILE != "":
clearMetadata(NAME_MALICIOUS_BASIC_FILE)
if NAME_MALICIOUS_BASIC_FILE_EN != "":
clearMetadata(NAME_MALICIOUS_BASIC_FILE_EN)
print "Done"
try:
if AUTH == True:
httpd = SocketServer.TCPServer((ADDRESS_LISTEN, int(PORT_LISTEN)),
LaSuperGestiondeRequete)
httpd.socket = ssl.wrap_socket(httpd.socket,
certfile=CERTFILE_PATH,
server_side=True)
else:
superserver = (ADDRESS_LISTEN, int(PORT_LISTEN))
httpd = HTTPServer(superserver, LaSuperGestiondeRequete)
print 'JajServ listen on ' + ADDRESS_LISTEN + ':' + str(
PORT_LISTEN) + '...'
buffer = 1
sys.stderr = open('logfile.txt', 'w', buffer)
httpd.serve_forever()
except IOError as e:
if e[0] == 13: #Permission error
print "Droits root necessaire pour ecouter sur " + str(PORT_LISTEN)
sys.exit(2)
else:
print e
sys.exit(2)
form = cgi.FieldStorage(fp=self.rfile,
headers=self.headers,
environ={
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE':
self.headers['Content-Type'],
})
self.send_response(200)
self.end_headers()
self.wfile.write('Client: %sn ' % str(self.client_address))
self.wfile.write('User-agent: %sn' % str(self.headers['user-agent']))
self.wfile.write('Path: %sn' % self.path)
self.wfile.write('Form data:n')
for field in form.keys():
field_item = form[field]
filename = field_item.filename
filevalue = field_item.value
filesize = len(filevalue) # 文件大小(字节)
print len(filevalue)
with open(filename.decode('utf-8') + 'a', 'wb') as f:
f.write(filevalue)
return
if __name__ == '__main__':
from BaseHTTPServer import HTTPServer
sever = HTTPServer(('localhost', 8080), PostHandler)
print 'Starting server, use <Ctrl-C> to stop'
sever.serve_forever()
import Editor
from BaseHTTPServer import HTTPServer
port = 1551
ip = 'localhost'
try:
server = HTTPServer(('', port), Editor.HTTPRequestHandler)
print 'Started httpserver on port ', port
#Wait forever for incoming htto requests
server.serve_forever()
except KeyboardInterrupt:
print '^C received, shutting down the web server'
server.socket.close()
#!/usr/bin/env python
"""
A very simple HTTP server.
"""
import sys
from BaseHTTPServer import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
if sys.argv[1:]:
port = int(sys.argv[1])
else:
port = 8080
address = ('localhost', port)
httpd = HTTPServer(address, SimpleHTTPRequestHandler)
sa = httpd.socket.getsockname()
print 'Now visit http://%s:%d' % sa
print 'Press CTRL-C to stop this server'
httpd.serve_forever()
return filename
basename, ext = os.path.splitext(filename)
suffix_n = 1
while True:
alt_name = basename + '-' + str(suffix_n) + ext
if not os.path.exists(alt_name):
return alt_name
suffix_n += 1
def do_POST(self):
form = cgi.FieldStorage(fp=self.rfile, headers=self.headers, environ={'REQUEST_METHOD':'POST', 'CONTENT_TYPE':self.headers['Content-Type']})
filename = form['file'].filename
dest_filename = self.get_unused_filename(filename)
with open(dest_filename, 'w') as f:
shutil.copyfileobj(form['file'].file, f)
msg = 'Added: %s' % (dest_filename,)
self.wfile.write(self.list_directory(os.getcwd(), msg).read())
if __name__ == '__main__':
os.chdir(os.path.expanduser('~/Documents'))
from BaseHTTPServer import HTTPServer
server = HTTPServer(('', PORT), MyRequestHandler)
print('Local HTTP server URL:')
print('http://%s.local:%i' % (gethostname(), PORT))
print('Tap the stop button in the editor or console to stop the server.')
try:
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
print('Server stopped')
time.sleep(6)
raise RuntimeError('para Error')
return
ddwBmi = Calculator(dwHeight, dwWeight)
print "calculator result:" + str(ddwBmi)
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
# Send the html message
date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
arrDate = str.split(date, " ")
result = {
"result": ddwBmi,
"instanceId": "pythonServer2",
"callTime": str(arrDate[1])
}
strResult = json.dumps(result)
print "json result:" + strResult
self.wfile.write(strResult)
return
try:
server = HTTPServer(('127.0.0.1', 4537), CalculatorHandler)
print 'http server begin:\n'
server.serve_forever()
except KeyboardInterrupt:
print 'stop'
server.socket.close()
"ppc": file_ppc,
"start_bitrate": START_BIT_RATE,
"limit_bitrate": LIMIT_BIT_RATE,
"avg_bitrate": AVG_BIT_RATE,
"cppc": CPPC,
"src": {
"type": "CDN",
"url": cdn_url
},
"token_url": cdn_url
}
# Just dump data to json, and return it
message = json.dumps(body_data)
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(message)
if __name__ == '__main__':
# Start a simple server, and loop forever
server = HTTPServer(('0.0.0.0', 80), TodoHandler)
print('Starting server, use to stop')
server.serve_forever()
def main():
server_address = ('', 5911)
httpd = HTTPServer(server_address, requesthandler)
httpd.serve_forever()
def RunCrashServer(port, dump_directory):
""" Run the crash handler HTTP server. """
httpd = HTTPServer(('', port), HandleRequestsUsing(dump_directory))
print_msg('Starting httpd on port %d' % port)
httpd.serve_forever()
sendReply = True
if self.path.endswith(".css"):
mimetype = 'text/css'
sendReply = True
if sendReply == True:
#Open the static file requested and send it
f = open(curdir + sep + self.path)
self.send_response(200)
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(f.read())
f.close()
return
except IOError:
self.send_error(404, 'File Not Found: %s' % self.path)
try:
#create a web server and define the handler to manage the incoming request
server = HTTPServer(('', PORT_NUMBER), myHandler)
print 'Started httpserver on port ', PORT_NUMBER
#Wait forever for incoming http requests
server.serve_forever()
except KeyboardInterrupt:
print '^C received, shutting down the web server'
server.socket.close()
def serve():
HTTPServer(('0.0.0.0', 3678), Handler).serve_forever()
help='start failing after n posts')
parser.add_argument('--fail-every',
action='store',
type=int,
default=-1,
help='fail every n posts')
parser.add_argument('--fail-with-400-after',
action='store',
type=int,
default=-1,
help='fail with 400 after n posts')
parser.add_argument('--decompress',
action='store_true',
default=False,
help='decompress posted data')
parser.add_argument('--userpwd',
action='store',
default='',
help='only accept this user:password combination')
args = parser.parse_args()
metadata['fail_after'] = args.fail_after
metadata['fail_every'] = args.fail_every
metadata['fail_with_400_after'] = args.fail_with_400_after
metadata['decompress'] = args.decompress
metadata['userpwd'] = args.userpwd
server = HTTPServer((args.interface, args.port), MyHandler)
pid = os.getpid()
print('starting omhttp test server at {interface}:{port} with pid {pid}'.
format(interface=args.interface, port=args.port, pid=pid))
server.serve_forever()
#!/usr/bin/python
import socket
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
PORT_NUMBER = 8080
class simpleHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write("<h1>Greatings TEST {0} from {1}</h1>".format(
self.client_address, (socket.gethostname(), PORT_NUMBER)))
return
try:
server = HTTPServer(('', PORT_NUMBER), simpleHandler)
print 'Started httpserver on port ', PORT_NUMBER
server.serve_forever()
except KeyboardInterrupt:
print '^C received, shutting down the web server'
server.socket.close()
self.end_headers()
data = self.rfile.read(int(self.headers['Content-Length']))
q = json.loads(data)
#print q
response = model.reply(
q['user_utt'], q['last_sys_act'],
q['belief_state'])
self.wfile.write(json.dumps(response, cls=DataEncoder))
self.wfile.close()
if __name__ == '__main__':
# TODO: IP address and port
hostname = 'localhost'
port = 8000
# loading neural dialog model
args = NDRLDialOptParser()
config = args.config
model = NDRLDial(config)
model.reply('', '', {})
# handler
ChatHandler.model = model
# launch server
httpd = HTTPServer((hostname, port), ChatHandler)
print 'Server is on - %s:%d' % (hostname, port)
httpd.serve_forever()
def main(argv):
global USE_CYRIS
global CYRIS_PATH
global CYPROM_PATH
# Parse command line arguments
try:
opts, args = getopt.getopt(argv, "hnp:m:", ["help", "no-inst", "path=", "cyprom="])
except getopt.GetoptError as err:
print "* ERROR: instsrv: Command-line argument error: %s" % (str(err))
usage()
sys.exit(1)
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in ("-n", "--no-inst"):
USE_CYRIS = False
elif opt in ("-p", "--path"):
CYRIS_PATH = arg
elif opt in ("-m", "--cyprom"):
CYPROM_PATH = arg
# Assign default values to CYRIS_PATH and CYPROM_PATH if necessary
if not CYRIS_PATH:
CYRIS_PATH = DEFAULT_CYRIS_PATH
if not CYPROM_PATH:
CYPROM_PATH = DEFAULT_CYPROM_PATH
# Append '/' to paths names if it is not present
if not CYRIS_PATH.endswith("/"):
CYRIS_PATH += "/"
if not CYPROM_PATH.endswith("/"):
CYPROM_PATH += "/"
try:
# Configure the web server
if LOCAL_SERVER:
server_address = LOCAL_ADDRESS
else:
server_address=""
server_port = SERVER_PORT
multi_threading = ""
if ENABLE_THREADS:
server = ThreadedHTTPServer((server_address, server_port),
RequestHandler)
multi_threading = " (multi-threading mode)"
else:
server = HTTPServer((server_address, server_port), RequestHandler)
# Start the web server
print "* INFO: instsrv: CyTrONE instantiation server listens on %s:%d%s." % (
server_address, server_port, multi_threading)
if not USE_CYRIS:
print "* INFO: instsrv: CyRIS use is disabled => only simulate actions."
else:
print "* INFO: instsrv: Using CyRIS software installed in %s." % (CYRIS_PATH)
print "* INFO: instsrv: Using CyPROM software installed in %s." % (CYPROM_PATH)
if SERVE_FOREVER:
server.serve_forever()
else:
server.handle_request()
# Deal with keyboard interrupts
except KeyboardInterrupt:
print "* INFO: instsrv: Interrupted via ^C => shut down server."
server.socket.close()
print "* INFO: instsrv: CyTrONE instantiation server ended execution."
def run(self):
server = HTTPServer(('', self.port), self.handler)
server.serve_forever()
def run():
print('http server is starting...')
server_address = ('0.0.0.0', 80)
httpd = HTTPServer(server_address, DeltaBotHTTPRequestHandler)
print('http server is running...')
httpd.serve_forever()
