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