def halt_shadowsocks_obfs_service(service_idf):
rtn = returnModel()
from model.db_ss_obfs_server import ssOBFSServerDatabase
from model.db_traffic import serviceTraffic
from proc.proc_ss import ssOBFS_Process
ssDB = ssOBFSServerDatabase()
ssProc = ssOBFS_Process()
trafficDB = serviceTraffic()
item = ssDB.getItem(service_idf)
if item == None:
return rtn.error(500)
elif item["status"] == "error":
return rtn.error(item["code"])
else:
port = int(item["info"]["server_port"])
result = ssProc.deleteServer(port)
if result == False:
return rtn.error(450)
else:
# kill record in database
ssDB.deleteInstance(service_idf)
trafficDB.deleteItem(service_idf)
return rtn.success(200)
def halt_shadowsocks_service(service_idf):
rtn = returnModel()
from model.db_ss_server import ssServerDatabase
from proc.proc_ss import ssProcess
ssDB = ssServerDatabase()
ssProc = ssProcess()
item = ssDB.getItem(service_idf)
if item == None:
return rtn.error(500)
elif item["status"] == "error":
return rtn.error(item["code"])
else:
port = int(item["info"]["server_port"])
kill_proc = ssProc.checkProcess(port=port)
# can not find pid in the system
if len(kill_proc) == 0:
return rtn.error(450)
else:
_pid = kill_proc[0]["pid"]
result = ssProc.killProcess(_pid)
if result == False:
return rtn.error(450)
else:
# kill record in database
ssDB.deleteInstance(service_idf)
return rtn.success(200)
def revoke(service_idf):
rtn = returnModel()
inDB = serviceInfo()
rDB = redisDevice(service_idf)
# first get item
item_result = inDB.getItem(service_idf)
if item_result == None:
return rtn.error(500)
elif item_result["status"] == "error":
return rtn.error(item_result["code"])
else:
info = item_result["info"]
# delete server instance in the database and halt the process
service_type = info["service_type"]
if service_type == "shadowsocks":
res = halt_shadowsocks_service(service_idf)
elif service_type == "shadowsocks-obfs":
res = halt_shadowsocks_obfs_service(service_idf)
else:
return rtn.error(405)
if res["status"] == "success":
result = inDB.deleteItem(service_idf)
rDB.deleteSet()
if result["status"] == "success":
return rtn.success(200)
else:
return result
else:
return res
pass
def send_socket_request(dest_ip,dest_port,data,type="TCP"):
rtn = returnModel()
dest_port = int(dest_port)
if type == "TCP":
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.settimeout(5)
sock.connect((dest_ip,dest_port))
sock.settimeout(None)
sock.sendall(bytes(data + "\n","utf-8"))
# recv data
recv = str(sock.recv(2048),"utf-8")
sock.close()
return json.loads(recv)
except socket.timeout:
return rtn.error(801)
elif type == "UDP":
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
sock.sendto(bytes(data + "\n","utf-8"),(dest_ip,dest_port))
return rtn.success(200)
except Exception as e:
return rtn.error(800)
def start_shadowsocks():
return_data_config = {
"server_port" : "",
"password" : "",
"method" : "",
"timeout" : ""
}
return_data = {
"service_idf":"",
"config":return_data_config
}
rtn = returnModel()
from model.db_ss_server import ssServerDatabase
from proc.proc_ss import ssProcess
ssDB = ssServerDatabase()
ssProc = ssProcess()
port = 0
# lock: to prevent infinite loop (for any reason)
lock = 20
while lock > 0:
lock -= 1
rand_port = randint(config["SHADOWSOCKS_MIN_PORT"],config["SHADOWSOCKS_MAX_PORT"])
if ssDB.portCollision(int(rand_port)) == False:
port = rand_port
break
if port == 0:
return rtn.error(422)
else:
# first generate params
service_idf = gen_service_idf()
service_port = port
service_password = gen_password(16)
service_method = config["SS_DEFAULT_METHOD"]
service_timeout = config["SS_DEFAULT_TIMEOUT"]
res = ssDB.insertServerInstance(service_idf,service_port
,service_password,service_method,service_timeout)
if res == None:
return rtn.error(423)
elif res["status"] == "error":
return rtn.error(423)
elif res["status"] == "success":
# insert success, then create real process
result = ssProc.createProcess(service_port,service_password,service_timeout,service_method)
# if the process not open successfully (maybe... just not install ss-server LOL)
# (2015-12-06)UPDATE : DO NOT CHECK THE RESULT OF PROCESS CREATION!!
# insert config data
return_data_config["server_port"] = service_port
return_data_config["password"] = service_password
return_data_config["method"] = service_method
return_data_config["timeout"] = service_timeout
return_data["service_idf"] = service_idf
return rtn.success(return_data)
pass
def sendSocket(self,status,info):
rtn = returnModel("string")
r_str = ""
if status == "success":
r_str = rtn.success(info)
elif status == "error":
r_str = rtn.error(info)
rb = bytes(r_str,'utf-8')
self.request.sendall(rb)
def decrease_traffic(service_idf,add_traffic):
rtn = returnModel()
siDB = serviceInfo()
add_result = siDB.increaseTraffic(service_idf,add_traffic)
if add_result == None:
return rtn.error(500)
elif add_result["status"] == "success":
return rtn.success(200)
else:
return rtn.error(add_result["code"])
def get_shadowsocks_conf(service_idf):
rtn = returnModel()
from model.db_ss_server import ssServerDatabase
ssDB = ssServerDatabase()
item = ssDB.getItem(service_idf)
if item == None:
return rtn.error(500)
elif item["status"] == "error":
return rtn.error(item['code'])
else:
return rtn.success(item['info'])
def sendSocket(self,status,info):
rtn = returnModel("string")
r_str = ""
if status == "success":
r_str = rtn.success(info)
elif status == "error":
r_str = rtn.error(info)
rb = bytes(r_str,'utf-8')
# dest
socket = self.request[1]
socket.sendto(rb, self.client_address)
def postpone(service_idf,postpone_timestamp):
rtn = returnModel()
siDB = serviceInfo()
p_time = int(postpone_timestamp)
postpone_result = siDB.updateExpireTimestamp(service_idf,p_time)
if postpone_result == None:
return rtn.error(500)
elif postpone_result["status"] == "success":
return rtn.success(200)
else:
return rtn.error(postpone_result["code"])
def get_shadowsocks_obfs_conf(service_idf):
rtn = returnModel()
from model.db_ss_obfs_server import ssOBFSServerDatabase
from proc.proc_ss import ssOBFS_Process
ssOBFSProc = ssOBFS_Process()
ssDB = ssOBFSServerDatabase()
item = ssDB.getItem(service_idf)
if item == None:
return rtn.error(500)
elif item["status"] == "error":
return rtn.error(item['code'])
else:
port = item["info"]["server_port"]
passwd = item["info"]["password"]
conf = ssOBFSProc.generateLocalConfig(port,passwd)
return rtn.success(conf)
def start_shadowsocks_obfs(traffic_strategy):
return_data = {
"service_idf":"",
"config":""
}
rtn = returnModel()
from model.db_ss_obfs_server import ssOBFSServerDatabase
from model.db_traffic import serviceTraffic
from proc.proc_ss import ssOBFS_Process
ssDB = ssOBFSServerDatabase()
ssProc = ssOBFS_Process()
ssT = serviceTraffic()
port = 0
# lock: to prevent infinite loop (for any reason)
lock = 20
while lock > 0:
lock -= 1
rand_port = randint(config["SHADOWSOCKS_MIN_PORT"],config["SHADOWSOCKS_MAX_PORT"])
if ssDB.portCollision(int(rand_port)) == False:
port = rand_port
break
if port == 0:
return rtn.error(422)
else:
# first generate params
service_idf = gen_service_idf()
passwd = gen_password(16)
res = ssDB.insertServerInstance(service_idf,port,passwd)
if res == None:
return rtn.error(423)
elif res["status"] == "error":
return rtn.error(423)
elif res["status"] == "success":
result = ssProc.createServer(port,passwd)
ssT.createNewTraffic(service_idf,traffic_strategy)
if result == True:
return_data["service_idf"] = service_idf
return_data["config"] = ssProc.generateLocalConfig(port,passwd)
return rtn.success(return_data)
else:
return rtn.error(1200)
pass
def connect(service_idf,mac_addr):
rtn = returnModel()
rd = redisDevice(service_idf)
siDB = serviceInfo()
# first, find if service_idf can be found
result = siDB.getItem(service_idf)
if result == None:
return rtn.error(500)
elif result["status"] == "error":
return rtn.error(430)
else:
info = result['info']
# check if devices num is not full
if (rd.countDevice()+int(rd.deviceInList(mac_addr))) > int(info["max_devices"]):
return rtn.error(431)
else:
conf_return_model = {
"service_type":"",
"expire_time":"",
"info":{}
}
# register device into device_db
rd.newDevice(mac_addr)
conf_return_model["expire_time"] = info["expire_time"]
# get configuration
if info["service_type"] == "shadowsocks":
conf_return_model["service_type"] = "shadowsocks"
res = get_shadowsocks_conf(service_idf)
elif info["service_type"] == "shadowsocks-obfs":
conf_return_model["service_type"] = "shadowsocks-obfs"
res = get_shadowsocks_obfs_conf(service_idf)
else:
return rtn.error(405)
if res["status"] == "error":
return rtn.error(res["code"])
else:
conf_return_model['info'] = res['info']
# get conf string then return
return rtn.success(conf_return_model)
pass
def new_service(max_traffic,max_devices,type,expire_timestamp,strategy=""):
# first get active service nums
sDB = serviceInfo()
rtn = returnModel()
count_res = sDB.countActiveService()
# set max num
if max_traffic == -1 or max_traffic >= config["MMAX_TRAFFIC"]:
max_traffic = config["MMAX_TRAFFIC"]
if max_devices == -1 or max_traffic >= config["MMAX_DEVICES"]:
max_devices = config["MMAX_DEVICES"]
if count_res == None:
return rtn.error(420)
else:
active_num = int(count_res["info"])
# if out of quota
if active_num >= config["SERVICE_QUOTA"]:
return rtn.error(421)
else:
# service type switch
if type == "shadowsocks":
result = start_shadowsocks()
elif type == "shadowsocks-obfs":
result = start_shadowsocks_obfs(strategy)
else:
return rtn.error(405)
# handle callback
if result["status"] == "error":
return rtn.error(result['code'])
elif result['status'] == "success":
# add service info
service_idf = result["info"]["service_idf"]
sDB.createNewService(service_idf,max_devices,max_traffic,expire_timestamp,type)
return rtn.success(result['info'])
else:
return rtn.error(420)
ml = os.path.abspath(args.ml)
if taskM == 'reg':
ml = args.ml + scorename + '_' + str(mt) + '_pat_' + str(
es_pat) + '_iter_' + str(iter_) + '_lr_' + str(lr) + '/'
tr_smp_sizes = [10000]
elif taskM == 'clx':
ml = args.ml + str(iter_) + '/'
tr_smp_sizes = [100, 200, 500, 1000, 2000, 5000, 10000]
else:
print('Review Task Mode')
try:
os.stat(os.path.abspath(odir))
except:
os.mkdir(os.path.abspath(odir))
### Read test data ###
nReps = 20
df = ut.readFrames(iter_, tr_smp_sizes, nReps, mode, ssd)
X, y = ut.read_X_y_5D(df, scorename)
dSize = X[0].squeeze().shape
### Load model ###
net = ut.returnModel(iter_, tr_smp_sizes, nReps, ml, mt, nc)
net.eval()
### Save Saliency ###
area_masks, _, _ = ut.get_brain_area_masks(dSize)
ut.run_saliency(odir, itrpm, X, net, area_masks, iter_, scorename, taskM)
def __init__(self,env="normal"):
self.env = env
Database.__init__(self,env=self.env)
self.createTable()
self.rtn = returnModel()
