def run(ip, port, new_key, sleep_time): # 获取当前使用的rc4加密key rc4_key = get_rc4_key(new_key) Log.log_message( '[*]server cipher key: {}'.format(BOLD(rc4_key)), log_type=Log.SERVER) # 启动http监听服务 session = Session() shell = Shell(session) httpd = Server(ip, port, JSCatServer, session, shell, rc4_key, sleep_time) httpd.start() Log.log_message( '[*]server running in {}:{}...'.format(BOLD('0.0.0.0'), BOLD(port)), log_type=Log.SERVER) Log.log_message( '[*]host connect ip is {}:{}...'.format(BOLD(ip), BOLD(port)), log_type=Log.SERVER) print_online_cmd(ip, port) # 控制台命令输入 try: while True: if not httpd.shell.get_command(): httpd.shutdown() exit() except KeyboardInterrupt: httpd.shutdown() Log.log_message('server shutdown', log_type=Log.SERVER)
def run(cmdArguments): # 获取当前使用的rc4加密key rc4_key = get_rc4_key(cmdArguments.get('new_key')) Log.log_message( '[*]server cipher key: {}'.format(BOLD(rc4_key)), log_type=Log.SERVER) cmdArguments['new_key'] = rc4_key # 启动http监听服务 host = cmdArguments['host'] port = int(cmdArguments['port']) httpd = Server(cmdArguments) httpd.start() Log.log_message( '[*]host connect ip is {}:{}...'.format(BOLD(host), BOLD(port)), log_type=Log.SERVER) print_online_cmd(host, port) # 控制台命令输入 try: while True: if not httpd.shell.get_command(): httpd.shutdown() exit() except KeyboardInterrupt: httpd.shutdown() Log.log_message('server shutdown', log_type=Log.SERVER)
def gen_server(self): try: return Server(self.ini, test_suite=self) except Exception as e: print e raise RuntimeError("Unknown server: core = {0}".format( self.ini["core"]))
def start(self): pid = self.read_pid() if pid: log.error(u"Server already running, pid %s." % pid) sys.exit(-1) else: self.write_pid(os.getpid()) server = None try: time.sleep(0.001) server = Server((Config.hostname, self.port)) log.info(u"Bloops and bleeps at http://%s:%s" % server.server_address) server.serve_forever() # will never reach this line except socket.error, se: if se.errno == errno.EACCES: log.warn(u"Bad port: %s" % self.port) sys.exit(se.errno) elif se.errno == errno.ECONNREFUSED: log.warn(u"Connection refused: %s" % self.port) sys.exit(se.errno) else: log.exception(se)
def main(): """ Main. :return: """ global hup_flag, quit_flag logging.basicConfig( format= "%(asctime)s %(levelname)s %(name)s: %(message)s {%(filename)s:%(funcName)s:%(lineno)s}", level=logging.DEBUG) register_signals() parser = ArgumentParser() parser.add_argument("-f", "--config", help="Config file", default="/etc/mon/probe.conf", dest="config") args = parser.parse_args() server = None while not quit_flag: if hup_flag: try: cf = ConfigParser() try: cf.read_file(open(args.config, "r"), args.config) except FileNotFoundError as e: logging.error( "Config file '%s' was not found. Not reconfiguring." % (e.filename, )) continue server = Server(cf.get("server", "Address")) services = Service.scan(cf.get("probe", "services")) server.register_probe(services) finally: hup_flag = False if server: mapped = server.get_mapped_services() responses = {} time_point = datetime.now() for service in mapped: responses[service.id] = service.fetch() server.update(responses, time_point) sleep()
def __init__(self, suite_path, args): """Initialize a test suite: check that it exists and contains a syntactically correct configuration file. Then create a test instance for each found test.""" self.args = args self.tests = [] self.ini = {} self.suite_path = suite_path self.ini["core"] = "tarantool" if os.access(suite_path, os.F_OK) == False: raise RuntimeError("Suite %s doesn't exist" % repr(suite_path)) # read the suite config config = ConfigParser.ConfigParser() config.read(os.path.join(suite_path, "suite.ini")) self.ini.update(dict(config.items("default"))) self.ini.update(self.args.__dict__) self.multi_run = self.get_multirun_conf(suite_path) if self.args.stress is None and self.ini['core'] == 'stress': return for i in ["script"]: self.ini[i] = os.path.join(suite_path, self.ini[i]) if i in self.ini else None for i in ["disabled", "valgrind_disabled", "release_disabled"]: self.ini[i] = dict.fromkeys( self.ini[i].split()) if i in self.ini else dict() for i in ["lua_libs"]: self.ini[i] = map( lambda x: os.path.join(suite_path, x), dict.fromkeys(self.ini[i].split()) if i in self.ini else dict()) try: if self.ini['core'] in ['tarantool', 'stress']: self.server = TarantoolServer(self.ini) else: self.server = Server(self.ini) self.ini["server"] = self.server except Exception as e: print e raise RuntimeError("Unknown server: core = {0}".format( self.ini["core"])) color_stdout("Collecting tests in ", schema='ts_text') color_stdout(repr(suite_path), schema='path') color_stdout(": ", self.ini["description"], ".\n", schema='ts_text') self.server.find_tests(self, suite_path) color_stdout("Found ", str(len(self.tests)), " tests.\n", schema='path')
def __init__(self): self.__root = Tk() self.__frame = Frame(self.__root) self.__label = Label(self.__frame) self.__chat = Label(self.__frame) self.__host = [(s.connect( ('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket(AF_INET, SOCK_DGRAM)]][0][1] self.__port = 9001 self.__server = Server(self.__host, self.__port) self.__server_thread = MyServerThread(self.__server, self.__chat)
def __init__(self, suite_path, args): """Initialize a test suite: check that it exists and contains a syntactically correct configuration file. Then create a test instance for each found test.""" self.args = args self.tests = [] self.ini = {} self.suite_path = suite_path self.ini["core"] = "tarantool" if os.access(suite_path, os.F_OK) == False: raise RuntimeError("Suite \"" + suite_path + \ "\" doesn't exist") # read the suite config config = ConfigParser.ConfigParser() config.read(os.path.join(suite_path, "suite.ini")) self.ini.update(dict(config.items("default"))) for i in ["config", "init_lua"]: self.ini[i] = os.path.join(suite_path, self.ini[i]) if i in self.ini else None for i in ["disabled", "valgrind_disabled", "release_disabled"]: self.ini[i] = dict.fromkeys( self.ini[i].split()) if i in self.ini else dict() for i in ["lua_libs"]: self.ini[i] = map( lambda x: os.path.join(suite_path, x), dict.fromkeys(self.ini[i].split()) if i in self.ini else dict()) try: self.server = Server(self.ini["core"]) self.ini["server"] = self.server except Exception as e: print e raise RuntimeError("Unknown server: core = {0}".format( self.ini["core"])) print "Collecting tests in \"" + suite_path + "\": " +\ self.ini["description"] + "." self.server.find_tests(self, suite_path) print "Found " + str(len(self.tests)) + " tests."
def run(ip, port, new_key, sleep_time): # 获取当前使用的rc4加密key rc4_key = get_rc4_key(new_key) print('[*]server encrypt key is {}'.format(BOLD(rc4_key))) # 启动http监听服务 session = Session() shell = Shell(session) httpd = Server(ip, port, JSCatServer, session, shell, rc4_key, sleep_time) httpd.start() print('[*]server running in {}:{}...'.format(BOLD(ip), BOLD(port))) print_online_cmd(ip, port) # 控制台命令输入 try: while True: if not httpd.shell.get_command(): httpd.shutdown() exit() except KeyboardInterrupt: httpd.shutdown() print('server shutdown')
def main(args): utils.clearscreen() try: if(len(args) == 2): config = ConfigParser.ConfigParser() config.read(args[1]) # Datos de servidor. s_host = config.get("SERVER", "Host") s_port = config.getint("SERVER", "Port") s_webdir = config.get("SERVER", "Webdir") s_idxdir = config.get("SERVER", "Idxpath") s_errdir = config.get("SERVER", "ErrPath") s_logdir = config.get("SERVER", "Logpath") elif len(args) == 7: s_host = args[1] s_port = int(args[2]) s_webdir = args[3] s_idxdir = args[4] s_errdir = args[5] s_logdir = args[6] else: print utils.msg_argv raw_input() sys.exit(0) # Inicio de servidor. server = Server(s_host, s_port, s_webdir, s_idxdir, s_errdir, s_logdir) server.start() except KeyboardInterrupt: pass except Exception, e: print utils.msg_file_not_found print e raw_input() sys.exit(0)
def main(): """Start the application""" server = Server() server.start()
def plant_status(request): context = {'plants_status': Server().get_plants_status()} return render(request, 'torch/plant_status.html', context)
def __init__(self): self.logger = logging.getLogger(__name__) self.server = Server('publish', timeout=15)
from lib.server import Server from middleware.csrf import csrf from middleware.static import static if __name__ == '__main__': # 生成配置并且运行程序 config = dict( host='localhost', port=3000, ) app = Server() app.use(csrf(dict( header_name='x_csrf_token', cookie_name='csrf_token', ))) app.use(static(dict( public_path='/static' ))) app.run(**config)
**The main module** Just starts the application. Run "python proxy.py" and configure the browser HTTP proxy to server port. By default the port is 12000, you can change on config.json file, is the port is been used the next will be try and on. """ __docformat__ = 'reStructuredText' import sys import json from lib.server import Server from lib.setup import Setup from lib.log import Log if __name__ == '__main__': try: setup = Setup() cfg = setup.config msg = "ProxY port load from file, trying to listening on " + cfg['port'] Log(msg) print msg server = Server(int(cfg['port']), cfg['auto_increment_port'], cfg['cache']) server.start() except KeyboardInterrupt: print "\nUser Requested An Interrupt" print "ProxY Exiting..." sys.exit()
if __name__ == "__main__": from lib.logger import Logger from lib.keymanager import KeyManager from lib.policy import PolicyManager from lib.config_loader import ConfigLoader from lib.auth import Connector from lib.epoll import Epoll from lib.request_queue import RequestQueue from lib.server import Server from lib.sockets import ServerSocket from lib.process import Pool logger = Logger(outfile=config.get("log-file", None), verbosity=config["verbosity"]) keys = KeyManager(logger) policy = PolicyManager(keys, logger) loader = ConfigLoader(logger, config["path_to_users"], config["path_to_policies"], policy, keys) res = loader.read() if not res: logger("Failed to read config. Exiting", "E") else: with Server(logger, keys, policy, config=config, queuer=RequestQueue) as server: epoll = Epoll(server) process_pool = Pool(server) server_socket = ServerSocket(server, Connector) logger("Server started") server.run()
def __get_servers_data(): '''obtains the filtered data from the pointed report from the environment variable FACTS_REPORT''' servers = Server() return servers.get_data()
#!/usr/bin/env python2 from argparse import ArgumentParser from lib.clusters import Clusters from lib.locks import Locks from lib.server import Server parser = ArgumentParser() parser.add_argument("--clusters-file", default="") parser.add_argument("--clusters-inline", default="") parser.add_argument("--locks", default="locks.json") parser.add_argument("--port", type=int, default=8000) args = parser.parse_args() clusters = Clusters(args.clusters_file, args.clusters_inline) locks = Locks(args.locks) server = Server(clusters, locks) print "Listening :{0}".format(args.port) server.listen(args.port)
from lib.server import Server if __name__ == '__main__': server = Server() server.start() input("Press enter to exit ;)\n") print("DEBUG send signal to stop sever") server.stop() server.join() print("DEBUG end main thread")
def run_server_main(args): Server(args.host, args.port).start()
parser.add_argument('-rh', '--remote-host', required=True, type=str, metavar='', dest='rhost') parser.add_argument('-rp', '--remote-port', required=True, type=int, metavar='', dest='rport') parser.add_argument('-lh', '--local-host', required=True, type=str, metavar='', dest='lhost') parser.add_argument('-lp', '--local-port', required=True, type=int, metavar='', dest='lport') args = parser.parse_args() Server(lhost=args.lhost, lport=args.lport, rhost=args.rhost, rport=args.rport).listen()