class PiggyNetwork():

	host = '127.0.0.1'
	base_port = 50000
	base_data_path = "/primary_data.txt"
	base_backup_path = "/backup_data.txt"
	# Defining the workload per server. In this case clients with last names A-M are processed by server 1 #
	# and clients with last names N-Z are processed by server 2 #
	total_workload = list(string.ascii_uppercase)

	# Initialize our Network with two servers, with divided workloads, and their relevant data paths. Each server is then #
	# added to the other's detectable network                                                                             #
	def __init__(self):
		self.server1 = Server(self.base_port, self.total_workload[:14], "server1" + self.base_data_path, "server1" + self.base_backup_path)
		self.server2 = Server(self.base_port + 1, self.total_workload[14:], "server2" + self.base_data_path, "server2" + self.base_backup_path)
		self.server1.add_server_to_network(self.server2)
		self.server2.add_server_to_network(self.server1)

	# Getters #
	def get_server1(self):
		return self.server1

	def get_server2(self):
		return self.server2
	# End Getters #

	# Multi-Threaded Functionality #
	def boot_server(self, server):
		server.listen()

	def initialize(self):
		thread1 = threading.Thread(target=self.boot_server, args=(self.server1,))
		thread2 = threading.Thread(target=self.boot_server, args=(self.server2,))
		thread1.start()
		thread2.start()
    def server(self, dist, target, upgrade_from_path=None, start=False):

        if upgrade_from_path is not None:
            raise Exception("***DEPRECATED*** Please use \"xl-helper upgrade server\"")

        source = dist.path if isinstance(dist, LocalServerDist) else self.cache.get(dist)

        ZipFile(source, 'r').extractall(target)

        # Copy available plugins
        server_dir = os.path.join(target, '.'.join(dist.get_filename().split('.')[:-1]))

        print "Server has been installed to %s" % server_dir

        for root, dirs, files in os.walk(os.path.join(server_dir, 'available-plugins')):
            for file_ in files:
                print "Copying available plugin %s" % file_
                if file_.endswith('.jar'):
                    shutil.copy(os.path.join(root, file_), os.path.join(server_dir, 'plugins', file_))

        proper_license = self.license_location if (dist.version == 'SNAPSHOT' or int(dist.version[0]) >= 4) else self.license_location_3x

        print "Copying license from %s" % proper_license
        shutil.copy(proper_license, os.path.join(server_dir, 'conf', 'deployit-license.lic'))

        for dirpath, d, file_names in os.walk(target):
            for filename in file_names:
                if filename.endswith(".sh"):
                    os.chmod(dirpath + '/' + filename, 0750)

        if start:
            Server.from_config(config=self.config, home=server_dir).run()

        return server_dir
Esempio n. 3
0
    def connect_to_server(self, hostname, port):
        """Handle connection to desired server

        Handles checking of certificate.

        Return Server instance."""

        self.logger.info("Connecting to %s:%s" % (hostname, port))
        try:
            server = Server(hostname, port)
        except Exception as e:
            self.logger.error("Error connecting to %s:%s: %s" % (hostname, port, e))
            raise
        self.logger.debug("Server subject is %s" % server.subject().as_text())

        self.logger.info("Checking certificate with Perspectives")
        try:
            fingerprint = server.get_fingerprint()
            service = Service(hostname, port)
            self.checker.check_seen_fingerprint(service, fingerprint)
        except PerspectivesException as e:
            self.logger.error("Perspectives check failed: %s" % str(e))
            raise

        self.logger.debug("Connection to server established")
        return server
Esempio n. 4
0
    def __init__(self, gui, name, parent=None):
        Server.__init__(self, gui, name)
        ns = Pyro.naming.NameServerLocator().getNS()
        self.game = Pyro.core.getProxyForURI(ns.resolve('jeopardy'))
        #    'PYRONAME://' + 'jeopardy')
        self.running = False

        self.name = name
	def __init__(self, config, buffSize=1024):
		Server.__init__(self, config["eventServer"]["ipAddress"], 
			config["eventServer"]["port"], buffSize)
		self.dbConfig = config["dbSettings"]
		self.running = True
		self.mediaDir = "media/"
		if not os.path.isdir(self.mediaDir):
			os.makedirs(self.mediaDir)

		print("Event Consumer Server started...")
Esempio n. 6
0
def testElectionTimeout():
    s1 = Server()
    s2 = Server()
    s3 = Server()
    
    s1.setNeighbors([s2, s3])
    s2.setNeighbors([s1, s3])
    s3.setNeighbors([s1, s2])
    
    t1 = Thread(target=s1.electionTimeout)
    t1.start()
    time.sleep(5)
    t2 = Thread(target=s2.electionTimeout)
    t2.start()
    t3 = Thread(target=s3.electionTimeout)
    t3.start()
    
    # Add to the leaders log a command no none else has
    s1.clusterLeader.log.append(("test", 1, False, 0))
    
    # Add a state machine no one else has
    s1.clusterLeader.stateMachine[1] = "test"

    time.sleep(5)
    assertion(s1.state == ServerState.leader, "Server should be the leader.")
    assertion(s2.state == ServerState.follower, "Server should be the follower.")
    assertion(s3.state == ServerState.follower, "Server should be the follower.")
    
    assertion(len(s1.clusterLeader.log) == 2, "Server has the right size log.")
    assertion(s1.log == s2.log, "Server has the right log.")
    assertion(s3.log == s2.log, "Server has the right log.")
    assertion(s2.log == s3.log, "Server has the right log.")
    
    assertion(len(s1.stateMachine) == 1, "Server has the right size state machine.")
    assertion(s1.stateMachine[1] == s2.stateMachine[1], "Server has the right state machine")
