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