def main():
network = Network()
httpThread = HttpServer(network)
webSocketThread = WebSocketServer(network)
webSocketThread.start()
httpThread.start()
def __init__(self): self.Logs = Logs(self) self.Configs = Configs(self) self.DataUnits = DataUnits(self) self.HttpClient = HttpClient(self) self.HttpServer = HttpServer(self) self.Manipulator = Manipulator(self)
def __init__(self):
self.sta_if = WLAN(STA_IF)
self.settings = Settings().load()
self.credentials = Credentials().load()
self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id))
self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id)
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/action/previous": self.previous,
b"/action/next": self.next,
b"/settings/values": self.settings_values,
b"/settings/net": self.settings_net,
b"/settings/group": self.settings_group,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
self.sign = Sign()
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.run_forever()
self.loop.close()
def __init__(self):
self.sta_if = WLAN(STA_IF)
self.settings = Settings().load()
self.credentials = Credentials().load()
self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id))
self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id)
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/settings/values": self.settings_values,
b"/settings/net": self.settings_net,
b"/settings/group": self.settings_group,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
self.display = Display()
self.ntp = NtpTime()
self.previous_hour1 = self.previous_hour2 = -1
self.previous_minute1 = self.previous_minute2 = -1
self.previous_second2 = self.previous_count = -1
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.create_task(self.update_time())
self.loop.run_forever()
self.loop.close()
def http_start_server(self, generate_html):
# inicia o servidor
self.http_server = HttpServer()
self.http_server.start()
if generate_html == True:
# cria páginas
html = Html()
html.create_index()
pass
def run_server():
server_address = ('', 8080)
server = HttpServer(server_address, 20)
# stream service object
thread = threading.Thread(group=None, target=server.serve_forever)
thread.start()
input('Press ENTER to stop server')
# stop server
server.shutdown()
while thread.is_alive():
thread.join(3.0)
if thread.is_alive():
x = input('Server is running, do you want wait? [Y/N]: ')
if x == 'N' or x == 'n':
break
def main():
#Setup
server = HttpServer("192.168.87.110", debug=False)
drive = DifferentialDrive(2, 0, 4, 16)
def mainLoop():
while True:
x, y = server.getJoystick()
drive.setInput(x, y)
drive.Update()
yield int(10)
loop = asyncio.get_event_loop()
loop.create_task(mainLoop())
server.start()
def start_http_server(self):
from HttpServer import HttpServer
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/settings/set-eco-mode": self.set_eco_mode,
b"/settings/values": self.settings_values,
b"/settings/shutdown-ap": self.shutdown_ap,
b"/settings/connected": self.connected,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
def __init__(self):
self.sta_if = WLAN(STA_IF)
self.settings = Settings(state=b"%s" % State.CLOCK).load()
self.credentials = Credentials().load()
self.tags = Tags().load()
self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id))
self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id)
self.mqtt = MqttManager(self.mdns, BROKER_NAME, self.settings.net_id,
MQTT_TOPIC_NAME)
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/action/color": self.set_color,
b"/action/clock/display": self.display_clock,
b"/action/brightness": self.set_brightness,
b"/action/scoreboard/display": self.display_scoreboard,
b"/action/scoreboard/green/more": self.scoreboard_green_more,
b"/action/scoreboard/green/less": self.scoreboard_green_less,
b"/action/scoreboard/red/more": self.scoreboard_red_more,
b"/action/scoreboard/red/less": self.scoreboard_red_less,
b"/action/scoreboard/reset": self.scoreboard_reset,
b"/settings/values": self.settings_values,
b"/settings/net-id": self.settings_net_id,
b"/settings/ssids": self.get_ssids,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
self.clock = Clock(self.settings.color)
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.create_task(self.check_mqtt())
self.loop.create_task(self.send_state())
self.loop.run_forever()
self.loop.close()
def __init__(self):
self.sta_if = WLAN(STA_IF)
self.settings = Settings().load()
self.credentials = Credentials().load()
# self.udps = UdpServer()
self.switch1 = Pin(PIN_SWITCH_1, Pin.OUT)
self.switch2 = Pin(PIN_SWITCH_2, Pin.OUT)
if self.settings.state1 == b"1":
self.switch1.on()
if self.settings.state2 == b"1":
self.switch2.on()
self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id))
self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id)
self.mqtt = MqttManager(
self.mdns, BROKER_NAME, self.settings.net_id, MQTT_TOPIC_NAME
)
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/action/toggle": self.toggle,
b"/settings/values": self.settings_values,
b"/settings/net": self.settings_net,
b"/settings/ssids": self.get_ssids,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.create_task(self.check_mqtt())
self.loop.create_task(self.send_state())
self.loop.run_forever()
self.loop.close()
def __init__(self):
self.sta_if = WLAN(STA_IF)
self.settings = Settings().load()
self.credentials = Credentials().load()
self.tags = Tags().load()
self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id))
self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id)
self.mqtt = MqttManager(
self.mdns, BROKER_NAME, self.settings.net_id, MQTT_TOPIC_NAME
)
routes = {
b"/": b"./index.html",
b"/index.html": b"./index.html",
b"/scripts.js": b"./scripts.js",
b"/style.css": b"./style.css",
b"/favicon.ico": self.favicon,
b"/connect": self.connect,
b"/action/go-up": self.go_up,
b"/action/go-down": self.go_down,
b"/action/stop": self.stop,
b"/settings/values": self.settings_values,
b"/settings/net-id": self.settings_net_id,
b"/settings/reverse-motor": self.reverse_motor,
b"/settings/ssids": self.get_ssids,
}
self.http = HttpServer(routes)
print("> HTTP server up and running")
self.motor = Motor()
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.create_task(self.check_mqtt())
self.loop.create_task(self.send_state())
self.loop.run_forever()
self.loop.close()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle('Our api')
self.httpd = HttpServer()
self.httpd.request_text_change.connect(self.add_to_request)
self.httpd.client_text_change.connect(self.add_to_client)
self.httpd.response_text_change.connect(self.add_to_response)
self.httpd.start()
self.ui.saveSession.clicked.connect(self.save_session)
self.ui.resetSession.clicked.connect(self.reset_session)
self.ui.testClientGet.clicked.connect(self.run_test_client_get)
self.ui.testClientPost.clicked.connect(self.run_test_client_post)
self.ui.apiSummary.clicked.connect(self.show_api)
self.session_string = ''
self.ui.requestText.setReadOnly(True)
self.ui.clientText.setReadOnly(True)
self.ui.responseText.setReadOnly(True)
def main():
my_server = HttpServer(IP, PORT, ROOT_DIR)
# able to have endless connections!!!
while True:
my_server.run_server()
def startup(args: argparse.Namespace, **kwargs: Dict[str, Any]) -> None:
global announce, dispatcher, group, httpServer, notification, validator
global registration, remote, security, statistics, storage, event
global rootDirectory
global aeStatistics
rootDirectory = os.getcwd() # get the root directory
os.environ[
"FLASK_ENV"] = "development" # get rid if the warning message from flask.
# Hopefully it is clear at this point that this is not a production CSE
# Handle command line arguments and load the configuration
if args is None:
args = argparse.Namespace(
) # In case args is None create a new args object and populate it
args.configfile = None
args.resetdb = False
args.loglevel = None
for key, value in kwargs.items():
args.__setattr__(key, value)
if not Configuration.init(args):
return
# init Logging
Logging.init()
Logging.log('============')
Logging.log('Starting CSE')
Logging.log('CSE-Type: %s' % C.cseTypes[Configuration.get('cse.type')])
Logging.log(Configuration.print())
# Initiatlize the resource storage
storage = Storage()
# Initialize the event manager
event = EventManager()
# Initialize the statistics system
statistics = Statistics()
# Initialize the registration manager
registration = RegistrationManager()
# Initialize the resource validator
validator = Validator()
# Initialize the resource dispatcher
dispatcher = Dispatcher()
# Initialize the security manager
security = SecurityManager()
# Initialize the HTTP server
httpServer = HttpServer()
# Initialize the notification manager
notification = NotificationManager()
# Initialize the announcement manager
announce = AnnouncementManager()
# Initialize the group manager
group = GroupManager()
# Import a default set of resources, e.g. the CSE, first ACP or resource structure
importer = Importer()
if not importer.importResources():
return
# Initialize the remote CSE manager
remote = RemoteCSEManager()
remote.start()
# Start AEs
startAppsDelayed(
) # the Apps are actually started after the CSE finished the startup
# Start the HTTP server
event.cseStartup() # type: ignore
Logging.log('CSE started')
httpServer.run() # This does NOT return
def __init__(self, host='localhost', port=8080):
callback = self.route
self.domain_rotation = 0
self.httpClient = None
self.httpserver = HttpServer(callback, host, port)
from HttpServer import HttpServer, BaseHandler
import json
def index(req):
return "Hello World, this is jimwu."
def iterator2(req):
if not req.has_key("param"):
return "{}"
if req["METHOD"] == "GET":
return json.dumps(req["param"])
elif req["METHOD"] == "POST":
import time
p = req["param"]
p["time"] = time.time()
return json.dumps(p)
else:
return "{}"
BaseHandler.parten = {
"/": index,
"/iterator2": iterator2,
}
if __name__ == '__main__':
server = HttpServer("", 8080, BaseHandler)
server.startServer()
import sys
sys.path.append("..") # TODO 如何更优雅的导入顶层包到 sys.path ???
import wx
from View.MainFrame import MainFrame
from View.LoginDialog import LoginDialog
from HttpServer import HttpServer
class Application(wx.App):
def OnInit(self):
self.MainFrame = MainFrame(None)
self.LoginDialog = LoginDialog(self.MainFrame)
LoginResult = self.LoginDialog.ShowModal()
if LoginResult == 1:
self.MainFrame.Show()
self.SetTopWindow(self.MainFrame)
return True
else:
return False
if __name__ == '__main__':
server = HttpServer('0.0.0.0', 8080)
print 'HTTP Server Running...........'
server.start()
app = Application(redirect=False)
app.MainLoop()
server.stop()
from HttpServer import HttpServer
from HttpProxyServer import HttpProxyServer
from HttpProxyServer import ProxyAnalyzer
import atexit
if __name__ == "__main__":
httpServer = HttpServer(8080)
analyzer = ProxyAnalyzer(8091)
proxy_server = HttpProxyServer(8090, analyzer)
try:
analyzer.setDaemon(True)
analyzer.start()
atexit.register(analyzer.stop)
proxy_server.setDaemon(True)
proxy_server.start()
httpServer.setDaemon(True)
httpServer.start()
atexit.register(httpServer.stop)
atexit.register(proxy_server.stop)
httpServer.join()
proxy_server.join()
analyzer.join()
except KeyboardInterrupt:
pass
finally:
exit(0)
from HttpServer import HttpServer
from rip.RIPOctave import RIPOctave
if __name__ == '__main__':
HttpServer(
host='127.0.0.1',
port=2055,
control=RIPOctave(
name='Octave',
description='An implementation of RIP to control Octave',
authors='D. Garcia, J. Chacon',
keywords='Octave, Raspberry PI, Robot',
),
).start()
def startup(args: argparse.Namespace, **kwargs: Dict[str, Any]) -> None:
global announce, dispatcher, group, httpServer, notification, validator
global registration, remote, request, security, statistics, storage, event
global rootDirectory
global aeStatistics
global supportedReleaseVersions, cseType, defaultSerialization, cseCsi, cseRi, cseRn
global cseOriginator
global isHeadless
rootDirectory = os.getcwd() # get the root directory
os.environ[
"FLASK_ENV"] = "development" # get rid if the warning message from flask.
# Hopefully it is clear at this point that this is not a production CSE
# Handle command line arguments and load the configuration
if args is None:
args = argparse.Namespace(
) # In case args is None create a new args object and populate it
args.configfile = None
args.resetdb = False
args.loglevel = None
args.headless = False
for key, value in kwargs.items():
args.__setattr__(key, value)
isHeadless = args.headless
if not Configuration.init(args):
return
# Initialize configurable constants
supportedReleaseVersions = Configuration.get(
'cse.supportedReleaseVersions')
cseType = Configuration.get('cse.type')
cseCsi = Configuration.get('cse.csi')
cseRi = Configuration.get('cse.ri')
cseRn = Configuration.get('cse.rn')
cseOriginator = Configuration.get('cse.originator')
defaultSerialization = Configuration.get('cse.defaultSerialization')
# init Logging
Logging.init()
if not args.headless:
Logging.console('Press ? for help')
Logging.log('============')
Logging.log('Starting CSE')
Logging.log(f'CSE-Type: {cseType.name}')
Logging.log('Configuration:')
Logging.log(Configuration.print())
# Initiatlize the resource storage
storage = Storage()
# Initialize the event manager
event = EventManager()
# Initialize the statistics system
statistics = Statistics()
# Initialize the registration manager
registration = RegistrationManager()
# Initialize the resource validator
validator = Validator()
# Initialize the resource dispatcher
dispatcher = Dispatcher()
# Initialize the request manager
request = RequestManager()
# Initialize the security manager
security = SecurityManager()
# Initialize the HTTP server
httpServer = HttpServer()
# Initialize the notification manager
notification = NotificationManager()
# Initialize the group manager
group = GroupManager()
# Import a default set of resources, e.g. the CSE, first ACP or resource structure
# Import extra attribute policies for specializations first
importer = Importer()
if not importer.importAttributePolicies() or not importer.importResources(
):
return
# Initialize the remote CSE manager
remote = RemoteCSEManager()
# Initialize the announcement manager
announce = AnnouncementManager()
# Start AEs
startAppsDelayed(
) # the Apps are actually started after the CSE finished the startup
# Start the HTTP server
event.cseStartup() # type: ignore
httpServer.run() # This does return (!)
Logging.log('CSE started')
if isHeadless:
# when in headless mode give the CSE a moment (2s) to experience fatal errors before printing the start message
BackgroundWorkerPool.newActor(
delay=2,
workerCallback=lambda: Logging.console('CSE started')
if not shuttingDown else None).start()
#
# Enter an endless loop.
# Execute keyboard commands in the keyboardHandler's loop() function.
#
commands = {
'?': _keyHelp,
'h': _keyHelp,
'\n': lambda c: print(), # 1 empty line
'\x03': _keyShutdownCSE, # See handler below
'c': _keyConfiguration,
'C': _keyClearScreen,
'D': _keyDeleteResource,
'i': _keyInspectResource,
'l': _keyToggleLogging,
'Q': _keyShutdownCSE, # See handler below
'r': _keyCSERegistrations,
's': _keyStatistics,
't': _keyResourceTree,
'T': _keyChildResourceTree,
'w': _keyWorkers,
}
# Endless runtime loop. This handles key input & commands
# The CSE's shutdown happens in one of the key handlers below
loop(commands, catchKeyboardInterrupt=True, headless=args.headless)
shutdown()
import importlib
from HttpServer import HttpServer
from AppConfig import config
def load_control(control):
module_name = 'rip.%s' % control['impl_module']
module = importlib.import_module(module_name)
control_name = control.get('impl_name', control['impl_module'])
RIPControl = getattr(module, control_name)
info = config['control']['info']
return RIPControl(info)
if __name__ == "__main__":
control = load_control(config['control'])
HttpServer(
host=config['server']['host'],
port=config['server']['port'],
control=control
).start(enable_ssl=False)
from HttpServer import HttpServer
import socket
if __name__ == "__main__":
IP_ADDRESS = socket.gethostbyname(socket.gethostname())
LOCALHOST = "127.0.0.1"
print("Do you want to run this on localhost or your IP?")
print("[1] My IP -", IP_ADDRESS + ":8000")
print("[2] localhost -", LOCALHOST + ":8000")
choice = input()
if choice == "1":
BIND_IP = IP_ADDRESS
elif choice == "2":
BIND_IP = LOCALHOST
else:
print("That is not a valid option!")
server = HttpServer(bind_ip=BIND_IP)
server.start()