Esempio n. 7
0
def main():
    signal.signal(signal.SIGTERM, handler)
    signal.signal(signal.SIGINT, handler)
    server = Server()
    server.start()
    while(exit_flag == 0):
        time.sleep(1)

    print 'Exiting on signal %d, waiting for all threads to finish...' % (exit_flag)
    sys.stdout.flush()
    server.stop()
    print 'done.\n'
Esempio n. 8
0
    def __init__(self, host, port):
        """create a XML-RPC server

Takes two initial inputs:
    host  -- hostname of XML-RPC server host
    port  -- port number for server requests
        """
        Server.__init__(self)
        SimpleXMLRPCDispatcher.__init__(self, allow_none=False, encoding=None)

        self._installSocket(host, port)
        self._activeProcesses = {}  # { fd : pid }
Esempio n. 9
0
	def getModes(self, modes, params=[]):
		modedir="+"
		r=[]
		param_idx=0
		svr=Server.getLinkedServer()
		for modechar in modes:
			if(modechar in ("+", "-")):
				modedir=modechar
				continue
			#if this line makes it crash again, it's Unreal's fault -- svr.chanmodes contains *all* of the modes that it specified in PROTOCTL!
			#which, btw, does not include q, a, o, h, or v - no wonder >.>
			#print svr.chanmodes
			#print svr
			if(modechar in ("q", "a", "o", "h", "v")):
				#r[modeID]=params[param_idx]
				r.append([modedir, modechar, params[param_idx]])
				param_idx+=1
			elif(svr.chanmodes[modechar]=="boolean"):
				#r[modeID]=True
				r.append([modedir, modechar, True])
			elif(modedir=="+" or svr.chanmodes[modechar]=="paramrequired"):
				#r[modeID]=params[param_idx]
				r.append([modedir, modechar, params[param_idx]])
				params_idx+=1
		return r
Esempio n. 10
0
    def __init__(self,
            stats = None,
            render = None) :
        self.waiting = PriorityQueue()
        self.server = Server()
        self.active = None
        self.events = EventList()
        self.clock = 0
        self.tasks = []
        self.until = 0

        # Statistics
        if stats is not None:
            self.stats = True
            self.stats_file = open(stats, "wb")
            self.stats_writer = csv.writer(self.stats_file, delimiter='|', lineterminator='\n')
            self.write_headers()
        else:
            self.stats = False

        # Rendering
        if render is not None:
            self.render = True
            self.render_file = render
            self.render_data = dict()
        else:
            self.render = False
Esempio n. 11
0
 def __init__(self, parent=None):
   #Instance variables
   self.chatLines = []
   self.consoleLines = []
   self.lastServerLine = 'first run'
   self.onlineDict = {}
   self.pluginsDict = {} 
   
   #Initialize a QTimer to run background updates (online players, status, new chat messages, etc)
   self.repeatingTimer = QtCore.QTimer()
   self.singleTimer = QtCore.QTimer() #Not used...
   
   self.s=Server()
   QtGui.QWidget.__init__(self, parent)
   self.ui = Ui_MainWindow()
   self.ui.setupUi(self)
   self.initUI()
   
   self.startRepeatingTimer()
   self.findPlugins() #Find the currently installed plugins by searching the plugin folder
   
   #Set the start/stop button text
   if self.s.status():
     self.ui.pushButtonStopStart.setText('Stop Server')
   else:
     self.ui.pushButtonStopStart.setText('Start Server')
Esempio n. 12
0
    def __init__(self):
        print("SpinOS 0.2")
        print("Group 5 IDP 2014 NHL")
        print("Default string encoding : " + str(sys.getdefaultencoding()).upper())
        SpinOS.logger = Logger(Logger.SENSOR_VALUES)
        print("Logger level : " + SpinOS.logger.get_loglevel_string())

        GPIO.setmode(GPIO.BOARD) ## Use board pin numbering
        GPIO.setup(11, GPIO.OUT)
        GPIO.setwarnings(False)

        SpinOS.play_sound(2)
        #logger aanmaken
        self.movementHandler = MovementHandler()

        #server maken op poort 15, omdat ie vrij is
        self.server = Server(15, SpinOS.logger)
        #server starten
        self.server.startServer()
        #server aan logger geven
        SpinOS.logger.set_server(self.server)

        #running op true zetten
        self.running = True
        #mode op manual zetten
        self.mode = "manual"
        #server aanmaken en starten

        self.current_mode = ManualMode(self.movementHandler, self.logger)

        #main loop opstarten
        self.main_thread = threading.Thread(target=self.run)
        self.main_thread.start()

        #Check of we op de raspberry pi zitten
        if platform.system() != "Windows":
            #import mpu
            from MPU6050 import MPU6050
            self.MPU = MPU6050(SpinOS.logger)
            #import os.path om te kijken of de arduino er is
            import os.path
            self.serial_device = None
            #loop door verschillende usb devices. De naam veranderd namelijk soms
            for i in xrange(0, 3):
                #de naam van de usb
                serial_device = "/dev/ttyUSB" + str(i)
                #kijk of de usb er is
                if os.path.exists(serial_device):
                    #als de arduino er is moeten we serial importen
                    from Serial import Serial
                    #maak een nieuwe serial
                    self.serial = Serial(SpinOS.logger, serial_device)
                    #sla de naam van de arduino op
                    self.serial_device = serial_device
                    break
            #start de sensor thread
            self.sensor_running = True
            self.sensor_thread = threading.Thread(target=self.runSensors())
            self.sensor_thread.start()
