def test_set_open_file_limit_not_called_coz_upper_bound_check(
self,
mock_set_rlimit: mock.Mock,
mock_get_rlimit: mock.Mock) -> None:
Proxy.set_open_file_limit(1024)
mock_get_rlimit.assert_called_with(resource.RLIMIT_NOFILE)
mock_set_rlimit.assert_not_called()
def test_default_web_server_returns_404(
self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None:
self._conn = mock_fromfd.return_value
mock_selector.return_value.select.return_value = [(
selectors.SelectorKey(
fileobj=self._conn,
fd=self._conn.fileno,
events=selectors.EVENT_READ,
data=None), selectors.EVENT_READ), ]
flags = Proxy.initialize()
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
])
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
self._conn.recv.return_value = CRLF.join([
b'GET /hello HTTP/1.1',
CRLF,
])
self.protocol_handler.run_once()
self.assertEqual(
self.protocol_handler.request.state,
httpParserStates.COMPLETE)
self.assertEqual(
self.protocol_handler.client.buffer[0],
HttpWebServerPlugin.DEFAULT_404_RESPONSE)
def test_set_open_file_limit_not_called(
self,
mock_set_rlimit: mock.Mock,
mock_get_rlimit: mock.Mock) -> None:
Proxy.set_open_file_limit(256)
mock_get_rlimit.assert_called_with(resource.RLIMIT_NOFILE)
mock_set_rlimit.assert_not_called()
def main():
run = sys.argv[1]
env = None
if sys.argv.__len__() == 3:
env = sys.argv[2]
try:
settings = Settings()
settings.load_env(env)
settings.load_config(run)
if run == 'alt':
alt = Alt(settings.alt_config, settings.db_config)
alt.update()
elif run == 'proxy':
proxy = Proxy(settings.alt_config, settings.proxy_config, settings.db_config)
proxy.update()
elif run == 'host':
raise NotImplementedError
else:
logging.error('unknown run module')
raise RuntimeError
except RuntimeWarning:
pass
except NotImplementedError:
pass
def test_authenticated_proxy_http_tunnel(self,
mock_server_connection: mock.Mock,
mock_fromfd: mock.Mock,
mock_selector: mock.Mock) -> None:
server = mock_server_connection.return_value
server.connect.return_value = True
server.buffer_size.return_value = 0
self._conn = mock_fromfd.return_value
self.mock_selector_for_client_read_read_server_write(
mock_selector, server)
flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass'))
flags.plugins = Proxy.load_plugins(
[bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER)])
self.protocol_handler = HttpProtocolHandler(TcpClientConnection(
self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
assert self.http_server_port is not None
self._conn.recv.return_value = CRLF.join([
b'CONNECT localhost:%d HTTP/1.1' % self.http_server_port,
b'Host: localhost:%d' % self.http_server_port,
b'User-Agent: proxy.py/%s' % bytes_(__version__),
b'Proxy-Connection: Keep-Alive',
b'Proxy-Authorization: Basic dXNlcjpwYXNz', CRLF
])
self.assert_tunnel_response(mock_server_connection, server)
self.protocol_handler.client.flush()
self.assert_data_queued_to_server(server)
self.protocol_handler.run_once()
server.flush.assert_called_once()
class ProxyHandler:
def __init__(self, http_log):
self.proxy = Proxy('127.0.0.1', 4949, http_log)
def start_proxy(self):
self.proxy.listen()
def kill(self):
self.proxy.listening = False
def test_static_web_server_serves(
self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None:
# Setup a static directory
static_server_dir = os.path.join(tempfile.gettempdir(), 'static')
index_file_path = os.path.join(static_server_dir, 'index.html')
html_file_content = b'''<html><head></head><body><h1>Proxy.py Testing</h1></body></html>'''
os.makedirs(static_server_dir, exist_ok=True)
with open(index_file_path, 'wb') as f:
f.write(html_file_content)
self._conn = mock_fromfd.return_value
self._conn.recv.return_value = build_http_request(
b'GET', b'/index.html')
mock_selector.return_value.select.side_effect = [
[(selectors.SelectorKey(
fileobj=self._conn,
fd=self._conn.fileno,
events=selectors.EVENT_READ,
data=None), selectors.EVENT_READ)],
[(selectors.SelectorKey(
fileobj=self._conn,
fd=self._conn.fileno,
events=selectors.EVENT_WRITE,
data=None), selectors.EVENT_WRITE)], ]
flags = Proxy.initialize(
enable_static_server=True,
static_server_dir=static_server_dir)
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
])
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
self.protocol_handler.run_once()
self.protocol_handler.run_once()
self.assertEqual(mock_selector.return_value.select.call_count, 2)
self.assertEqual(self._conn.send.call_count, 1)
encoded_html_file_content = gzip.compress(html_file_content)
self.assertEqual(self._conn.send.call_args[0][0], build_http_response(
200, reason=b'OK', headers={
b'Content-Type': b'text/html',
b'Cache-Control': b'max-age=86400',
b'Content-Encoding': b'gzip',
b'Connection': b'close',
b'Content-Length': bytes_(len(encoded_html_file_content)),
},
body=encoded_html_file_content
))
def setUp(self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None:
self.fileno = 10
self._addr = ('127.0.0.1', 54382)
self._conn = mock_fromfd.return_value
self.mock_selector = mock_selector
self.flags = Proxy.initialize()
self.flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
])
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=self.flags)
self.protocol_handler.initialize()
def init_and_make_pac_file_request(self, pac_file: str) -> None:
flags = Proxy.initialize(pac_file=pac_file)
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
bytes_(PLUGIN_PAC_FILE),
])
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
self._conn.recv.return_value = CRLF.join([
b'GET / HTTP/1.1',
CRLF,
])
def test_unique_plugin_from_class(self) -> None:
self.flags = Proxy.initialize([], plugins=[
HttpProxyPlugin,
])
self.assert_plugins({'HttpProtocolHandlerPlugin': [
HttpProxyPlugin,
]})
def test_unique_plugin_from_bytes(self) -> None:
self.flags = Proxy.initialize([],
plugins=[
bytes_(PLUGIN_HTTP_PROXY),
])
self.assert_plugins({'HttpProtocolHandlerPlugin': [
HttpProxyPlugin,
]})
def test_unique_plugin_from_args(self) -> None:
self.flags = Proxy.initialize([
'--plugins',
PLUGIN_HTTP_PROXY,
])
self.assert_plugins({'HttpProtocolHandlerPlugin': [
HttpProxyPlugin,
]})
def test_basic_auth(self, mock_acceptor_pool: mock.Mock,
mock_sleep: mock.Mock) -> None:
mock_sleep.side_effect = KeyboardInterrupt()
input_args = ['--basic-auth', 'user:pass']
flgs = Proxy.initialize(input_args)
main(input_args=input_args)
mock_acceptor_pool.assert_called_once()
self.assertEqual(flgs.auth_code, b'dXNlcjpwYXNz')
def test_load_plugins_from_args(self) -> None:
self.flags = Proxy.initialize([
'--plugins',
'proxy.plugin.CacheResponsesPlugin,proxy.plugin.FilterByUpstreamHostPlugin',
])
self.assert_plugins({
'HttpProxyBasePlugin': [
CacheResponsesPlugin,
FilterByUpstreamHostPlugin,
]
})
def setUp(self) -> None:
self.acceptor_id = 1
self.mock_protocol_handler = mock.MagicMock()
self.pipe = multiprocessing.Pipe()
self.flags = Proxy.initialize()
self.acceptor = Acceptor(
idd=self.acceptor_id,
work_queue=self.pipe[1],
flags=self.flags,
lock=multiprocessing.Lock(),
work_klass=self.mock_protocol_handler)
def test_authenticated_proxy_http_get(self,
mock_server_connection: mock.Mock,
mock_fromfd: mock.Mock,
mock_selector: mock.Mock) -> None:
self._conn = mock_fromfd.return_value
self.mock_selector_for_client_read(mock_selector)
server = mock_server_connection.return_value
server.connect.return_value = True
server.buffer_size.return_value = 0
flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass'))
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
])
self.protocol_handler = HttpProtocolHandler(TcpClientConnection(
self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
assert self.http_server_port is not None
self._conn.recv.return_value = b'GET http://localhost:%d HTTP/1.1' % self.http_server_port
self.protocol_handler.run_once()
self.assertEqual(self.protocol_handler.request.state,
httpParserStates.INITIALIZED)
self._conn.recv.return_value = CRLF
self.protocol_handler.run_once()
self.assertEqual(self.protocol_handler.request.state,
httpParserStates.LINE_RCVD)
assert self.http_server_port is not None
self._conn.recv.return_value = CRLF.join([
b'User-Agent: proxy.py/%s' % bytes_(__version__),
b'Host: localhost:%d' % self.http_server_port, b'Accept: */*',
b'Proxy-Connection: Keep-Alive',
b'Proxy-Authorization: Basic dXNlcjpwYXNz', CRLF
])
self.assert_data_queued(mock_server_connection, server)
def test_load_plugins_from_class(self) -> None:
self.flags = Proxy.initialize([],
plugins=[
CacheResponsesPlugin,
FilterByUpstreamHostPlugin,
])
self.assert_plugins({
'HttpProxyBasePlugin': [
CacheResponsesPlugin,
FilterByUpstreamHostPlugin,
]
})
def test_proxy_authentication_failed(self, mock_fromfd: mock.Mock,
mock_selector: mock.Mock) -> None:
self._conn = mock_fromfd.return_value
self.mock_selector_for_client_read(mock_selector)
flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass'))
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
bytes_(PLUGIN_PROXY_AUTH),
])
self.protocol_handler = HttpProtocolHandler(TcpClientConnection(
self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
self._conn.recv.return_value = CRLF.join([
b'GET http://abhinavsingh.com HTTP/1.1', b'Host: abhinavsingh.com',
CRLF
])
self.protocol_handler.run_once()
self.assertEqual(self.protocol_handler.client.buffer[0],
ProxyAuthenticationFailed.RESPONSE_PKT)
def test_static_web_server_serves_404(
self,
mock_fromfd: mock.Mock,
mock_selector: mock.Mock) -> None:
self._conn = mock_fromfd.return_value
self._conn.recv.return_value = build_http_request(
b'GET', b'/not-found.html')
mock_selector.return_value.select.side_effect = [
[(selectors.SelectorKey(
fileobj=self._conn,
fd=self._conn.fileno,
events=selectors.EVENT_READ,
data=None), selectors.EVENT_READ)],
[(selectors.SelectorKey(
fileobj=self._conn,
fd=self._conn.fileno,
events=selectors.EVENT_WRITE,
data=None), selectors.EVENT_WRITE)], ]
flags = Proxy.initialize(enable_static_server=True)
flags.plugins = Proxy.load_plugins([
bytes_(PLUGIN_HTTP_PROXY),
bytes_(PLUGIN_WEB_SERVER),
])
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
self.protocol_handler.run_once()
self.protocol_handler.run_once()
self.assertEqual(mock_selector.return_value.select.call_count, 2)
self.assertEqual(self._conn.send.call_count, 1)
self.assertEqual(self._conn.send.call_args[0][0],
HttpWebServerPlugin.DEFAULT_404_RESPONSE)
def main() -> None:
# This example requires `threadless=True`
pool = AcceptorPool(flags=Proxy.initialize(port=12345,
num_workers=1,
threadless=True),
work_klass=EchoServerHandler)
try:
pool.setup()
while True:
time.sleep(1)
except KeyboardInterrupt:
pass
finally:
pool.shutdown()
def test_on_client_connection_called_on_teardown(
self, mock_fromfd: mock.Mock) -> None:
flags = Proxy.initialize()
plugin = mock.MagicMock()
flags.plugins = {b'HttpProtocolHandlerPlugin': [plugin]}
self._conn = mock_fromfd.return_value
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=flags)
self.protocol_handler.initialize()
plugin.assert_called()
with mock.patch.object(self.protocol_handler, 'run_once') as mock_run_once:
mock_run_once.return_value = True
self.protocol_handler.run()
self.assertTrue(self._conn.closed)
plugin.return_value.on_client_connection_close.assert_called()
def convert_proxy(values):
try:
_type = values.get("type", "")
if _type == "http":
protocol = const.HTTP
elif _type == "https":
protocol = const.HTTPS
else:
return False, None
proxy = Proxy(
values["host"],
int(values["port"]),
protocol
)
except BaseException:
return False, None
else:
return True, proxy
def setUp(self,
mock_fromfd: mock.Mock,
mock_selector: mock.Mock) -> None:
self.mock_fromfd = mock_fromfd
self.mock_selector = mock_selector
self.fileno = 10
self._addr = ('127.0.0.1', 54382)
self.flags = Proxy.initialize()
self.plugin = mock.MagicMock()
self.flags.plugins = {
b'HttpProtocolHandlerPlugin': [HttpProxyPlugin],
b'HttpProxyBasePlugin': [self.plugin]
}
self._conn = mock_fromfd.return_value
self.protocol_handler = HttpProtocolHandler(
TcpClientConnection(self._conn, self._addr),
flags=self.flags)
self.protocol_handler.initialize()
def start(self):
print('Server started\n')
self.input_list.append(self.server_socket)
while True:
read_list, _, _ = select.select(self.input_list, [], [])
for s in read_list:
if s == self.server_socket:
client_socket, client_address = self.server_socket.accept()
proxy = Proxy().start(REDIRECT_TO.get('host'),
REDIRECT_TO.get('port'))
if proxy:
print(
f'{client_address[0]}:{client_address[1]} is connected\n'
)
self.input_list.append(client_socket)
self.input_list.append(proxy)
self.channel[client_socket] = proxy
self.channel[proxy] = client_socket
else:
print(
f'Cannot reach remote server, closing connection with client: {client_address[0]}\n'
)
client_socket.close()
break
data = s.recv(BUFFER_SIZE)
if len(data) == 0:
self.close(s)
break
else:
if self.has_CONNECT(data):
self.wrap_with_ssl(s, proxy)
print(data)
self.channel[s].send(data)
def test_setup_and_shutdown(self, mock_acceptor: mock.Mock,
mock_socket: mock.Mock, mock_pipe: mock.Mock,
mock_send_handle: mock.Mock) -> None:
acceptor1 = mock.MagicMock()
acceptor2 = mock.MagicMock()
mock_acceptor.side_effect = [acceptor1, acceptor2]
num_workers = 2
sock = mock_socket.return_value
work_klass = mock.MagicMock()
flags = Proxy.initialize(num_workers=2)
pool = AcceptorPool(flags=flags, work_klass=work_klass)
pool.setup()
mock_send_handle.assert_called()
work_klass.assert_not_called()
mock_socket.assert_called_with(
socket.AF_INET6 if pool.flags.hostname.version == 6 else
socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt.assert_called_with(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
sock.bind.assert_called_with(
(str(pool.flags.hostname), pool.flags.port))
sock.listen.assert_called_with(pool.flags.backlog)
sock.setblocking.assert_called_with(False)
self.assertTrue(mock_pipe.call_count, num_workers)
self.assertTrue(mock_acceptor.call_count, num_workers)
acceptor1.start.assert_called()
acceptor2.start.assert_called()
acceptor1.join.assert_not_called()
acceptor2.join.assert_not_called()
sock.close.assert_called()
pool.shutdown()
acceptor1.join.assert_called()
acceptor2.join.assert_called()
current_port: StringVar
# Custom Profile Features
current_features = []
feature_widgets: Dict[str, ttk.Checkbutton] = {}
# Current Process
current_process: Popen = None
# Current Config
current_config = {}
# Proxy
proxy_lock = threading.Lock()
proxy_thread: threading.Thread = None
proxy = Proxy()
'''
Helper classes.
'''
# Hyper-Link
class HyperLink(ttk.Label):
def __init__(self, parent, url, text=None, cursor=None, *args, **kwargs):
self.url = url
super().__init__(parent, text=(text or url), cursor=(cursor or 'hand2'), *args, **kwargs)
self.bind('<Button-1>', self.web_open)
def web_open(self, event):
return webbrowser.open(self.url)
high, low, open, close, weighted_average, volume = data
threshold = 0.01511201
# Place a sell order when the candlestick average is above a certain
# threshold.
if weighted_average > threshold:
self.new_sell_order()
# Likewise, place a buy order when the candlestick is below a certain threshold.
else:
self.new_buy_order()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--proxy",
help="instantiate the proxy server",
action="store_true")
parser.add_argument(
"-d",
"--dispatch",
help="dispatch the strategies for execution",
action="store_true",
)
args = parser.parse_args()
if args.proxy:
# Instantiate the Proxy.
Proxy()
elif args.dispatch:
# Dispatch a list of strategies.
Dispatcher([Example1, Example1, Example2])
if optlist[2][1] != '0': #DIFFERENT PERMUTATION
help()
if len(args) == 4:
optlist, args = getopt.getopt(
args, '',
['net-config=', 'firewall-config=', 'log-level=', 'log-file='])
net_config = firewall_config = log_level = log_level = None
for opt in optlist:
if opt[0] == '--net-config':
net_config = opt[1]
elif opt[0] == '--firewall-config':
firewall_config = opt[1]
elif opt[0] == '--log-level':
log_level = int(opt[1])
elif opt[0] == '--log-file':
log_file = opt[1]
host, server = parse_net_config(net_config)
#firewall = Firewall(firewall_config, logger)
#proxy = Proxy(host, server, firewall)
#proxy.start()
f_logger = Logger(log_file, log_level, 'firewall')
p_logger = Logger('logs/proxy_log.txt', log_level, 'proxy')
firewall = Firewall(firewall_config, f_logger)
proxy = Proxy(host, server, firewall, p_logger)
proxy.start()
def test_load_plugin_from_args(self) -> None:
self.flags = Proxy.initialize([
'--plugins',
'proxy.plugin.CacheResponsesPlugin',
])
self.assert_plugins({'HttpProxyBasePlugin': [CacheResponsesPlugin]})
from sneeze.logging import Logger
from proxy.proxy import Proxy
if __name__ == '__main__':
proxy = Proxy('127.0.0.1', 4949, Logger('sneeze.ini'))
print('Proxy listening at 127.0.0.1:4949')
proxy.listen()
answers['description'], answers['scheduled_time'])
handle_menu_selection('List all events')
def handle_event_delete(event):
proxy.event_delete(event.name)
handle_menu_selection('List all events')
def handle_event_name_input():
return prompt(get_event_name_form())
def handle_event_description_input():
return prompt(get_event_description_form())
if __name__ == "__main__":
if len(sys.argv) > 1:
urlServ = sys.argv[1]
else:
urlServ = "http://localhost/Xh1Serv.php"
proxy = Proxy(urlServ)
print("**********************************************")
print("*** Welcome to Events Agenda Application ***")
print("**********************************************")
handle_cli_start()