def test_regional_tcp(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) subdomain = "pyngrok-{}-{}-{}{}-tcp".format( platform.system(), platform.python_implementation(), sys.version_info[0], sys.version_info[1]).lower() pyngrok_config = PyngrokConfig( config_path=conf.DEFAULT_NGROK_CONFIG_PATH, auth_token=os.environ["NGROK_AUTHTOKEN"], region="au") # WHEN ngrok_tunnel = ngrok.connect(5000, "tcp", subdomain=subdomain, pyngrok_config=pyngrok_config) current_process = ngrok.get_ngrok_process() # THEN self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertIsNotNone(ngrok_tunnel.public_url) self.assertIsNotNone(process.get_process(pyngrok_config)) self.assertEqual("localhost:5000", ngrok_tunnel.config["addr"]) self.assertIn("tcp://", ngrok_tunnel.public_url) self.assertIn(".au.", ngrok_tunnel.public_url) self.assertEqual(len(process._current_processes.keys()), 1)
def process(self): """Return ngrok process Returns: Popen """ return ngrok.get_ngrok_process().process
def test_connect_fileserver(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) pyngrok_config = PyngrokConfig( config_path=conf.DEFAULT_NGROK_CONFIG_PATH, auth_token=os.environ["NGROK_AUTHTOKEN"]) # WHEN url = ngrok.connect("file:///", pyngrok_config=pyngrok_config) current_process = ngrok.get_ngrok_process() time.sleep(1) tunnels = ngrok.get_tunnels() # THEN self.assertEqual(len(tunnels), 2) self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertTrue(current_process._monitor_thread.is_alive()) self.assertIsNotNone(url) self.assertIsNotNone(process.get_process(self.pyngrok_config)) self.assertIn('http://', url) self.assertEqual(len(process._current_processes.keys()), 1) # WHEN ngrok.disconnect(url) time.sleep(1) tunnels = ngrok.get_tunnels() # THEN # There is still one tunnel left, as we only disconnected the http tunnel self.assertEqual(len(tunnels), 1)
def test_connect_fileserver(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) pyngrok_config = PyngrokConfig(config_path=conf.DEFAULT_NGROK_CONFIG_PATH, auth_token=os.environ["NGROK_AUTHTOKEN"]) # WHEN ngrok_tunnel = ngrok.connect("file:///", pyngrok_config=pyngrok_config) current_process = ngrok.get_ngrok_process() time.sleep(1) tunnels = ngrok.get_tunnels() # THEN self.assertEqual(len(tunnels), 2) self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertTrue(current_process._monitor_thread.is_alive()) self.assertTrue(ngrok_tunnel.name.startswith("http-file-")) self.assertEqual("file:///", ngrok_tunnel.config["addr"]) self.assertIsNotNone(ngrok_tunnel.public_url) self.assertIsNotNone(process.get_process(self.pyngrok_config)) self.assertIn('http://', ngrok_tunnel.public_url) self.assertEqual(len(process._current_processes.keys()), 1)
def kill(): ngrok_process = ngrok.get_ngrok_process() try: ngrok.kill() except: print("ngrok is already closed")
def test_regional_subdomain(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) subdomain = "pyngrok-{}-{}-{}{}-http".format( platform.system(), platform.python_implementation(), sys.version_info[0], sys.version_info[1]).lower() pyngrok_config = PyngrokConfig( config_path=conf.DEFAULT_NGROK_CONFIG_PATH, auth_token=os.environ["NGROK_AUTHTOKEN"], region="au") # WHEN url = ngrok.connect(5000, options={"subdomain": subdomain}, pyngrok_config=pyngrok_config) current_process = ngrok.get_ngrok_process() # THEN self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertIsNotNone(url) self.assertIsNotNone(process.get_process(pyngrok_config)) self.assertIn("http://", url) self.assertIn(".au.", url) self.assertIn(subdomain, url) self.assertEqual(len(process._current_processes.keys()), 1)
def test_api_request_query_params(self): # GIVEN tunnel_name = "tunnel (1)" current_process = ngrok.get_ngrok_process( pyngrok_config=self.pyngrok_config) public_url = ngrok.connect(name=tunnel_name).replace("http", "https") time.sleep(1) try: urlopen(public_url) except: pass # WHEN response1 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET") response2 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET", params={"tunnel_name": "{}".format(tunnel_name)}) response3 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET", params={"tunnel_name": "{} (http)".format(tunnel_name)}) # THEN self.assertEqual(1, len(response1["requests"])) self.assertEqual(1, len(response2["requests"])) self.assertEqual(0, len(response3["requests"]))
def test_api_request_query_params(self): # GIVEN tunnel_name = "tunnel (1)" current_process = ngrok.get_ngrok_process( pyngrok_config=self.pyngrok_config) public_url = ngrok.connect(urlparse(current_process.api_url).port, name=tunnel_name, bind_tls=True).public_url time.sleep(1) urlopen("{}/status".format(public_url)).read() time.sleep(3) # WHEN response1 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET") response2 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET", params={"tunnel_name": "{}".format(tunnel_name)}) response3 = ngrok.api_request( "{}/api/requests/http".format(current_process.api_url), "GET", params={"tunnel_name": "{} (http)".format(tunnel_name)}) # THEN self.assertGreater(len(response1["requests"]), 0) self.assertGreater(len(response2["requests"]), 0) self.assertEqual(0, len(response3["requests"]))
def test_regional_subdomain(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) subdomain = self.create_unique_subdomain() pyngrok_config = self.copy_with_updates( self.pyngrok_config, auth_token=os.environ["NGROK_AUTHTOKEN"], region="au") # WHEN url = ngrok.connect(5000, subdomain=subdomain, pyngrok_config=pyngrok_config).public_url current_process = ngrok.get_ngrok_process() # THEN self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertIsNotNone(url) self.assertIsNotNone(process.get_process(pyngrok_config)) self.assertIn("http://", url) self.assertIn(".au.", url) self.assertIn(subdomain, url) self.assertEqual(len(process._current_processes.keys()), 1)
def ngrok_process(): ngrok_process = ngrok.get_ngrok_process() print('Stop the process when you finish') try: ngrok_process.proc.wait() except: stop_ngrok() stop_nginx()
def __init__(self): if self.__working: ngrok_host, ngrok_port = self.__active_tunnel.public_url[6:].split(':') post_data = {'host': ngrok_host, 'port': ngrok_port} requests.post(settings.API_URL + settings.UPDATE_URL, data=post_data, verify=False) ngrok_process = ngrok.get_ngrok_process().proc ngrok_process.wait()
def start_ngrok(port): try: print(Fore.RED + "[" + Fore.BLUE + "*" + Fore.RED + "]" + Fore.GREEN + " Send this link to your victim: " + Fore.CYAN + ngrok.connect(port, "http").public_url.replace("http", "https")) ngrok_process = ngrok.get_ngrok_process() ngrok_process.proc.wait() except (pyngrok.exception.PyngrokNgrokError, ConnectionResetError): print(Fore.RED + '\nExiting...(You pressed Ctrl+C)') os._exit(0)
def kill_process(self): """ The first created tunnel instance also starts the ``ngrok`` process. The process will stay alive until the Python interpreter is stopped or this action is invoked. """ from pyngrok import ngrok proc = ngrok.get_ngrok_process() assert proc and proc.proc, 'The ngrok process is not running' proc.proc.kill() get_bus().post(NgrokProcessStoppedEvent())
def test_no_monitor_thread(self): # GIVEN self.given_ngrok_installed(self.pyngrok_config) pyngrok_config = self.copy_with_updates(self.pyngrok_config, monitor_thread=False) # WHEN ngrok.connect(pyngrok_config=pyngrok_config) ngrok_process = ngrok.get_ngrok_process() # THEN self.assertIsNone(ngrok_process._monitor_thread)
def test_no_monitor_thread(self): # GIVEN self.given_ngrok_installed(self.pyngrok_config.ngrok_path) pyngrok_config = PyngrokConfig(config_path=conf.DEFAULT_NGROK_CONFIG_PATH, monitor_thread=False) # WHEN ngrok.connect(pyngrok_config=pyngrok_config) ngrok_process = ngrok.get_ngrok_process() # THEN self.assertIsNone(ngrok_process._monitor_thread)
def test_api_get_request_success(self): # GIVEN current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) ngrok_tunnel = ngrok.connect() time.sleep(1) # WHEN response = ngrok.api_request("{}{}".format(current_process.api_url, ngrok_tunnel.uri), "GET") # THEN self.assertEqual(ngrok_tunnel.name, response["name"])
def test_api_get_request_success(self): # GIVEN current_process = ngrok.get_ngrok_process(config_path=self.config_path) ngrok.connect(config_path=self.config_path) time.sleep(1) tunnel = ngrok.get_tunnels()[0] # WHEN response = ngrok.api_request("{}{}".format(current_process.api_url, tunnel.uri.replace("+", "%20")), "GET") # THEN self.assertEqual(tunnel.name, response["name"])
def test_stop_monitor_thread(self): # GIVEN self.given_ngrok_installed(self.pyngrok_config) current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) public_url = ngrok.connect(urlparse(current_process.api_url).port, bind_tls=True, pyngrok_config=self.pyngrok_config).public_url ngrok_process = ngrok.get_ngrok_process() monitor_thread = ngrok_process._monitor_thread # WHEN time.sleep(1) self.assertTrue(monitor_thread.is_alive()) ngrok_process.stop_monitor_thread() # Make a request to the tunnel to force a log through, which will allow the thread to trigger its own teardown urlopen("{}/status".format(public_url)).read() time.sleep(1) # THEN self.assertFalse(monitor_thread.is_alive()) self.assertIsNone(ngrok_process._monitor_thread) self.assertTrue(ngrok_process.pyngrok_config.monitor_thread)
def test_api_request_timeout(self): # GIVEN current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) ngrok_tunnel = ngrok.connect() time.sleep(1) # WHEN with self.assertRaises(PyngrokNgrokURLError) as cm: ngrok.api_request("{}{}".format(current_process.api_url, ngrok_tunnel.uri), "DELETE", timeout=0.0001) # THEN self.assertIn("timed out", cm.exception.reason)
def test_api_request_timeout(self): # GIVEN current_process = ngrok.get_ngrok_process(config_path=self.config_path) ngrok.connect(config_path=self.config_path) time.sleep(1) tunnels = ngrok.get_tunnels() # WHEN with self.assertRaises(PyngrokNgrokURLError) as cm: ngrok.api_request("{}{}".format(current_process.api_url, tunnels[0].uri.replace("+", "%20")), "DELETE", timeout=0.0001) # THEN self.assertIn("timed out", cm.exception.reason)
def test_connect(self): # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) # WHEN url = ngrok.connect(5000, config_path=self.config_path) current_process = ngrok.get_ngrok_process() # THEN self.assertIsNotNone(current_process) self.assertIsNone(current_process.process.poll()) self.assertIsNotNone(url) self.assertIsNotNone(process.get_process(ngrok.DEFAULT_NGROK_PATH)) self.assertEqual(len(process._current_processes.keys()), 1)
def main(): public_url = ngrok.connect(5000) print("Navigate to : {}".format(public_url)) run() ngrok_process = ngrok.get_ngrok_process() try: # Block until CTRL-C or some other terminating event ngrok_process.proc.wait() except KeyboardInterrupt: print(" Shutting down NGROK server.") ngrok.kill() finally: ngrok.kill()
def test_log_event_callback_and_max_logs(self): # GIVEN self.given_ngrok_installed(self.pyngrok_config) log_event_callback_mock = mock.MagicMock() pyngrok_config = self.copy_with_updates(self.pyngrok_config, log_event_callback=log_event_callback_mock, max_logs=5) # WHEN ngrok.connect(pyngrok_config=pyngrok_config) ngrok_process = ngrok.get_ngrok_process() time.sleep(1) # THEN self.assertGreater(log_event_callback_mock.call_count, len(ngrok_process.logs)) self.assertEqual(len(ngrok_process.logs), 5)
def test_log_event_callback_and_max_logs(self): # GIVEN self.given_ngrok_installed(self.pyngrok_config.ngrok_path) log_event_callback_mock = mock.MagicMock() pyngrok_config = PyngrokConfig(config_path=conf.DEFAULT_NGROK_CONFIG_PATH, log_event_callback=log_event_callback_mock, max_logs=5) # WHEN ngrok.connect(pyngrok_config=pyngrok_config) ngrok_process = ngrok.get_ngrok_process() time.sleep(1) # THEN self.assertGreater(log_event_callback_mock.call_count, len(ngrok_process.logs)) self.assertEqual(len(ngrok_process.logs), 5)
def ngrokConnect(update: Update, context: CallbackContext) -> None: if not checkId(update.message.chat_id): return global tunnel if len(ngrok.get_tunnels()) == 1: msg = "Already connected at: " + str(tunnel.public_url) update.message.reply_text(msg) elif len(ngrok.get_tunnels()) > 1: update.message.reply_text("Error! Multiple tunnels running!") else: conf.get_default().region = "eu" tunnel = ngrok.connect(4000, 'tcp', region="eu") process = ngrok.get_ngrok_process() update.message.reply_text("Connected at " + tunnel.public_url)
def test_connect(self): # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) # WHEN url = ngrok.connect(5000, pyngrok_config=self.pyngrok_config) current_process = ngrok.get_ngrok_process() # THEN self.assertIsNotNone(current_process) self.assertIsNone(current_process.proc.poll()) self.assertTrue(current_process._monitor_thread.is_alive()) self.assertIsNotNone(url) self.assertIsNotNone(process.get_process(self.pyngrok_config)) self.assertIn('http://', url) self.assertEqual(len(process._current_processes.keys()), 1)
def test_api_request_delete_data_updated(self): # GIVEN current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) ngrok.connect() time.sleep(1) tunnels = ngrok.get_tunnels() self.assertEqual(len(tunnels), 2) # WHEN response = ngrok.api_request("{}{}".format(current_process.api_url, tunnels[0].uri.replace("+", "%20")), "DELETE") # THEN self.assertIsNone(response) tunnels = ngrok.get_tunnels() self.assertEqual(len(tunnels), 1)
def test_api_request_fails(self): # GIVEN current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) bad_options = { "name": str(uuid.uuid4()), "addr": "8080", "proto": "invalid-proto" } # WHEN with self.assertRaises(PyngrokNgrokHTTPError) as cm: ngrok.api_request("{}/api/{}".format(current_process.api_url, "tunnels"), "POST", data=bad_options) # THEN self.assertEqual(StatusCodes.BAD_REQUEST, cm.exception.status_code) self.assertIn("invalid tunnel configuration", str(cm.exception)) self.assertIn("protocol name", str(cm.exception))
def test_ngrok_tunnel_refresh_metrics(self): # GIVEN current_process = ngrok.get_ngrok_process(pyngrok_config=self.pyngrok_config) ngrok_tunnel = ngrok.connect(urlparse(current_process.api_url).port, bind_tls=True) time.sleep(1) self.assertEqual(0, ngrok_tunnel.metrics.get("http").get("count")) self.assertEqual(ngrok_tunnel.data["metrics"].get("http").get("count"), 0) urlopen("{}/status".format(ngrok_tunnel.public_url)).read() time.sleep(3) # WHEN ngrok_tunnel.refresh_metrics() # THEN self.assertGreater(ngrok_tunnel.metrics.get("http").get("count"), 0) self.assertGreater(ngrok_tunnel.data["metrics"].get("http").get("count"), 0)
def test_get_tunnel_fileserver(self): if "NGROK_AUTHTOKEN" not in os.environ: self.skipTest("NGROK_AUTHTOKEN environment variable not set") # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) pyngrok_config = self.copy_with_updates(self.pyngrok_config, auth_token=os.environ["NGROK_AUTHTOKEN"]) ngrok_tunnel = ngrok.connect("file:///", pyngrok_config=pyngrok_config) time.sleep(1) api_url = ngrok.get_ngrok_process(pyngrok_config).api_url # WHEN response = ngrok.api_request("{}{}".format(api_url, ngrok_tunnel.uri), "GET") # THEN self.assertEqual(ngrok_tunnel.name, response["name"]) self.assertTrue(ngrok_tunnel.name.startswith("http-file-"))