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
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
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...")
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")
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'
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 }
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
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
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')
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()
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
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
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 __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)
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)
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
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)
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
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
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
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)
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
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)
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)
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()
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
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
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()
# 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')
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()
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
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()
def c_main() -> int: _server = Server("UDP")
# 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))
def _setup_servers(self): for svr in range(self.servers_number): server = Server(svr, self.service_rate) self.servers.append(server)
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()
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()
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)
from Server import Server import sys s = Server(int(sys.argv[1])) input() s.close()
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)
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
# 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.')
# 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()
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()
#!/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())
def __init__(self): super(ResponseHandler, self).__init__() self.monitors = [] self.server = Server() self.isRunning = True
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
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.")
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()
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)
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()
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)
def __init__(self): self.server = Server()
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)
__author__ = 'Chema' from Server.Server import * from Client.Client import * x = Server('',2525) x.create() x.listen()
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()
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.")