import os
import re
import time
import uuid
import select
import psutil
from sys import exit as exx
from subprocess import Popen, PIPE
HOME = os.path.expanduser("~")
CWD = os.getcwd()
tokens = {}
class ngrok:
def __init__(self, TOKEN=None, USE_FREE_TOKEN=True,
service=[['Service1', 80, 'tcp'], ['Service2', 8080, 'tcp']],
region='us',
dBug=[f"{HOME}/.ngrok2/ngrok.yml", 4040]):
self.region = region
self.configPath, self.dport = dBug
self.TOKEN = TOKEN
self.USE_FREE_TOKEN = USE_FREE_TOKEN
self.service = service
if USE_FREE_TOKEN:
self.sdict = {}
for i, sn in enumerate(service):
tempcP = f'{HOME}/.ngrok2/'+sn[0]+'.yml'
# Port, Protocol, config path
self.sdict[sn[0]] = [self.dport+i, sn[2], tempcP]
def nameport(self, TOKEN, AUTO):
if AUTO:
try:
return tokens.popitem()[1]
except KeyError:
return "Invalid Token"
elif not TOKEN:
if not 'your' in tokens.keys():
from IPython import get_ipython
from IPython.display import clear_output
ipython = get_ipython()
print(r"Copy authtoken from https://dashboard.ngrok.com/auth")
__temp = ipython.magic('%sx read -p "Token :"')
tokens['your'] = __temp[0].split(':')[1]
USR_Api = "your"
clear_output()
else:
USR_Api = "your"
else:
USR_Api = "mind"
tokens["mind"] = TOKEN
return tokens[USR_Api]
def ngrok_config(self, token, Gport, configPath, region, service):
import os
data = """
region: {}
update: false
update_channel: stable
web_addr: localhost:{}
tunnels:\n""".format(region, Gport)
if not self.USE_FREE_TOKEN:
auth ="""
authtoken: {}""".format(token)
data = auth+data
tunnels = ""
for S in service:
Sn, Sp, SpC = S
tunnels += """ {}:
addr: {}
proto: {}
inspect: false\n""".format(Sn, Sp, SpC)
data = data + tunnels
os.makedirs(f'{HOME}/.ngrok2/', exist_ok=True)
with open(configPath, "w+") as configFile:
configFile.write(data)
return True
def startWebUi(self, token, dport, nServer, region, btc, configPath,
displayB, service, v):
import os, time, urllib
from IPython.display import clear_output
from json import loads
if token == "Invalid Token":
print(tokens)
os.exit()
installNgrok()
if v:
clear_output()
loadingAn(name="lds")
textAn("Starting ngrok ...", ty='twg')
if self.USE_FREE_TOKEN:
for sn in service:
self.ngrok_config(
token,
self.sdict[nServer][0],
self.sdict[nServer][2],
region,
service)
if sn[0] == nServer:
runSh(f"ngrok {sn[2]} -config={self.sdict[nServer][2]} {sn[1]} &", shell=True)
else:
self.ngrok_config(token, dport, configPath, region, service)
runSh(f"ngrok start --config {configPath} --all &", shell=True)
time.sleep(3)
try:
if self.USE_FREE_TOKEN:
dport = self.sdict[nServer][0]
nServer = 'command_line'
host = urllib.request.urlopen(f"http://localhost:{dport}/api/tunnels")
else:
host = urllib.request.urlopen(f"http://localhost:{dport}/api/tunnels")
host = loads(host.read())['tunnels']
for h in host:
if h['name'] == nServer:
host = h['public_url'][8:]
break
except urllib.error.URLError:
if v:
clear_output()
loadingAn(name="lds")
textAn("Ngrok Token is in used!. Again trying token ...", ty='twg')
time.sleep(2)
return True
data = {"url": f"https://{host}"}
if displayB:
displayUrl(data, btc)
return data
def start(self, nServer, btc='b', displayB=True, v=True):
import urllib
from IPython.display import clear_output
from json import loads
try:
nServerbk = nServer
if self.USE_FREE_TOKEN:
dport = self.sdict[nServer][0]
nServer = 'command_line'
else:
dport = self.dport
host = urllib.request.urlopen(f"http://localhost:{dport}/api/tunnels")
host = loads(host.read())['tunnels']
for h in host:
if h['name'] == nServer:
host = h['public_url'][8:]
data = {"url": f"https://{host}"}
if displayB:
displayUrl(data, btc)
return data
raise Exception('Not found tunnels')
except urllib.error.URLError:
for run in range(10):
if v:
clear_output()
loadingAn(name='lds')
dati = self.startWebUi(
self.nameport(self.TOKEN, self.USE_FREE_TOKEN) if not self.USE_FREE_TOKEN else {},
self.dport,
nServerbk,
self.region,
btc,
self.configPath,
displayB,
self.service,
v
)
if dati == True:
continue
return dati
def checkAvailable(path_="", userPath=False):
from os import path as _p
if path_ == "":
return False
else:
return (
_p.exists(path_)
if not userPath
else _p.exists(f"/usr/local/sessionSettings/{path_}")
)
def accessSettingFile(file="", setting={}, v=True):
from json import load, dump
if not isinstance(setting, dict):
if v:print("Only accept Dictionary object.")
exx()
fullPath = f"/usr/local/sessionSettings/{file}"
try:
if not len(setting):
if not checkAvailable(fullPath):
if v:print(f"File unavailable: {fullPath}.")
exx()
with open(fullPath) as jsonObj:
return load(jsonObj)
else:
with open(fullPath, "w+") as outfile:
dump(setting, outfile)
except:
if v:print(f"Error accessing the file: {fullPath}.")
def displayUrl(data, btc='b', pNamU='Public URL: ', EcUrl=None, ExUrl=None, cls=True):
from IPython.display import HTML, clear_output
if cls:
clear_output()
showTxT = f'{pNamU}{data["url"]}'
if EcUrl:
showUrL = data["url"]+EcUrl
elif ExUrl:
showUrL = ExUrl
else:
showUrL = data["url"]
if btc == 'b':
# blue
bttxt = 'hsla(210, 50%, 85%, 1)'
btcolor = 'hsl(210, 80%, 42%)'
btshado = 'hsla(210, 40%, 52%, .4)'
elif btc == 'g':
# green
bttxt = 'hsla(110, 50%, 85%, 1)'
btcolor = 'hsla(110, 86%, 56%, 1)'
btshado = 'hsla(110, 40%, 52%, .4)'
elif btc == 'r':
# red
bttxt = 'hsla(10, 50%, 85%, 1)'
btcolor = 'hsla(10, 86%, 56%, 1)'
btshado = 'hsla(10, 40%, 52%, .4)'
return display(HTML(''''''))
def findProcess(process, command="", isPid=False):
from psutil import pids, Process
if isinstance(process, int):
if process in pids():
return True
else:
for pid in pids():
try:
p = Process(pid)
if process in p.name():
for arg in p.cmdline():
if command in str(arg):
return True if not isPid else str(pid)
else:
pass
else:
pass
except:
continue
def installArgoTunnel():
if checkAvailable(f"{HOME}/tools/argotunnel/cloudflared"):
return
else:
import os
from shutil import unpack_archive
from urllib.request import urlretrieve
os.makedirs(f'{HOME}/tools/argotunnel/', exist_ok=True)
aTURL = findPackageR("cloudflare/cloudflared", "cloudflared-linux-amd64")
urlretrieve(aTURL, f'{HOME}/tools/argotunnel/cloudflared')
# unpack_archive('cloudflared.tgz',
# f'{HOME}/tools/argotunnel')
os.rename(f'{HOME}/tools/argotunnel/cloudflared', f'{HOME}/tools/argotunnel/argo')
os.chmod(f'{HOME}/tools/argotunnel/argo', 0o755)
# os.unlink('cloudflared.tgz')
def installNgrok():
if checkAvailable("/usr/local/bin/ngrok"):
return
else:
import os
from zipfile import ZipFile
from urllib.request import urlretrieve
ngURL = "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip"
urlretrieve(ngURL, 'ngrok-amd64.zip')
with ZipFile('ngrok-amd64.zip', 'r') as zip_ref:
zip_ref.extractall('/usr/local/bin/')
os.chmod('/usr/local/bin/ngrok', 0o755)
os.unlink('ngrok-amd64.zip')
def installAutoSSH():
if checkAvailable("/usr/bin/autossh"):
return
else:
runSh("apt-get install autossh -qq -y")
def runSh(args, *, output=False, shell=False, cd=None):
import subprocess, shlex
if not shell:
if output:
proc = subprocess.Popen(
shlex.split(args), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=cd
)
while True:
output = proc.stdout.readline()
if output == b"" and proc.poll() is not None:
return
if output:
print(output.decode("utf-8").strip())
return subprocess.run(shlex.split(args), cwd=cd).returncode
else:
if output:
return (
subprocess.run(
args,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=cd,
)
.stdout.decode("utf-8")
.strip()
)
return subprocess.run(args, shell=True, cwd=cd).returncode
def loadingAn(name="cal"):
from IPython.display import HTML
if name == "cal":
return display(HTML(''))
elif name == "lds":
return display(HTML(''''''))
def textAn(TEXT, ty='d'):
from IPython.display import HTML
if ty == 'd':
return display(HTML(''''''))
elif ty == 'twg':
textcover = str(len(TEXT)*0.55)
return display(HTML(''''''+TEXT+'''
'''))
class LocalhostRun:
RE_PATTERN = r"n,\s(?:https?://)?((?:[-\w]+\.)+[\w]{2,}(?:/[-\w./?%&=]*)?)"
def __init__(self,port,id=None,interval=30,retries=30):
import os
filePath = "/usr/local/sessionSettings/localhostDB.json"
if not os.path.exists(filePath):
os.makedirs(filePath[:-16], exist_ok=True)
open(filePath, 'w').close()
installAutoSSH()
if not id:id=str(uuid.uuid4())[:8]
self.connection=None
self.id=id
self.port=port
self.interval=interval
self.retries=retries
def start(self):
if self.connection:self.connection.kill()
self.connection=Popen(f"ssh -R 80:localhost:{self.port} {self.id}@ssh.localhost.run -o StrictHostKeyChecking=no".split(), stdout=PIPE, stdin=PIPE)
try:
outputString = read_subprocess_output(self.connection, timeout=5)
return re.findall(self.RE_PATTERN, outputString)[0]
except:
raise Exception(self.connection.stdout.readline().decode("utf-8"))
def keep_alive(self):
# if self.connection:self.connection.kill()
import urllib
try:
localhostOpenDB = dict(accessSettingFile("localhostDB.json", v=False))
except TypeError:
localhostOpenDB = dict()
if findProcess("autossh", f"80:localhost:{self.port}"):
try:
oldAddr = localhostOpenDB[str(self.port)]
urllib.request.urlopen("http://"+oldAddr)
return oldAddr
except:
pass
for _ in range(2):
self.connection=Popen(f"autossh -R 80:localhost:{self.port} {self.id}@ssh.localhost.run -o StrictHostKeyChecking=no -o ServerAliveInterval={self.interval} -o ServerAliveCountMax={self.retries}".split(),
stdout=PIPE, stdin=PIPE, stderr=PIPE)
#print("ssh -R 80:localhost:{self.port} {self.id}@ssh.localhost.run -o StrictHostKeyChecking=no -o ServerAliveInterval={self.interval} -o ServerAliveCountMax={self.retries}")
try:
outputString = read_subprocess_output(self.connection, timeout=5)
newAddr = re.findall(self.RE_PATTERN, outputString)[0]
localhostOpenDB[str(self.port)] = newAddr
accessSettingFile("localhostDB.json" , localhostOpenDB, v=False)
return newAddr
except:
outs, errs = self.connection.communicate(timeout=15)
self.connection.kill()
# print(outs)
# print(errs)
if re.search(r"Permission\sdenied\s\(publickey\)", errs.decode("utf-8")):
os.system("ssh-keygen -q -t rsa -N '' -f ~/.ssh/id_rsa")
continue
raise Exception(errs.decode("utf-8"))
break
def kill(self):
self.connection.kill()
class ArgoTunnel:
def __init__(self, port, proto='http', metrics=49589, interval=30, retries=30):
import os
filePath = "/usr/local/sessionSettings/argotunnelDB.json"
if not os.path.exists(filePath):
os.makedirs(filePath[:-17], exist_ok=True)
open(filePath, 'w').close()
#Installing argotunnel
installArgoTunnel()
self.connection=None
self.proto=proto
self.port=port
self.metricPort=metrics
self.interval=interval
self.retries=retries
# def start(self):
# if self.connection:self.connection.kill()
# # self.connection=Popen(f"ssh -R 80:localhost:{self.port} {self.id}@ssh.localhost.run -o StrictHostKeyChecking=no".split(), stdout=PIPE, stdin=PIPE)
# self.connection=Popen(f"/content/tools/argotunnel/cloudflared tunnel --url {self.proto}://0.0.0.0:{self.port} --logfile cloudflared.log".split(), stdout=PIPE, stdin=PIPE)
# try:
# return re.findall("https://(.*?.trycloudflare.com)",self.connection.stdout.readline().decode("utf-8"))[0]
# except:
# raise Exception(self.connection.stdout.readline().decode("utf-8"))
def keep_alive(self):
# if self.connection:self.connection.kill()
import urllib, requests, re
from urllib.error import HTTPError
try:
argotunnelOpenDB = dict(accessSettingFile("argotunnelDB.json", v=False))
except TypeError:
argotunnelOpenDB = dict()
if findProcess("argo", f"localhost:{self.metricPort}"):
try:
oldAddr = argotunnelOpenDB[str(self.port)]
if requests.get("http://"+oldAddr).status_code == 200:
return oldAddr
except:
pass
self.connection=Popen(f"{HOME}/tools/argotunnel/argo tunnel --url {self.proto}://0.0.0.0:{self.port} --logfile {HOME}/tools/argotunnel/argo_{self.port}.log --metrics localhost:{self.metricPort}".split(),
stdout=PIPE, stdin=PIPE, stderr=PIPE, universal_newlines=True)
time.sleep(5)
hostname = None
for i in range(20):
try:
with urllib.request.urlopen(f"http://127.0.0.1:{self.metricPort}/metrics") as response:
hostname = re.search(r'userHostname=\"https://(.+)\"',
response.read().decode('utf-8'), re.MULTILINE)
if not hostname:
time.sleep(1)
continue
hostname = hostname.group(1)
break
except HTTPError:
time.sleep(2)
if not hostname:
raise RuntimeError("Failed to get user hostname from cloudflared")
argotunnelOpenDB[str(self.port)] = hostname
accessSettingFile("argotunnelDB.json" , argotunnelOpenDB, v=False)
return hostname
def kill(self):
self.connection.kill()
class jprq:
def __init__(self, port, proto='http', ids=None):
import os, uuid
filePath = "/usr/local/sessionSettings/jprqDB.json"
if not os.path.exists(filePath):
os.makedirs(filePath[:-11], exist_ok=True)
open(filePath, 'w').close()
if not ids:self.ids=str(uuid.uuid4())[:12]
#Installing jprq
runSh("pip install jprq")
self.connection=None
self.proto=proto
self.port=port
def keep_alive(self):
# if self.connection:self.connection.kill()
import urllib, requests, re
try:
jprqOpenDB = dict(accessSettingFile("jprqDB.json", v=False))
except TypeError:
jprqOpenDB = dict()
if findProcess("jprq", f"{self.port}"):
try:
oldAddr = jprqOpenDB[str(self.port)]
if requests.get("http://"+oldAddr).status_code == 200:
return oldAddr
except:
pass
hostname = f"OneClickRun-{self.ids}"
self.connection=Popen(f"jprq -s {hostname} {self.port}".split(),
stdout=PIPE, stdin=PIPE, stderr=PIPE)
time.sleep(3)
# try:
# return re.findall("https://(.*?.jprq.live/)", self.connection.stdout.readline().decode("utf-8"))[0]
# except:
# raise Exception(self.connection.stdout.readline().decode("utf-8"))
hostname += ".jprq.live"
jprqOpenDB[str(self.port)] = hostname
accessSettingFile("jprqDB.json" , jprqOpenDB, v=False)
return hostname
def kill(self):
self.connection.kill()
class PortForward:
def __init__(self,connections,region=None,SERVICE="localhost",TOKEN=None,USE_FREE_TOKEN=None,config=None):
c=dict()
for con in connections:
c[con[0]]=dict(port=con[1],proto=con[2])
self.connections=c
if config:config[1] = closePort(config[1])
self.config = config
if SERVICE=="ngrok":self.ngrok=ngrok(TOKEN,USE_FREE_TOKEN,connections,region,self.config)
self.SERVICE = SERVICE
def start(self,name,btc='b',displayB=True,v=True):
from IPython.display import clear_output
if self.SERVICE == "localhost":
con=self.connections[name]
port=con["port"]
proto=con["proto"]
if(proto=="tcp"):
return self.ngrok.start(name,btc,displayB,v)
else:
if v:
clear_output()
loadingAn(name="lds")
textAn("Starting localhost ...", ty="twg")
data = dict(url="https://"+LocalhostRun(port).keep_alive())
if displayB:
displayUrl(data, btc)
return data
elif self.SERVICE == "ngrok":
return self.ngrok.start(name,btc,displayB,v)
elif self.SERVICE == "argotunnel":
con=self.connections[name]
port=con["port"]
proto=con["proto"]
if v:
clear_output()
loadingAn(name="lds")
textAn("Starting Argo Tunnel ...", ty="twg")
data = dict(url="https://"+ArgoTunnel(port, proto, closePort(self.config[1])).keep_alive())
if displayB:
displayUrl(data, btc)
return data
elif self.SERVICE == "jprq":
con=self.connections[name]
port=con["port"]
proto=con["proto"]
if v:
clear_output()
loadingAn(name="lds")
textAn("Starting jprq ...", ty="twg")
data = dict(url="https://"+jprq(port, proto).keep_alive())
if displayB:
displayUrl(data, btc)
return data
class PortForward_wrapper(PortForward):
def __init__(self,SERVICE,TOKEN,USE_FREE_TOKEN,connections,region,config):
super(self.__class__,self).__init__(connections,region,SERVICE,TOKEN,USE_FREE_TOKEN,config)
def findPackageR(id_repo, p_name, tag_name=False, all_=False):
import requests
for rawData in requests.get(f"https://api.github.com/repos/{id_repo}/releases").json():
if tag_name:
if rawData['tag_name'] != tag_name:
continue
for f in rawData['assets']:
if p_name == f['browser_download_url'][-len(p_name):]:
rawData['assets'] = f
return f['browser_download_url'] if not all_ else rawData
raise Exception("not found or maybe api changed!\n Try again with Change packages name")
def closePort(port):
import socket
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
for _ in range(100):
if s.connect_ex(('localhost', port)) == 0:
port += 1
else:
return port
raise Exception("Close port not found!")
def read_subprocess_output(process, timeout=5):
output = ""
# set the process to non-blocking mode
process.stdout.fileno()
# create a poll object to wait for data
poll_obj = select.poll()
poll_obj.register(process.stdout, select.POLLIN)
# read the data with a timeout
start_time = time.monotonic()
while True:
# calculate the remaining timeout
elapsed_time = time.monotonic() - start_time
remaining_time = timeout - elapsed_time
# break if the timeout has expired
if remaining_time <= 0:
process.kill()
output += f"\nProcess killed after {timeout} seconds due to timeout."
break
# wait for data with a timeout
poll_result = poll_obj.poll(remaining_time * 1000)
if poll_result:
# read the available data
output += process.stdout.readline().decode().strip() + "\n"
# break if the subprocess has exited
if process.poll() is not None:
output += process.stdout.read().decode().strip()
break
return output
def run_process(command, shell=False, cwd=None, env=None, notSilent=True):
for proc in psutil.process_iter():
try:
# Get process info as a named tuple containing the process name and command-line arguments
process_info = proc.as_dict(attrs=['pid', 'name', 'cmdline'])
process_cmdline = process_info['cmdline']
# Check if the command matches the process command-line arguments
if process_cmdline == command.split():
if notSilent:
print("Killing process with PID", process_info['pid'])
proc.kill()
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
pass
if notSilent:
print("Starting process with command", command)
Popen(command, shell=shell, cwd=cwd, env=env)