Esempio n. 13
0
 def attendance():
     if not PaipaiDai.__check_attendance():
         res = Server.post('http://invest.ppdai.com/PaiMoney/PaiMoneySignin', data=None,
                           headers={'Referer': u'http://invest.ppdai.com/account/lend'})
         if res and res['Code'] > 0:
             return True
         else:
             return False
Esempio n. 14
0
class Application(object):
	server = None
	def __init__(self):
		self.server = Server()
		
	def run(self):
		print 'Initialize'
		if not self.server.initialize():
			print 'Game server initialization fail'
			return
		print 'Initialized'
		while True:
			try:
				self.server.loop()
			except KeyboardInterrupt as e:
				print 'Keyboard interrupt!'
				self.server.stop_and_cleanup()
				return
Esempio n. 15
0
    def __init__(self, configPath):
        serverConfig = ServerConfig(configPath)

        self.warehouse = Warehouse(serverConfig.getWarehousePath())

        logMngr = ServerLogger()
        logMngr.addFileHandler(serverConfig.getLogDirectory())

        self.server = Server(int(serverConfig.getPortNo()),
                             serverConfig.getURLHandlers())
Esempio n. 16
0
    def __init__(self, c_instance):
        self.c_instance = c_instance
        self._server = Server()
        self._setup_server()

        Log.info('Inicializado!')

        if self.song().visible_tracks_has_listener(self.refresh_state) != 1:
            Log.info('setting listener')
            self.song().add_visible_tracks_listener(self.refresh_state)
Esempio n. 17
0
	def __init__(self, host, port, mod, arma_path, oa_path, cpucount=None, exthreads=None, maxmem=None):
		self.host = host
		self.port = port
		self.mod = mod
		self.arma_path = arma_path
		self.oa_path = oa_path
		self.cpucount = cpucount
		self.exthreads = exthreads
		self.maxmem = maxmem
		self.server_mon = Server(self.host, self.port)
Esempio n. 18
0
 def login(uname, pwd):
     """ 登陆 """
     data = {
         "IsAsync": "true",
         "Redirect": "",
         "UserName": uname,
         "Password": pwd,
         "RememberMe": "true",
     }
     url = 'https://ac.ppdai.com/User/Login'
     return Server.login(url, data) is not None
