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, port = -1): self.state = State() self.__eventHandler = AmarokEventHandler(self.state) if port == -1: self.__httpServer = HttpServer(self.state) else: self.__httpServer = HttpServer(self.state, port) signal.signal(signal.SIGINT, self.__exit_signal_handler) signal.signal(signal.SIGKILL, self.__exit_signal_handler) signal.signal(signal.SIGTERM, self.__exit_signal_handler)
class Main: 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 start(self): self.HttpServer.start()
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 __init__(self): self.state = State() self.__eventHandler = AmarokEventHandler(self.state) self.__httpServer = HttpServer(self.state) signal.signal(signal.SIGINT, self.__exit_signal_handler) signal.signal(signal.SIGKILL, self.__exit_signal_handler) signal.signal(signal.SIGTERM, self.__exit_signal_handler)
def login_by_qrcode(self): logging.info("Requesting the login pages...") qrcode_path = self.sys_paras['qrcode_path'] if os.path.exists(qrcode_path): os.remove(qrcode_path) close_port(self.sys_paras['report_port']) self.http_server = HttpServer(self.sys_paras['report_port'], 'OK') thread.start_new_thread(self.wait_msg, ()) thread.start_new_thread(startMojoQQ, (self.sys_paras['qq_code'], self.sys_paras['report_port'], self.sys_paras['mojo_port'], qrcode_path, self)) wait_time = 300 detect_interval = 0.01 i = 0 while i < wait_time / detect_interval: if self.login_fail: return False elif self.login_ok: break elif self.login_input_qrcode: self.login_input_qrcode = False continue time.sleep(detect_interval) i += 1 r = requests.get('http://127.0.0.1:' + str(self.mojo_port) + '/openqq/get_user_info') if r.status_code != 200: return False try: r_data = json.loads(r.text) self.account = r_data['account'] self.username = r_data['nick'] except: return False logging.info("QQ:{0} login successfully, Username:{1}".format(self.account, self.username)) return True
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()
class Jukebox: def __exit_signal_handler(self, signal, frame): print "Exiting..." self.__eventHandler.stop() sys.exit(0) def __init__(self): self.__eventHandler = AmarokEventHandler() self.__httpServer = HttpServer() signal.signal(signal.SIGINT, self.__exit_signal_handler) signal.signal(signal.SIGKILL, self.__exit_signal_handler) signal.signal(signal.SIGTERM, self.__exit_signal_handler) def start(self): self.__t = threading.Thread(target = self.__eventHandler.start) self.__t.start() self.__httpServer.serve()
class Jukebox: def __exit_signal_handler(self, signal, frame): print "Exiting..." self.__eventHandler.stop() sys.getdefaultencoding = lambda: 'utf-8' sys.exit(0) def __init__(self, port = -1): self.state = State() self.__eventHandler = AmarokEventHandler(self.state) if port == -1: self.__httpServer = HttpServer(self.state) else: self.__httpServer = HttpServer(self.state, port) signal.signal(signal.SIGINT, self.__exit_signal_handler) signal.signal(signal.SIGKILL, self.__exit_signal_handler) signal.signal(signal.SIGTERM, self.__exit_signal_handler) def start(self): self.__t = threading.Thread(target = self.__eventHandler.start) self.__t.start() self.__httpServer.serve()
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 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().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(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.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()
class QQ: def __init__(self, sys_paras): self.sys_paras = sys_paras self.default_config = DefaultConfigs() self.last_refresh = time.time() self.refresh_interval = int(self.default_config.conf.get("global", "refresh_interval")) self.qrcode_path = sys_paras['qrcode_path'] if sys_paras['qrcode_path'] else self.default_config.conf.get("global", "qrcode_path") # QRCode保存路径 self.http_server = None self.mojo_on = False self.mojo_off = False self.account = None self.username = None self.login_ok = False self.login_fail = False self.login_input_qrcode = False self.login_input_qrcode_triggered = False self.msg_handler = None self.msg_list = [] self.mojo_port = int(self.sys_paras['mojo_port']) def login_by_qrcode(self): logging.info("Requesting the login pages...") qrcode_path = self.sys_paras['qrcode_path'] if os.path.exists(qrcode_path): os.remove(qrcode_path) close_port(self.sys_paras['report_port']) self.http_server = HttpServer(self.sys_paras['report_port'], 'OK') thread.start_new_thread(self.wait_msg, ()) thread.start_new_thread(startMojoQQ, (self.sys_paras['qq_code'], self.sys_paras['report_port'], self.sys_paras['mojo_port'], qrcode_path, self)) wait_time = 300 detect_interval = 0.01 i = 0 while i < wait_time / detect_interval: if self.login_fail: return False elif self.login_ok: break elif self.login_input_qrcode: self.login_input_qrcode = False continue time.sleep(detect_interval) i += 1 r = requests.get('http://127.0.0.1:' + str(self.mojo_port) + '/openqq/get_user_info') if r.status_code != 200: return False try: r_data = json.loads(r.text) self.account = r_data['account'] self.username = r_data['nick'] except: return False logging.info("QQ:{0} login successfully, Username:{1}".format(self.account, self.username)) return True def wait_msg(self): self.http_server.run(self.msg_process) def msg_process(self, data): try: lines = data.split('\n') uri = lines[1].split(' ')[1] msg = lines[-1] if (msg == "login ok"): self.login_ok = True return True elif (msg == "login failed"): self.login_fail = True return True elif (msg == "input qrcode"): self.login_input_qrcode = True return True msg = json.loads(msg) pm_list = [] sess_list = [] group_list = [] notify_list = [] ret_type = msg['type'] if ret_type == 'message' and False: pm_list.append(PmMsg(msg)) elif ret_type == 'group_message' and True: msg['group_code'] = self.get_group_info(gid=msg['group_id'])['gcode'] group_list.append(GroupMsg(msg)) elif ret_type == 'sess_message' and False: sess_list.append(SessMsg(msg)) elif ret_type == 'input_notify' and False: notify_list.append(InputNotify(msg)) elif ret_code == 'kick_message' and False: notify_list.append(KickMessage(msg)) else: logging.warning("unknown message type: " + str(ret_type) + "details: " + str(msg)) group_list.sort(key=lambda x: x.seq) self.msg_list += pm_list + sess_list + group_list + notify_list if not self.msg_list: return False return True except: logging.warning("An error has occured when handling message. Error traceback:\n" + traceback.format_exc()) return False return True def check_msg(self): if self.mojo_off: return None msg_list = [i for i in self.msg_list] msg_cnt = len(msg_list) if msg_cnt == 0: return [] else: self.msg_list = self.msg_list[msg_cnt:] return msg_list def sendGroupMessage(self, gid, content): r = requests.post("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/send_group_message", { 'gid': gid, 'content': content }) return (r.status_code == 200) def close(self): if self.mojo_on and not self.mojo_off: r = requests.get("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/close") if not r.status_code == 200: print "close mojo failed" try: self.lisfd.shutdown(socket.SHUT_RD) except: print "shutdown server failed" pass # 查询QQ号,通常首次用时0.2s,以后基本不耗时 def get_account(self, msg): assert isinstance(msg, (Msg, Notify)), "function get_account received a not Msg or Notify parameter." if isinstance(msg, (PmMsg, SessMsg, InputNotify)): # 如果消息的发送者的真实QQ号码不在FriendList中,则自动去取得真实的QQ号码并保存到缓存中 tuin = msg.from_uin account = self.uin_to_account(tuin) return account elif isinstance(msg, GroupMsg): return str(msg.info_seq).join("[]") + str(self.uin_to_account(msg.send_uin)) def uin_to_account(self, tuin): uin_str = str(tuin) r = requests.get("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/get_friend_info?id={0}".format(uin_str)) if r.status_code == 200: data = r.json() if not ('code' in data and data['code'] != 0): return data['qq'] return None # 查询详细信息 def get_friend_info(self, msg): # assert isinstance(msg, (Msg, Notify)), "function get_account received a not Msg or Notify parameter." assert isinstance(msg, (PmMsg, GroupMsg)), "function get_friend_info received a not PmMsg or GroupMsg parameter" tuin = "" # if isinstance(msg, (PmMsg, SessMsg, InputNotify)): if isinstance(msg, (PmMsg)): tuin = str(msg.from_uin) elif isinstance(msg, GroupMsg): tuin = str(msg.send_uin) else: return None r = requests.get("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/get_friend_info?id={0}".format(tuin)) if r.status_code == 200: data = r.json() if not ('code' in data and data['code'] != 0): return data return None # 查询群信息 def get_group_info(self, msg = None, gid = None, gcode = None): query_str = "" if msg: gcode = str(msg.group_code) query_str += "gcode={0}".format(gcode) elif gid: query_str += "gid={0}".format(gid) elif gcode: query_str += "gcode={0}".format(gcode) else: return None r = requests.get("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/get_group_info?" + query_str) if r.status_code == 200: data = r.json() if not ('code' in data and data['code'] != 0): data['nid'] = "{0}_{1}".format(self.uin_to_account(data['gowner']), data['gcreatetime']) return data return None def get_groupnames(self): r = requests.get("http://127.0.0.1:" + str(self.mojo_port) + "/openqq/get_group_info") if r.status_code == 200: data = r.json() if not ('code' in data and data['code'] != 0): return [{ "name": item['gname'], "code": item['gcode']} for item in data] return None
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();
class MainWindow(QMainWindow): 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 add_to_request(self, request_text): request_type, request_string = request_text.split(',') self.ui.requestText.setText(request_string) request_log = f"""\n\n ################### NEW REQUEST ################### \t{request_string}\t ################################################### """ self.session_string += request_log def add_to_client(self, client_text): self.ui.clientText.setText(client_text) request_log = f"Client details\n{client_text}\n" self.session_string += request_log def add_to_response(self, response_text): self.ui.responseText.setText(response_text) request_log = f"\nResponse\n{response_text}\n\n" self.session_string += request_log def save_session(self): file_name, _ = QFileDialog.getSaveFileName(self, "Session File", "", "Text Files (*.txt)") if file_name: with open(file_name, "w") as session_file: session_file.write(self.session_string) def reset_session(self): self.session_string = '' self.ui.requestText.clear() self.ui.clientText.clear() self.ui.responseText.clear() def run_test_client_get(self): get_client = ClientGet(self) get_client.setModal(False) get_client.show() def run_test_client_post(self): post_client = ClientPost(self) post_client.setModal(False) post_client.show() def show_api(self): definitions = Definitions('definitions.ini') definitions.load() api_dialog = ApiDialog(self, definitions.definitions_dict) api_dialog.setWindowTitle('API Functions') api_dialog.setModal(False) api_dialog.show()
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()
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()
class Main: ''' Collects data from a specified year ano - year of the data to be collected ''' def collect_data(self, ano): bd = BaseDados() print "STARTED COLLECTING DATA FOR YEAR", ano bd.criar_tabelas() bd.preencher_tipos_estabelecimento(ano) bd.preencher_tabelas_gerais(ano) print "FINISHED COLLECTING DATA FOR YEAR", ano pass pass #--------------------------------- # Constroi as estatisticas # # years - anos para gerar estatisticas # groupby - campos pelos quais são agrupadas # count - o que contar #--------------------------------- def get_statistics(self, years, groupby, count): bd = Dados() # transforma os elementos de years activos em string filtered_years = self.filter_active(years) # transforma os elementos de groupby activos em string filtered_groupby = self.filter_active(groupby) # constroi o título a dar ao gráfico title = """Total number of {0} for years {1} grouped by {2}""".\ format(count + 's', ','.join(['200' + str(i) for i in filtered_years]), ','.join([str(i) for i in filtered_groupby])) # se tudo estiver bem gera gráfico data = bd.get_statistics(filtered_years, filtered_groupby, count) # adiciona a página à bd db = BaseDados() file_name = db.insert_custom_list(title, 1) # Cria a página HTML com a estatistica html = Html() html.create_statistics_page(title, data, filtered_groupby, file_name) # cria o ficheiro CSV csv = CriarCSV() csv.escrita_csv(title, file_name, data) # gera o gráfico graph = Graphs(data, title) pass pass #-------------------------- # Retorna uma lista com os itens que tenham a segunda posição a True # # list_to_be_filtered - lista a ser filtrada #-------------------------- def filter_active(self, list_to_be_filtered): # cria a lista a ser devolvida filtered_list = [] # se o item for True adiciona à lista a ser devolvida for l in list_to_be_filtered: if l[1] == True: filtered_list.append(l[0]) pass pass # altera a ordem da lista filtered_list.reverse() # retorna a lista filtrada return filtered_list pass #--------------------------- # Menu estatisticas #--------------------------- def get_lists(self, select, years): print "get_lists" # transforma os elementos de years activos em string filtered_years = self.filter_active(years) # transforma os elementos de groupby activos em string filtered_select = self.filter_active(select) # constroi o título a dar à lista title = """List of {0} for years {1}""".\ format(','.join([str(i) for i in filtered_select]), ','.join(['200' + str(i) for i in filtered_years])) # retorna os dados da base de dados bd = Dados() data = bd.get_lists(filtered_select, filtered_years) # adiciona a página à bd db = BaseDados() file_name = db.insert_custom_list(title, 0) # cria o ficheiro CSV csv = CriarCSV() csv.escrita_csv(title, file_name, data) # Cria a página HTML com a estatistica html = Html() html.create_lists_page(title, data, filtered_select, file_name) pass pass #--------------------------- # Menu HTTP # # generate_html - if true generates HTML #--------------------------- # Inicia o servidor http 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 pass # Pára o servidor http def http_stop_server(self): self.http_server.stop() pass pass
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()
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)
def main(): my_server = HttpServer(IP, PORT, ROOT_DIR) # able to have endless connections!!! while True: my_server.run_server()
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()