async def prepare(self) -> None:
bot_logging.set_logging_level(self.LOGGERS, logging.WARNING)
ngrok.set_auth_token(
self.config[services_constants.CONFIG_CATEGORY_SERVICES][
services_constants.CONFIG_WEBHOOK][
services_constants.CONFIG_NGROK_TOKEN])
try:
self.webhook_host = os.getenv(
services_constants.ENV_WEBHOOK_ADDRESS,
self.config[services_constants.CONFIG_CATEGORY_SERVICES][
services_constants.CONFIG_WEBHOOK][
services_constants.CONFIG_WEB_IP])
except KeyError:
self.webhook_host = os.getenv(
services_constants.ENV_WEBHOOK_ADDRESS,
services_constants.DEFAULT_WEBHOOK_SERVER_IP)
try:
self.webhook_port = int(
os.getenv(
services_constants.ENV_WEBHOOK_PORT,
self.config[services_constants.CONFIG_CATEGORY_SERVICES][
services_constants.CONFIG_WEBHOOK][
services_constants.CONFIG_WEB_PORT]))
except KeyError:
self.webhook_port = int(
os.getenv(services_constants.ENV_WEBHOOK_PORT,
services_constants.DEFAULT_WEBHOOK_SERVER_PORT))
def create_ngrok_app():
app = Flask(__name__)
app.config.from_mapping(
BASE_URL="http://localhost:5000",
USE_NGROK=os.environ.get("WERKZEUG_RUN_MAIN") != "true"
)
if app.config["USE_NGROK"]:
from pyngrok import ngrok
port = sys.argv[sys.argv.index(
"--port") + 1] if "--port" in sys.argv else 5000
ngrok.set_auth_token("1nVYxp54FWAA7aaBJP4Sr6y2vgw_7gBeaZ3rXfJJWmuue9kYR")
public_url = ngrok.connect(port).public_url
open("ngrok-link.txt", "w").write(" * ngrok tunnel \"{}\" -> \"http://127.0.0.1:{}\"".format(
public_url, port))
print(bcolors.HEADER + " * ngrok tunnel \"{}\" -> \"http://127.0.0.1:{}\"".format(
public_url, port) + bcolors.ENDC)
app.config["BASE_URL"] = public_url
init_webhooks(public_url)
return app
def test_set_auth_token(self):
# WHEN
ngrok.set_auth_token("807ad30a-73be-48d8", config_path=self.config_path)
contents = open(self.config_path, "r").read()
# THEN
self.assertIn("807ad30a-73be-48d8", contents)
def set_token(): # set the token
global tAuthToken, success_txt
auth_token = tAuthToken.get(
'1.0', 'end-1c') # retrieve the ngrok auth token from the text field
ngrok.set_auth_token(auth_token) # sets the ngrok auth token
success_txt.set(
'Token set to ' +
auth_token) # notify the user it has been changed with the text field
def test_set_auth_token(self):
# WHEN
ngrok.set_auth_token("807ad30a-73be-48d8", pyngrok_config=self.pyngrok_config)
with open(self.pyngrok_config.config_path, "r") as f:
contents = f.read()
# THEN
self.assertIn("807ad30a-73be-48d8", contents)
def _start_ngrok_server(self):
if self.authtoken:
ngrok.set_auth_token(self.authtoken)
active_tunnels = ngrok.get_tunnels()
for tunnel in active_tunnels:
public_url = tunnel.public_url
ngrok.disconnect(public_url)
url = ngrok.connect(addr=self.port, options={"bind_tls": True})
return url
def _get_public_url(self):
conf.get_default().region = self.region
if self.auth_token:
ngrok.set_auth_token(self.auth_token)
url = ngrok.connect(self.port).public_url
return url
def _start_server(self):
if self.authtoken:
ngrok.set_auth_token(self.authtoken)
active_tunnels = ngrok.get_tunnels()
for tunnel in active_tunnels:
public_url = tunnel.public_url
ngrok.disconnect(public_url)
url = ngrok.connect(addr=self.port, options={"bind_tls": True})
print(f"Code Server can be accessed on: {url}")
def connect_ngrok(ngrok_auth_token: str) -> str:
'''
:return: ngrok url
'''
ngrok.set_auth_token(ngrok_auth_token)
ngrok_tunnel = ngrok.connect(8080)
public_url = (ngrok_tunnel.public_url).replace("http", "https")
print("NGROK URL: {}".format(public_url))
return public_url
def _start_server(self):
if self.authtoken:
ngrok.set_auth_token(self.authtoken)
active_tunnels = ngrok.get_tunnels()
for tunnel in active_tunnels:
public_url = tunnel.public_url
ngrok.disconnect(public_url)
NgrokTunnel = ngrok.connect(addr=self.port, options={"bind_tls": True})
https_url = self._get_https_url(str(NgrokTunnel))
print(f'\n\nopen code server via https: {https_url}\n\n')
print(f"Code Server can be accessed on: {NgrokTunnel}")
def test_set_auth_token_fails(self, mock_check_output):
# GIVEN
error_msg = "An error occurred"
mock_check_output.return_value = error_msg
# WHEN
with self.assertRaises(PyngrokNgrokError) as cm:
ngrok.set_auth_token("807ad30a-73be-48d8", pyngrok_config=self.pyngrok_config)
# THEN
self.assertIn(": {}".format(error_msg), str(cm.exception))
def _start_server(self):
if self.authtoken:
ngrok.set_auth_token(self.authtoken)
active_tunnels = ngrok.get_tunnels()
for tunnel in active_tunnels:
public_url = tunnel.public_url
ngrok.disconnect(public_url)
url = ngrok.connect(addr=self.port, bind_tls=True)
if self._code:
print(f"Code Server can be accessed on: {url}")
else:
print(f"Public URL: {url}")
def _start_server(self):
conf.get_default().region = self.region
if self.authtoken:
ngrok.set_auth_token(self.authtoken)
active_tunnels = ngrok.get_tunnels()
for tunnel in active_tunnels:
public_url = tunnel.public_url
ngrok.disconnect(public_url)
url = ngrok.connect(addr=self.port, options={"bind_tls": True})
if self._code:
print(f"Code Server can be accessed on: {url}")
else:
print(f"Public URL: {url}")
def open_ngrok_tunnel():
telegram_log('++ opening ngrok tunnel')
# Open a tunnel on the default port 80
ngrok.set_auth_token(ngrok_token)
public_url = ngrok.connect(port=22, proto="tcp")
regex = '^tcp:\/\/(\d+\.tcp\.ngrok\.io)\:(\d+?)$'
match = re.match(regex, public_url)
if match:
ssh_string = 'ssh swim@{} -p{}'.format(match.group(1), match.group(2))
log_ip(ssh_string)
else:
log_ip(public_url)
async def __call__(
self, fn: reviews.WebhookFn
) -> AsyncIterator[reviews.WebhookClientConfig]:
try:
from pyngrok import conf, ngrok
except ImportError:
raise MissingDependencyError(
"Using ngrok webhook tunnel requires an extra dependency: "
"run `pip install pyngrok` or `pip install kopf[dev]`. "
"More: https://kopf.readthedocs.io/en/stable/admission/")
if self.binary is not None:
conf.get_default().ngrok_path = str(self.binary)
if self.region is not None:
conf.get_default().region = self.region
if self.token is not None:
ngrok.set_auth_token(self.token)
# Ngrok only supports HTTP with a free plan; HTTPS requires a paid subscription.
tunnel: Optional[ngrok.NgrokTunnel] = None
loop = asyncio.get_running_loop()
async with WebhookServer(addr=self.addr,
port=self.port,
path=self.path,
insecure=True) as server:
# TODO: inverse try & async for?
try:
async for client_config in server(fn):
# Re-create the tunnel for each new local endpoint (if it did change at all).
if tunnel is not None:
await loop.run_in_executor(None, ngrok.disconnect,
tunnel.public_url)
parsed = urllib.parse.urlparse(client_config['url'])
tunnel = await loop.run_in_executor(
None,
functools.partial(ngrok.connect,
f'{parsed.port}',
bind_tls=True))
# Adjust for local webhook server specifics (no port, but with the same path).
# Report no CA bundle -- ngrok's certs (Let's Encrypt) are in a default trust chain.
url = f"{tunnel.public_url}{self.path or ''}"
logger.debug(f"Accessing the webhooks at {url}")
yield reviews.WebhookClientConfig(
url=url) # e.g. 'https://e5fc05f6494b.ngrok.io/xyz'
finally:
if tunnel is not None:
await loop.run_in_executor(None, ngrok.disconnect,
tunnel.public_url)
def run_ngrok(self, config, path: str, port: int = 5000):
ngrok.DEFAULT_NGROK_PATH = path
if len(ngrok.get_tunnels()) != 0:
ngrok.kill()
# Open a ngrok tunnel to the dev server
ngrok.set_auth_token(config['NGROK']['ngrok_TOKEN'])
public_url = ngrok.connect(port)
public_url = public_url.replace('http:', 'https:')
print(" * ngrok tunnel \"{}\" -> \"http://127.0.0.1:{}/\"".format(
public_url, port))
return public_url
def port_forward(port, auth_token):
try:
ngrok.set_auth_token(auth_token)
pyngrok_config = PyngrokConfig(monitor_thread=False)
server_addr = ngrok.connect(port, 'tcp', pyngrok_config=pyngrok_config)
server_addr = server_addr.split('//', 1)[1]
ip = server_addr.split(':', 1)[0]
port = server_addr.split(':', 1)[1]
server_ip = socket.gethostbyname(ip)
print('[\033[1;92m*\033[m] Server IP: \033[1;92m%s\033[m' % server_ip)
print('[\033[1;92m*\033[m] Server Port: \033[1;92m%s\033[m' % port)
except Exception as e:
exit(e)
def create_tunnel():
"""Open ngrok tcp tunnel"""
conf.get_default().region = NGROK_REGION
ngrok.set_auth_token(NGROK_TOKEN)
try: # Create new tunnel
tunnel = ngrok.connect(TUNNEL_PORT, "tcp")
server_host = CUSTOM_HOST or tunnel.public_url.replace("tcp://", "")
print(
f"{Clr.GREEN}[O] Successfully created ngrok tunnel{Clr.END} localhost:{TUNNEL_PORT} -> {server_host}"
)
except:
server_host = CUSTOM_HOST or "N/A"
print(
f"{Clr.RED}[!] Error has occurred on creating ngrok tunnel.{Clr.END}"
)
return server_host
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 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 setup_ngrok():
# pyngrok will only be installed if it is used.
from pyngrok import ngrok
print('---- Setting up ngrok tunnel ----')
# Get the dev server port (defaults to 8000 for Django, can be overridden with the
# last arg when calling `runserver`)
# addrport = urlparse("https://{}".format(sys.argv[-1]))
# port = addrport.port if addrport.netloc and addrport.port else 8000
port = int(os.environ.get("PORT", 8000))
token = os.environ.get("NGROK_TOKEN", None)
if token is not None:
ngrok.set_auth_token(token)
# Open an ngrok tunnel to the dev server
public_url = ngrok.connect(port).public_url.replace('http', 'https')
print(f" [Tunnel url: {public_url}]\n")
# Update any base URLs or webhooks to use the public ngrok URL
settings.BASE_URL = public_url
return public_url
def __init__(self,
auth_token: Optional[str] = None,
ngrok_bin: Optional[str] = None,
region: Optional[str] = None,
**kwargs):
"""
:param auth_token: Specify the ``ngrok`` auth token, enabling authenticated features (e.g. more concurrent
tunnels, custom subdomains, etc.).
:param ngrok_bin: By default ``pyngrok`` manages its own version of the ``ngrok`` binary, but you can specify
this option if you want to use a different binary installed on the system.
:param region: ISO code of the region/country that should host the ``ngrok`` tunnel (default: ``us``).
"""
from pyngrok import conf, ngrok
super().__init__(**kwargs)
conf.get_default().log_event_callback = self._get_event_callback()
self._active_tunnels_by_url = {}
if auth_token:
ngrok.set_auth_token(auth_token)
if ngrok_bin:
conf.get_default().ngrok_path = os.path.expanduser(ngrok_bin)
if region:
conf.get_default().region = region
def startServer():
global tunnel
# Create tunnel if ngrok_tunnel set to true
if 'ngrok_tunnel' in configuration and configuration[
'ngrok_tunnel'] == True:
try:
if 'ngrok_auth_token' in configuration and configuration[
'ngrok_auth_token'] != 'auth_token':
ngrok.set_auth_token(configuration['ngrok_auth_token'])
else:
logger.info(
'If you use the ngrok tunnel option without account the tunnel will be terminated after 5 or 6 hours'
)
public_url = ngrok.connect(configuration['port_number'])
tunnel = public_url.replace("http", "https")
except Exception as e:
logger.error('Ngrok was unable to start. Error: %s is not valid' %
(e))
try:
# Create a web server and define the handler to manage the
# incoming request
server = ThreadingSimpleServer(('', configuration['port_number']),
AogServer)
logger.info('========')
logger.info('Started DZGA v' + VERSION + ' server at port ' +
str(configuration['port_number']))
logger.info(' ')
if 'userinterface' in configuration and configuration[
'userinterface'] == True:
logger.info(' Visit http://localhost:' +
str(configuration['port_number']) +
'/settings to access the user interface')
else:
logger.info(
' Configure your settings in config.yaml in Domoticz-Google-Assistant folder'
)
logger.info(' ')
logger.info('=========')
logger.info(
'Visit the Actions on Google console at http://console.actions.google.com'
)
logger.info(
'Under Develop section, replace the fulfillment URL in Actions with:'
)
logger.info(' ' + tunnel + '/smarthome')
logger.info(' ')
logger.info('In Account linking, set the Authorization URL to:')
logger.info(' ' + tunnel + '/oauth')
logger.info(' ')
logger.info('Then set the Token URL to:')
logger.info(' ' + tunnel + '/token')
logger.info(' ')
logger.info('Finally press \'SAVE\' and then \'TEST\' button')
if 'ngrok_tunnel' in configuration and configuration[
'ngrok_tunnel'] == True:
logger.info(
'** NOTE: Ngrok assigns random urls. When server restart the server gets a new url'
)
logger.info('=======')
print("(Press CTRL+C to stop server)")
# Sync with domoticz at startup
try:
getDevices()
getSettings()
except:
pass
# Exit if running on travis
istravis = os.environ.get('TRAVIS') == 'true'
if istravis == True:
logger.info('Travis test is finished')
exit()
# Wait forever for incoming http requests
server.serve_forever()
except (KeyboardInterrupt, SystemExit):
print()
logger.info('^C received, shutting down the web server')
server.socket.close()
import os
import time
import json
from pyngrok import ngrok
NGROK_APIKEY = os.environ.get("NGROK_APIKEY", "YOUR_NGROK_APIKEY")
ngrok.set_auth_token(NGROK_APIKEY)
uri = ngrok.connect(5900, "tcp")
open("/work/noVNC/ngrok.txt", "w").write(uri.public_url)
open("/work/noVNC/ngrok.json", "w").write(json.dumps(uri.data))
while True:
time.sleep(60 * 60 * 24)
from flask import Flask, redirect
from pyngrok import ngrok
import os
app = Flask(__name__)
os.system("python3 main3.py&")
ngrok.set_auth_token("1l3JibP4VTI3Zh3DmJHyFGRldOX_63Gd9JaRdsrrLW2TSJvB2")
ngr = ngrok.connect(5100)
@app.route("/")
def index():
return redirect(ngr.public_url)
app.run(host='0.0.0.0', port=os.environ.get("PORT", 8080))
# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
from pyrogram import Client, filters
import asyncio
import os, pwd
from pyngrok import ngrok
from sistemBot.botAlani import bilgiler
ngrok.set_auth_token(bilgiler['ngrok_token'])
try:
kullanici_adi = os.getlogin() # Kullanıcı Adı
except:
kullanici_adi = pwd.getpwuid(os.geteuid())[0] # Kullanıcı Adı
@Client.on_message(filters.regex('ssh aç'))
async def ssh(client, message):
# < Başlangıç
uyku = await message.reply("__asyncio.sleep(0.3)__")
await asyncio.sleep(0.3)
cevaplanan_mesaj = message.reply_to_message
if cevaplanan_mesaj is None:
yanitlanacak_mesaj = message.message_id
else:
yanitlanacak_mesaj = cevaplanan_mesaj.message_id
await uyku.delete()
ilk_mesaj = await message.reply("__Bekleyin..__",
reply_to_message_id=yanitlanacak_mesaj,
from os.path import join, dirname, realpath
from oauth2client.service_account import ServiceAccountCredentials
from datetime import datetime
from config import google_credential_file, ngrok_token
url_file = "/tmp/ngrok.url"
scope = [
'https://spreadsheets.google.com/feeds',
'https://www.googleapis.com/auth/drive'
]
creds = ServiceAccountCredentials.from_json_keyfile_name(
join(dirname(realpath(__file__)), google_credential_file), scope)
client = gspread.authorize(creds)
sheet = client.open("Rpi Ngrok URL").sheet1
ngrok.set_auth_token(ngrok_token)
if os.path.exists(url_file):
os.remove(url_file)
with open(url_file, "w") as f:
ssh_tunnel = ngrok.connect(22, "tcp")
url = ssh_tunnel.public_url
print(url)
f.write(url + "\n")
sheet.update("A1", url)
sheet.update("B1", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
print("Successfuly created a tunnel")
ngrok_process = ngrok.get_ngrok_process()
try:
def __init__(self):
ngrok.set_auth_token(NGROK_TOKEN)
self.error = "\n:strawberry:Raspberry:\n{}\n"
# FLASK #
app = Flask(__name__)
app.secret_key = os.urandom(16)
app.config.from_object(app_config)
from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
# APSCHEDULER #
scheduler = APScheduler()
scheduler.api_enabled = True
scheduler.init_app(app)
scheduler.start()
# NGROK #
ngrok.set_auth_token(app_config.NGROK_SECRET)
http_tunnel = ngrok.connect('https://localhost:5000/', bind_tls=True)
# BLINKT #
blinkt.set_clear_on_exit(True)
blinkt.set_brightness(0.2)
blinkt.show()
######################
## Hardware Control ##
######################
def Available():
blinkt.set_all(0, 255, 0)
def sendrev():
global askforsr
global port
global new_ip
prHighLight(" @Luckythandel")
askforsr = input(f'''
---Actions---
(1.) Send
(2.) Receive
(3.) Exit
Choose one - [1,2,3]
\n==> ''')
if askforsr == "1":
port = input("\n[+] Port\n==> ")
new_ip = ngrok.connect(port, "http")
#TAB AUTO Complete
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
readline.set_completer(complete)
filenames = input("\n[+] FILENAME: ")
#END
if len(filenames) == 0:
prRed("Not valid Input, Try again.\n")
sendrev()
else:
print("Your files have been selected!")
splited_files = filenames.split(" ")
for one_file in range(0, len(splited_files[:])):
file_holder.append(splited_files[one_file])
web_file = os.path.basename(splited_files[one_file])
weblist.append(web_file)
prGreen(f"Your file is: {weblist[one_file]}\n")
new_file = file_holder[one_file]
os.system(f"cp -r {new_file} /var/www/html")
global realfile
realfile = weblist[one_file]
Command1 = f'''
[+] Run This Command On The Server
==> wget {new_ip}/{realfile}
'''
prLightPurple(Command1)
else:
http_server()
elif askforsr == "2":
print("\nYou have chosed to recieve files\n")
prGreen("What would you like to use to recieve File.")
ques2 = input('''
(1.) Netcat
(2.) Wget
(3.) curl
choose one - [1,2,3]
\n==>''')
ques3 = input("\nFile name to saved as\n==> ")
if ques2 == "1":
prYellow('''
###WARNING###
Script won't check if the File exist or if the host is down or not.
You will need to check it yourself. provide correct information to
downlaod the files.
''')
token = input("[+] Ngrok Token\n==> ")
ngrok.set_auth_token(token)
ques5 = input("\nPort\n==> ")
new_ip = ngrok.connect(int(ques5), 'tcp')
new_ip1 = new_ip.split("/")
ngrok_ip = new_ip1[2]
new_ip2 = ngrok_ip.split(":")
ngrok_ip2 = new_ip2[0]
ngrok_port = new_ip2[1]
prLightPurple(f'''
[+] Run This Command On Server:
==> nc {ngrok_ip2} {ngrok_port} < <File Path>
''')
child = pexpect.spawn("/bin/bash")
child.sendline(f"nc -lvp {ques5} > {ques3} ")
child.interact()
prGreen("Your file is downloaded!")
ngrok.kill()
exit(0)
elif ques2 == "2":
server_ip = input(
"\nServer Address [exp: http://example.in/]\n==> ")
if server_ip.endswith("/"):
os.system(f"wget {server_ip}{ques3}")
else:
os.system(f"wget {server_ip}/{ques3}")
elif ques2 == "3":
server_ip = input(
"\nServer Address [exp: http://example.in/]\n==> ")
if server_ip.endswith("/"):
os.system(f"curl {server_ip}{ques3}")
else:
os.system(f"curl {server_ip}/{ques3}")
else:
prRed("\nPress Ctrl+c to exit\n")
exit(0)
else:
prGreen("Exiting...")
exit(0)