Esempio n. 19
0
File: VPyN.py Progetto: sok63/vpyn
def main():
    my = Manage(getpass('Enter password: '******'hex')
    print "Public Key y : %s" % my.ecc.pubkey_y.encode('hex')
    print "\ntry help for help ;)"
    # Now asynchrone 
    monkey.patch_all()
    fcntl.fcntl(sys.stdin, fcntl.F_SETFL, os.O_NONBLOCK)
    S = shell(my)
    server = Server(port, my)
    try:
        S.loop()
    except KeyboardInterrupt:
        pass
    if server.ready() is False:
        server.kill(block=True)
    print "Bye"
    sys.exit(0)
Esempio n. 20
0
    def __init__(self):
        self.timer = Timer()
        self.tweetGen = TweetGen(self.timer)
        self.server = Server(self.timer)
        self.userNodes = self.server.get_user_nodes()
        self.userNodeNum = len(self.userNodes)

        self.userCurNetIn = [0] * self.userNodeNum
        self.userCurNetOut = [0] * self.userNodeNum
        self.userAccNetIn = [0] * self.userNodeNum
        self.userAccNetOut = [0] * self.userNodeNum
Esempio n. 21
0
    def get_loan_list(url, cache, use_cookie=False):
        """ 获取散标列表, 返回列表 """
        domain = PaipaiDai.get_domain(url)
        data, cache = Server.get(url, cache=cache, use_cookie=use_cookie)
        if data:
            data, next_page = Analyzer.get_loan_list(data)
            if next_page:
                next_page = os.path.join(domain, next_page.lstrip('/'))
            return data, next_page, cache

        return [], None, False
Esempio n. 22
0
    def connect_to_server(self, hostname, port):
        """Handle connection to desired server

        Handles checking of certificate.

        Return Server instance."""
        
        self.logger.info("Connecting to %s:%s" % (hostname, port))
        try:
            server = Server(hostname, port)
        except Exception as e:
            self.logger.error("Error connecting to %s:%s: %s" % (hostname,
                                                                     port,
                                                                     e))
            raise

        self.logger.debug("Server subject is %s" % (server.subject().as_text()))                             
        self.check_server(server)
        
        self.logger.debug("Connection to server established")
        return server
Esempio n. 23
0
 def __init__(self, host, port, type, id = 0):
     super(Ssh, self).__init__()
     
     self.auth = None  # created by PyUML
     self.server = Server(host, port, type, id)
     
     self.client = paramiko.SSHClient()
     self.client.load_system_host_keys()
     self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
     self.isConnected = False
     
     self.monitoring = Monitor(self)
Esempio n. 24
0
    def server(self, dist, target, upgrade_from_path=None, start=False):

        source = dist.path if isinstance(dist, LocalServerDist) else self.cache.get(dist)

        ZipFile(source, 'r').extractall(target)

        # Copy available plugins
        server_dir = os.path.join(target, '.'.join(dist.get_filename().split('.')[:-1]))

        print "Server has been installed to %s" % server_dir

        for root, dirs, files in os.walk(os.path.join(server_dir, 'available-plugins')):
            for file_ in files:
                print "Copying available plugin %s" % file_
                if file_.endswith('.jar'):
                    shutil.copy(os.path.join(root, file_), os.path.join(server_dir, 'plugins', file_))

        proper_license = self.license_location if (dist.version.startswith('4') or dist.version == 'SNAPSHOT') else self.license_location_3x

        print "Copying license from %s" % proper_license
        shutil.copy(proper_license, os.path.join(server_dir, 'conf', 'deployit-license.lic'))

        for dirpath, d, file_names in os.walk(target):
            for filename in file_names:
                if filename.endswith(".sh"):
                    os.chmod(dirpath + '/' + filename, 0750)

        if upgrade_from_path is not None:
            print "Copying files from old installation at %s" % upgrade_from_path
            if os.path.isdir(os.path.join(upgrade_from_path, 'repository')):
                dir_util.copy_tree(os.path.join(upgrade_from_path, 'repository'), os.path.join(server_dir, 'repository'))
            dir_util.copy_tree(os.path.join(upgrade_from_path, 'plugins'), os.path.join(server_dir, 'plugins'))
            dir_util.copy_tree(os.path.join(upgrade_from_path, 'conf'), os.path.join(server_dir, 'conf'))
            dir_util.copy_tree(os.path.join(upgrade_from_path, 'ext'), os.path.join(server_dir, 'ext'))
            self._remove_old_plugins(server_dir)

        if start:
            Server.from_config(config=self.config, home=server_dir).start()

        return server_dir
Esempio n. 25
0
  def __init__(self, parent=None):
    
    #Are we local or remote?
    self.remote = True

    #Instantiate a minecraft server object
    self.s=Server(remote=self.remote)

    #The usual
    QtGui.QWidget.__init__(self, parent)
    self.ui = Ui_MainWindow()
    self.ui.setupUi(self)
    self.initUI()

    #Instance variables
    self.chatLines = []
    self.consoleLines = []
    self.onlineDict = {}
    self.pluginsDict = {} 

       #Set the start/stop button text
    if self.s.status():
      self.ui.pushButtonStopStart.setText('Stop Server')
    else:
      self.ui.pushButtonStopStart.setText('Start Server')

    if self.remote:
      print 'spawning remote thread'
      self.connect(self, QtCore.SIGNAL('newRemoteLines'), self.routeServerLines)
      self.connect(self, QtCore.SIGNAL('pluginsDict'), self.remotePlugins)
      self.thread = GenericThread(self.remoteConn)
      self.thread.start()
      print 'thread started'
    else:
      #Instantiate a qThreadWatcher() to monitor server.log for changes and connect its signal
      #to newLineDetected.
      self.fileWatcher = QtCore.QFileSystemWatcher(self)
      self.fileWatcher.addPath(os.path.join(self.s.bukkitDir, 'server.log'))
      self.connect(self.fileWatcher, QtCore.SIGNAL('fileChanged(QString)'), self.newLineDetected)

      #Find the currently installed plugins by searching the plugin folder
      self.findPlugins()

      #On app boot, read til the last time the server was started
      self.lastServerLine = ' [INFO] Stopping server'
      self.newLineDetected()
     
     #Initialize a QTimer to run and connect it to ticToc
      self.repeatingTimer = QtCore.QTimer()
      self.repeatingTimer.start(1000)      
      self.connect(self.repeatingTimer, QtCore.SIGNAL('timeout()'), self.ticToc)
Esempio n. 26
0
 def __get_buy_loans2(self, url):
     domain = PaipaiDai.get_domain(url)
     content, cache = Server.get(url, cache=False, use_cookie=True)
     if content:
         my_loans, next_page = Analyzer.get_my_loan_list(content)
         self.db.insert_my_loans(my_loans)
         print url
         if next_page:
             if not cache:
                 time.sleep(2)
             next_page = os.path.join(domain, next_page.lstrip('/'))
             self.__get_buy_loans2(next_page)
     else:
         time.sleep(2)
Esempio n. 27
0
class Launcher(object):
    '''
    This class sets up and configures the Server and starts it.
    '''

    def __init__(self, configPath):
        serverConfig = ServerConfig(configPath)

        self.warehouse = Warehouse(serverConfig.getWarehousePath())

        logMngr = ServerLogger()
        logMngr.addFileHandler(serverConfig.getLogDirectory())

        self.server = Server(int(serverConfig.getPortNo()),
                             serverConfig.getURLHandlers())
        

        

    def startServer(self):
        self.server.startServer()

    def stopServer(self):
        self.server.stopServer()
Esempio n. 28
0
    def get_bond_list(url, total_page=1):
        """ 获取债券列表 """
        domain = PaipaiDai.get_domain(url)
        bonds = []
        try:
            data, cache = Server.get(url, cache=False)
            if data:
                data, next_page = Analyzer.get_bond_list(data)
                bonds.extend(data)

                if next_page and total_page > 1:
                    next_page = os.path.join(domain, next_page.lstrip('/'))
                    PaipaiDai.get_best_bond(next_page, total_page-1)
        except Exception, e:
            print e
Esempio n. 29
0
    def get_loan_all_list(url, total_page=1):
        """ 获取散标列表, 返回列表 """
        domain = PaipaiDai.get_domain(url)
        result = []
        data, cache = Server.get(url, cache=False)
        if data:
            data, next_page = Analyzer.get_loan_list(data)
            print url
            result.extend(data)

            if next_page and total_page > 1:
                next_page = os.path.join(domain, next_page.lstrip('/'))
                time.sleep(3)
                result.extend(PaipaiDai.get_loan_list(next_page, total_page-1))
        return result
Esempio n. 30
0
def run_server(host, port):
    selfServer = Server(host, int(port)) 
    input.append(selfServer.serverSocket) 
    selfServer._listen() 
    running = True

    while running is True: 
        inready,outready,exready = select.select(input,[],[]) 

        for s in inready:
            # Accepting newly discovered connections.
            if s == selfServer.serverSocket:
                clientInformation = selfServer._accept()
                client = clientInformation[0]
                input.append(client)
                users.update({client:[None,clientInformation[1], False]})
                pendingClients.append(client)
            # Receiving data from a client, if client is no longer sending data,
            # they are no longer connected (remove them).
            # This will write to all connected clients!
            if s in clientList:
                data = s.recv(SIZE)
                name = users.get(s)[0]
                if data:
                    tempData = data.rstrip("\r\n")
                    splitData = tempData.split(" ", 1)
                    splitData.append("\n") # Placeholder to fix argument issues...
                    if splitData[0] in commandDict.keys():
                        commandDict[splitData[0]](s, splitData[1])
                    else:
                        line = name + ": " + data
                        print line
                        for client in clientList:
                            if client is not s:
                                client.send(line)
                else: 
                    cleanup(s)
                    print ERROR_MSG['leaveMsg'].format(name=name)
                    for client in clientList:
                        if client is not s:
                            client.send(ERROR_MSG['leaveMsg'].format(name=name))
            if s in pendingClients:
                data = s.recv(SIZE)
                if data:
                    tempData = data.rstrip("\r\n")
                    splitData = tempData.split(" ", 1)
                    splitData.append("\n")
                    if splitData[0] == "/name":
                        commandDict[splitData[0]](s, splitData[1])
                        pendingClients.remove(s)
                        clientList.append(s)
                else:
                    pass 
    selfServer._close()
Esempio n. 31
0
        # based on the question, distribute corresponding index to each question
        if questions == 0:
            self.listOfSelection = ['Agency Name']
        elif questions == 1:  # How much funding is available in the target categories? (Total, by category, over time)
            self.listOfSelection = ['Value', 'UNSPSC Title']
        elif questions == 2:  # question 2
            self.listOfSelection = []
        else:
            self.listOfSelection = []

    # Return the list of agency name with target category
    # def category_agency(self, category_name):
    #     listAgency = self.catByAgency.get(category_name)
    #     return listAgency

    # **********************************************************************


if __name__ == '__main__':
    c = Client()
    from Server import Server
    s = Server()
    c.upload_file("/Users/NAN/Desktop/Qt Project/All_data.csv")
    # question 1
    df = s.visual_q2(
        c.cleaned_Dataframe
    )  # total included in rows which records sum value of a category
    df_sum = df[df['Agency Name'] == 'Total']
    df_sum['Value'].plot(kind='barh')
Esempio n. 32
0
arg_parser.add_argument("--host", help="which host should the server listen on", default="0.0.0.0")
arg_parser.add_argument("--port", help="which port should the server bind to", default=8000)
args = arg_parser.parse_args()

sensor_config_file_path = None
data_logger_config_file_path = None

if args.mock:
    sensor_config_file_path = Path.cwd()/"config/mock_sensors.yaml"
    data_logger_config_file_path = Path.cwd()/"config/mock_data_logger.yaml"
else:
    sensor_config_file_path = args.sensors
    data_logger_config_file_path = args.logger

if sensor_config_file_path is None:
    raise Exception("no sensors config file given")

if data_logger_config_file_path is None:
    raise Exception("no data logger config file given")
 
sensors = config.parse_sensor_config(sensor_config_file_path)
sensor_manager = SensorManager(sensors)

(DataLoggerClass, data_logger_arguments) = config.parse_data_logger_config(data_logger_config_file_path)
data_logger = DataLoggerClass(sensor_manager=sensor_manager, **data_logger_arguments)

print("initialized application with sensors:", sensors, "and data logger", data_logger)

server = Server(sensor_manager, data_logger)
asyncio.gather(server.serve(host=args.host, port=args.port), data_logger.log_loop())
asyncio.get_event_loop().run_forever()
Esempio n. 33
0
 def __init__(self, player_names, cards_per_player):
     self.server = Server()
     self.shownClock = [Card('Hidden', 'Hidden') for i in range(12)]
     self.createPlayers(player_names)
     self.setup(cards_per_player)
     self.currentTime = 0
Esempio n. 34
0
        count = 1
        for i, post in enumerate(ans):

            if not self.is_post_ok(post):
                continue

            await self.get_comments(post.id)
            await sleep(0.1)

            print('get comment post', post.id, count, i, '/', len(ans))

            count += 1

        print('end', count - 1, len(ans))

    async def main(self):
        while True:
            await self.get_new_comments()
            await sleep(60*6)


async def on_start(_):
    stat = RedditStat(config.sub)
    stat.auth(config.client_id, config.client_secret)

    loop.add(stat.get_new_posts()).add(stat.main()).start()


if __name__ == '__main__':
    Server().add(on_start).run()
Esempio n. 35
0
def c_main() -> int:
    _server = Server("UDP")
Esempio n. 36
0
# QUERIES
import random
import Conventions
import mysql.connector
from Server import Server

mydb = None
mycursor = None
settings_info = None
DEBUGGING = False
USE_MOCK_DB = False
CHOOSE_RANDOM_SONGS_LIST = False
DEBUGGING_EMPTY_SONGS_LIST = False

sql_server = Server()


def run():
    """
    RUN the SQL:
    connect to server
    If connection failed return error
    """
    status = None
    message = None
    try:
        sql_server.connect()
    except mysql.connector.Error as err:
        print("Something went wrong: {}".format(err))

Esempio n. 37
0
 def _setup_servers(self):
     for svr in range(self.servers_number):
         server = Server(svr, self.service_rate)
         self.servers.append(server)
Esempio n. 38
0
from bitarray import bitarray
import time
import random
import hashlib
from Function import Function
from Server import Server
import AttackUtil as Util

print "-> Fesitel cipher algorithm: Attack <-\n"

socket = Server.initServerSocket(Util.ADDRESS, Util.PORT)

print "Waiting for data ..."

try:
    file = open(Util.encodedAttackFile, "wb")

    clientSocket, address = socket.accept()

    print "Receiving data ..."
    data = Server.readSocket(clientSocket)
    print "Data received."

    file.write(data)
    file.close()

    print "\nStarting the attack operations ..."

    start = time.time()

    bytes = bitarray()
Esempio n. 39
0
        print("Added user: "******"User Salt: " + str(salt))
        print("User Password: "******"User Salted Password: "******"2":
        # Validate user
        username = input("Enter username: "******"Enter password: "******"Success, welcome " + str(username) + "!")
        else:
            print("Invalid credentials")

    if menu_choice is "3":
        keep_going = False


if __name__ == '__main__':

    server = Server()
    menu()
Esempio n. 40
0
 def startServer(self):
   """Start the game server."""
   if not self.server:
     Log.debug("Starting server.")
     self.server = Server(self)
     self.addTask(self.server, synchronized = False)
Esempio n. 41
0
from Server import Server
import sys

s = Server(int(sys.argv[1]))

input()

s.close()
Esempio n. 42
0
 def init_data(
     self
 ):  # Check for data presence on server, otherwise push current user data to server
     if Server.pull_user_data(self.MAC) == False:
         Server.push_user_data(self.MAC, self.Psw)
Esempio n. 43
0
import os
import sys
from Server import Server, client_connection

ip = raw_input("Ip of connecting Node: ")
ip = str(ip)
port = raw_input("Type port to use: ")
port = int(port)
mBit = raw_input("Power of size in your ring: ")
mBit = int(mBit)
total_node = 2**mBit
threads = []
finger = [-1 for i in range(mBit)]
predecessor = None

active_server = Server(ip, port, total_node, predecessor, mBit, finger)
active_server.start()
threads.append(active_server)

while True:
    x = raw_input("chord>> ")
    if x == "":
        continue
    x = x.strip()
    x = x.split()
    if x[0] == "print":
        print ip, port, active_server.predecessor
        print active_server.finger_table
    elif x[0] == "create_ring":
        active_server.create_ring()
        print "Ring created with only node in it", active_server.position
Esempio n. 44
0
    # TODO - Change your name
    print("Server Automator v0.1 by Vlado Situm")


# This is the entry point to our program
if __name__ == '__main__':
    print_program_info()
    # TODO - Create a Server object
    # TODO - Call Ping method and print the results

    my_server_ip = "52.14.212.224"
    my_rsa_key_file = "C:\\Users\\VladoPC\\.ssh\\id_rsa"
    username = "******"

    my_upgrade_command = 'sudo apt update && sudo apt upgrade -y'
    my_server = Server(my_server_ip, my_rsa_key_file, username,
                       my_upgrade_command)

    print('Pinging server %s...' % my_server_ip)
    ping_result = my_server.ping()
    print(ping_result)
    if ping_result == 0:
        print("Pinging IP [%s] successful." % my_server_ip)
    else:
        print("Pinging IP [%s] Failed." % my_server_ip)

    print("\nUpdating server using ssh client from paramiko...")
    ssh_result = my_server.upgrade()
    print(''.join(ssh_result))

    print('Done.')
Esempio n. 45
0
# This is the template code for the CNA337 Final Project
# TJ Dewey [email protected]
# CNA 337 Fall 2020
# Base code template furnished by Zachary Rubin, [email protected]
# Stackoverflow.com and docs.python.org for pinging using os module
# Stackoverflow.com for Running Powershell functions in python with subprocess (not used)
# docs.microsoft.com for powershell excecution policy (not used)
# Paramiko examples at programcreek.com
# help with Paramiko @ youtube: "Automating SSH using python | by using Paramiko module" by Exploit Blizzard
# Paramiko documents: "Using Paramiko to control an EC2 instance" @ Mainly Data
# With tutoring from Zak Rubin

from Server import Server

def print_program_info():
    print("Server Automator v0.17 by T.J. Dewey")

# This is the entry point to our program
if __name__ == '__main__':
    print_program_info()
    myEC2 = Server("3.15.229.69") #EC2 address
    status = myEC2.ping()
    print(status)    
    myEC2.connect()
Esempio n. 46
0
from Config import Config
from Server import Server

# Parse arguments
for i in range(1, len(sys.argv)):
    # Config arguments should be in format of Config=Value
    # For setting booleans to False use Config=
    x, y = sys.argv[i].split('=')
    # setattr(Config, x, type(getattr(Config, x))(y))
    setattr(Config, x, ast.literal_eval(y))

# Adjust configs for Play mode
if Config.PLAY_MODE:
    Config.AGENTS = 1
    Config.PREDICTORS = 1
    Config.TRAINERS = 1
    Config.DYNAMIC_SETTINGS = False

    Config.LOAD_CHECKPOINT = True
    Config.TRAIN_MODELS = False
    Config.SAVE_MODELS = False

gym.undo_logger_setup()
attrs = vars(Config)
for key, value in attrs.items():
    print(key, value)

# Start main program
Server().main()
Esempio n. 47
0
#!/usr/bin/env python
'''
    Gateway main
'''
import sys
from Server import Server
from RobotManager import RobotManager
from Config import HOST, PORT
from sys import exit

sys.path.append("..")
import pypibot
from pypibot import log

log.setLevel("i")

assert __name__ == '__main__', 'Please run in main.'

server = Server(HOST, PORT)
server.setDaemon(True)
server.start()

if not RobotManager().init():
    log.error('Fail to initilize robot manager.')
    exit(1)

RobotManager().spin()
# This code is to ping my Raspberry Pi

from Server import Server


def print_program_info():
    # TODO - Change your name
    print("Server Automator v0.1 by Luma")


# This is the entry point to our program
if __name__ == '__main__':
    print_program_info()
    Pi = Server('10.0.0.12')
    # Call Ping method and print the results
    print(Pi.ping())
Esempio n. 49
0
 def __init__(self):
     super(ResponseHandler, self).__init__()
     self.monitors = []
     self.server = Server()
     self.isRunning = True
Esempio n. 50
0

def graceful_shutdown(sig, dummy):
    """ This function shuts down the server. It's triggered
    by SIGINT signal """
    s.shutdown()  #shut down the server
    import sys
    sys.exit(1)


###########################################################
# shut down on ctrl+c
signal.signal(signal.SIGINT, graceful_shutdown)

print("Starting web server")
# Usage: python3 test.py -host host -p port
parser = argparse.ArgumentParser()
parser.add_argument("-v", help="Verbose?", action='store_true')
parser.add_argument("-p", help="Server Port", type=int, default=9000)
parser.add_argument("-d", help="Working Directory", type=str, default='.')
args = parser.parse_args()

# make sure specified working directory exists and not moving up directories
if re.compile(r'\.\.').findall(args.d):
    print("Working directory should never go up..")
elif not os.path.exists(args.d):
    print("working directory sub-directory does not exist.")
else:
    s = Server(args.v, args.p, args.d)  # construct server object
    s.activate_server()  # aquire the socket
Esempio n. 51
0
from Turn import TurnAndTurn
from Player import Player
from Client import ClientGUI, link
import select
import socket
import time

# Booléen

gameBool = True

# Acceptation des clients.
# Si un Serveur est déjà en ligne, lance un client.

try:
    server = Server()
    server.onLine()
    # Selection de la map.

    map = MapSelect()
    map.mapListPrinter()
    mapUsed = map.mapListSelecter()
    mapData = ("map", map._mapChoiced)
    data = pickle.dumps(mapData)
    print(map._mapChoiced)

    print(
        f"Vous avez choisie la carte: {map._mapTitleProper[mapUsed[2]]}\n\n{map._mapChoiced}"
    )

    print("Serveur en attente d'acceptation.")
Esempio n. 52
0
from Server import Server
import socket
import sys
try:
    server_port = int(sys.argv[1])
except:
    print('Error')

rtsp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
rtsp_socket.bind(('', server_port))
rtsp_socket.listen(5)

while True:
    _socket = rtsp_socket.accept()
    server = Server(_socket)
    server.work()

Esempio n. 53
0
from Server import Server
from Role import Role

Roles = {}  # empty dictionary
Servers = {}  # empty dictionary

a = Role("db", [], [])

Roles["db"] = Role("db", ["install mysql", "install mysql_client"],
                   ["configure iptable"])
Roles["web"] = Role("web", ["install apache", "install php"],
                    ["configure iptable", "configure iptables"])

Servers["Server1"] = Server("Server1", "db")
Servers["server2"] = Server("Server2", "web")
Servers["server3"] = Server("Server3", "web")


def buildServers(pServers, pRoles):
    for k, v in pServers.items():
        role = pRoles[v.get_role()]
        print(v.get_name())
        for c in role.get_commands():
            print(c)
        for ip in role.get_iptables():
            print(ip)


buildServers(Servers, Roles)
Esempio n. 54
0
from Server import Server
import time


start = time.time()
print("Algorithm started.")


m = 10
lamb = random.randint(50, 150)

datacenter = Datacenter(lamb)

# make some servers
for i in range(0, m):
    server = Server()
    # server.set_active(random.randint(0, 1))
    server.set_active(1)
    datacenter.add_server(server)

# turn on some of the servers
for server in datacenter.servers:
    if server.active:
        server.set_lambda(datacenter.lamb / len(datacenter.active_servers()))

jcl = Jcl(datacenter)

jcl.optimize()


end = time.time()
Esempio n. 55
0
class MainWindow(QMainWindow):
    def __init__(self):
        super(QMainWindow, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.ui.retranslateUi(self)

        self.ui.tabClients.setTabsClosable(True)
        self.ui.tabClients.tabCloseRequested.connect(self.tab_close_requested)

        self.scanDevice = ScanDevice()
        self.scanDevice.new_device.connect(self.ui.lwdScanResult.addItem)
        self.ui.cmbServiceIp.addItems(self.scanDevice.get_host_ip())
        self.ui.cmbServiceIp.currentIndexChanged.connect(
            self.scanDevice.set_current_index)

        self.server = Server(self.ui.cmbServiceIp.currentText(),
                             int(self.ui.leServerPort.text()), self)
        self.server.new_client.connect(self.new_client)
        self.ui.btnRestartServer.clicked.connect(self.restart_server)

        self.ui.btnScanDevice.clicked.connect(self.scan_device)
        self.ui.lwdScanResult.itemDoubleClicked.connect(
            self.lwd_scan_result_double_clicked)

        self.__double_tag = None

        self.titleToClient = {}

    def new_client(self, client):
        tag = self.__double_tag
        if tag:
            index = self.find_tab(tag)
            if index == -1:
                message_ctrl = MessageCtrl(client, self)
                self.ui.tabClients.addTab(message_ctrl, self.__double_tag)
            else:
                message_ctrl = self.ui.tabClients.widget(index)
                message_ctrl.set_new_client(client)
            self.__double_tag = None

    def restart_server(self):
        self.clear_result()
        self.server.restart_server(self.ui.cmbServiceIp.currentText(),
                                   int(self.ui.leServerPort.text()))

    # 找到指定title,return index,否则return -1
    def find_tab(self, title):
        for index in range(self.ui.tabClients.count()):
            if self.ui.tabClients.tabText(index) == title:
                return index
        return -1

    def scan_device(self):
        self.ui.lwdScanResult.clear()
        self.scanDevice.search()

    def lwd_scan_result_double_clicked(self, item):
        tag = item.text()
        self.__double_tag = tag
        if self.find_tab(tag) == -1:
            self.scanDevice.connect_device(tag.split(":")[1])

    def close_tab(self, index):
        tag = self.ui.tabClients.tabText(index)
        self.scanDevice.disconnect_device(tag.split(":")[1])
        self.ui.tabClients.removeTab(index)

    def tab_close_requested(self, index):
        self.close_tab(index)

    def clear_result(self):
        self.ui.lwdScanResult.clear()
        count = self.ui.tabClients.count()
        for index in range(count):
            self.close_tab(0)
Esempio n. 56
0
 def __init__(self):
     self.server = Server()
Esempio n. 57
0
load_dotenv()
TOKEN = os.getenv("TOKEN")

bot = commands.Bot(
    command_prefix=".",
    description="Sniff Bot is the bot for the Why Cello There server.", intents=discord.Intents.all())


@bot.event
async def on_ready():
	print("Bot is ready!")

@bot.event
async def on_member_join(member):
  channel = discord.utils.get(member.guild.channels, id = 795609115492876298)
  await channel.send(f"Welcome to Why Cello There, <@{member.id}>! Make sure to join all of the servers in the partnered channels. You can also ~~join in on the pyramid scheme and~~ write `$join @username` of the person who invited you. Have fun!")

@bot.event 
async def on_member_remove(member): 
  channel = discord.utils.get(member.guild.channels, id = 795609115492876298)
  await channel.send(f"<@{member.id}> just left! Let us all wish them an absolutely terrible day.")

keep_alive()

bot.add_cog(Fun(bot))
bot.add_cog(Meta(bot))
bot.add_cog(Server(bot))

bot.run(TOKEN)
Esempio n. 58
0
__author__ = 'Chema'
from Server.Server import *
from Client.Client import *

x = Server('',2525)
x.create()
x.listen()





Esempio n. 59
0
File: Save.py Progetto: vhenaoi/HVA
from Marks import Marks
from Server import Server
import numpy as np
import csv
from datetime import datetime

sample_mark, timestamp = Marks.Marks()
mysample = Server.lslStreamers()


def Save(mysample, sample_mark, timestamp):
    with open("data.csv", "a") as csvfile:
        writer = csv.writer(csvfile, delimiter=',')
    if sample_mark is not None:
        data2write = np.append(sample_mark, datetime.fromtimestamp(timestamp))
        writer.writerows([np.array(data2write)])
    else:
        data2write = np.array(
            mysample.channels_data) * (4500000) / 24 / (2**23 - 1)
        data2write = np.append(data2write)
        writer.writerows([np.array(data2write)])


if __name__ == '__main__':
    Save = Save()
Esempio n. 60
0
import argparse
from Client import Client
from Server import Server

if __name__ == "__main__":
    argParser = argparse.ArgumentParser(
        description="Program to send and receive data using the Arduino Due.")
    argParser.add_argument("type",
                           help="Type of connection [client, server].",
                           type=str)
    argParser.add_argument("-d",
                           "--debug",
                           help="Debug mode.",
                           action="store_true")
    args = argParser.parse_args()

    # Serial Com Port
    # para saber a sua porta, execute no terminal:
    # python -m serial.tools.list_ports

    serialName = "/dev/ttyACM0"  # Ubuntu (variacao de)
    #serialName = "/dev/tty.usbmodem1411"  # Mac    (variacao de)
    #serialName = "COM11"                  # Windows(variacao de)

    if args.type == "client":
        client = Client("/dev/ttyACM1", args.debug)
    elif args.type == "server":
        server = Server("/dev/ttyACM0", args.debug)
    else:
        print("[ERROR] Invalid connection type.")