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