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