def Run(self):
if self.proxy_port == '-1':
return 1
# Temporary means to determine if we are running on CI
# TODO: Update to IS_CI environment variable or similar
out_dir = _launcher_params.out_directory
is_ci = out_dir and 'mh_lab' in out_dir
target = (_launcher_params.platform, _launcher_params.config)
if is_ci and '{}/{}'.format(*target) in _DISABLED_BLACKBOXTEST_CONFIGS:
logging.warning(
'Blackbox tests disabled for platform:{} config:{}'.format(
*target))
return 0
logging.info('Using proxy port: %s', self.proxy_port)
with ProxyServer(port=self.proxy_port,
host_resolve_map=self.host_resolve_map,
client_ips=self.device_ips):
if self.test_name:
suite = unittest.TestLoader().loadTestsFromModule(
importlib.import_module(_TEST_DIR_PATH + self.test_name))
else:
suite = LoadTests(_launcher_params)
return_code = not unittest.TextTestRunner(
verbosity=0, stream=sys.stdout).run(suite).wasSuccessful()
return return_code
def run(cmdargs):
args = [
(cmdargs.localhost, cmdargs.localport),
(cmdargs.remotehost, cmdargs.remoteport)
]
kwargs = {}
if cmdargs.sslboth:
kwargs['ssl'] = True
if not cmdargs.certfile or not cmdargs.keyfile:
print ('You need to specify a valid certificate file and a key file!')
sys.exit(1)
kwargs['certfile'] = cmdargs.certfile
kwargs['keyfile'] = cmdargs.keyfile
elif cmdargs.sslout:
kwargs['ssl_out_only'] = True
kwargs['debug'] = False
if cmdargs.username and cmdargs.password:
credentials = store_credentials.StoreCredentials()
credentials.username = cmdargs.username
credentials.password = cmdargs.password
credentials.stored = True
else:
credentials = credentials_emailing.StoreCredentials()
#credentials.username = config.username
#credentials.password = config.password
credentials.stored = True
kwargs['credential_validator'] = credentials
server = ProxyServer(*args, **kwargs)
server.run()
def test_log_info(self):
proxy = ProxyServer()
conn = connection.Connection(None, CLIENT_IP, 'scratchpads.eu', 80)
result = proxy.get_log_info(conn, HTTP_PACKAGE.decode())
self.assertEqual(
result, CLIENT_IP + ' POST '
'http://scratchpads.eu/modules/'
'statistics/statistics.php')
def test_init_options(self):
server = ProxyServer(cert_ca=ROOT_CRT,
cert_key=ROOT_KEY,
certs_folder=CERTIFICATES_FOLDER)
certs_path_exist = False
if os.path.exists(server.certs_folder):
certs_path_exist = True
self.assertEqual(certs_path_exist, True)
def Run(self):
if self.proxy_port_number == '-1':
return 1
logging.info('Using proxy port number: %s', self.proxy_port_number)
with ProxyServer(port=self.proxy_port_number,
host_resolve_map=self.host_resolve_map):
if self.test_name:
suite = unittest.TestLoader().loadTestsFromModule(
importlib.import_module(_TEST_DIR_PATH + self.test_name))
else:
suite = LoadTests(_device_params.platform,
_device_params.config,
_device_params.device_id,
_device_params.out_directory)
return_code = not unittest.TextTestRunner(
verbosity=0, stream=sys.stdout).run(suite).wasSuccessful()
return return_code
def test_starting_stopping_server(self):
proxy = ProxyServer()
expected_host = socket.gethostbyname(socket.gethostname())
expected_port = 1111
th = threading.Thread(target=proxy.start,
kwargs={
'host': '0.0.0.0',
'port': expected_port
})
th.start()
time.sleep(0.1)
host, port = proxy.get_addr()
proxy.stop()
self.assertEqual(host, expected_host)
self.assertEqual(port, expected_port)
self.assertEqual(proxy.sever_sock.fileno(), -1)
self.assertIsNone(proxy.executor)
def test_handling_clients(self):
url = 'http://{}:{}'.format(WEB_SERVER_ADDRESS[0],
WEB_SERVER_ADDRESS[1])
server = HTTPServer(WEB_SERVER_ADDRESS, CGIHTTPRequestHandler)
proxy = ProxyServer()
proxy_th = threading.Thread(target=proxy.start)
http_th = threading.Thread(target=server.serve_forever)
proxy_th.start()
http_th.start()
proxy_url = 'http://{}:{}'.format(*proxy.get_addr())
proxies = {'http': proxy_url}
r = requests.get(url, proxies=proxies)
self.assertEqual(r.status_code, 200)
proxy.stop()
server.shutdown()
http_th.join()
proxy_th.join()
self.assertEqual(proxy.executor, None)
def test_handling_https(self):
proxy = ProxyServer()
th = threading.Thread(target=proxy.start)
th.start()
host, port = proxy.get_addr()
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv.connect((host, port))
serv.sendall(HTTPS_PACKAGE)
response = b''
while True:
data = serv.recv(BUFFER_SIZE)
if not data:
break
response += data
self.assertEqual(SUCCESS_MESSAGE, response)
proxy.stop()
th.join()
parser.add_argument('id',
metavar='I',
help='Server id',
choices=[*SERVER_MAPPINGS])
args = parser.parse_args()
'''Logging Configuration'''
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)-15s - %(name)s: %(message)s',
filename='{}.log'.format(args.id),
)
log = logging.getLogger('server.py')
''' Setup Server '''
SERVER_ADDRESS = (SERVER_URL, SERVER_MAPPINGS[args.id])
event_loop = asyncio.get_event_loop()
server_factory = event_loop.create_server(
lambda: ProxyServer(args.id, event_loop), *SERVER_ADDRESS)
server = event_loop.run_until_complete(server_factory)
log.debug('starting up on {} port {}'.format(*SERVER_ADDRESS))
try:
event_loop.run_forever()
except KeyboardInterrupt:
pass
log.debug('closing server')
server.close()
event_loop.run_until_complete(server.wait_closed())
log.debug('closing event loop')
event_loop.close()
def main():
"""Init and run HttpServer"""
server = ProxyServer("config.json")
server.run()
def main():
proxy = ProxyServer()
proxy.run()
def main():
proxy_server = ProxyServer('localhost', 9001, 100, 4092)
proxy_server.run()
def main():
proxy_server = ProxyServer('localhost', 8080)
proxy_server.start()
