def remove_server(self, server): """ Remove a server from the servers database """ if not self._db.remove(Server(server)): print '[!] Unknown server' return
def get_first_turned_server(self): """ Return server to be turned on first """ served_server = Server(-1, True, False) served_server.turn_on_time = float('inf') for server in self.servers: if server.to_be_turned_on and server.turn_on_time < served_server.turn_on_time: served_server = server return served_server
def get_first_served_server(self): """ Return server to be served first """ served_server = Server(-1, True, False) served_server.departure_time = float('inf') for server in self.servers: if server.is_busy and server.is_deployed and server.departure_time < served_server.departure_time: served_server = server return served_server
def __init__(self, configPath): self.config = config.load(configPath) if self.config.operators: self.operators = Operator(self.config.operators) if self.config.store: self.store = store.get_store(self.config.store) if self.config.queue: # print("---> 1", self.config.queue) self.queue = Queue.make(self.config.queue) if self.config.server: self.server = Server(self.config.server)
def process(self, server): """ Process task with a given Vodstok server """ try: #print self.alias server, alias = self.alias.split('?') self.chunk = Server(server).download(alias) return (self.chunk is not None) except ServerIOError: self.chunk = None return False
def on_download_file_completed(self, task): """ Called when the target file is fully downloaded. This method retrieve the stored data and loop while all the metadata have not been retrieved. That means that a file's matadata can be stored in many chunks, the same way files are stored in vodstok. """ if self.__state == DownTask.SUMMARY: file_content = self.__file.read() # Is it an old version of chunk ? if (file_content.count('|') == 1): filename, self.__chunks = file_content.split('|') elif (file_content.count('|') == 2): filename, version, self.__chunks = self.__file.read().split( '|') # Check version # If version is greater than our version, raise an error. if VersionStr(version) > Settings.version: raise VersionError() if filename == 'metadata': self.__file = MemoryStream('', key=self.__key) self.__task = DownloadFileTask(self, self.__chunks.split(','), self.__file) else: self.__state = DownTask.RECVING self.filename = clean_filename( os.path.join(self.__dst_prefix, filename)) self.__file = FileStream(open(self.filename, 'wb'), key=self.__key) self.__task = DownloadFileTask(self, self.__chunks.split(','), self.__file) if self.__manager is not None: self.__manager.queue_task(self.__task) elif self.__state == DownTask.RECVING: self.__state = DownTask.DONE self.__file.close() if self.__manager is not None: # notify manager of new servers for chunk in self.__chunks.split(','): server, alias = chunk.split('?') self.__manager.on_server_discovered(Server(server)) self.__manager.on_task_done(self)
def __init__(self, mode, lambd, mu, theta, servers_count, core_servers_count, L, H, simulation_time, max_queue_size, is_debug): self.lambd = lambd self.mu = mu self.theta = theta self.servers_count = int(servers_count) self.core_servers_count = int(core_servers_count) self.L = int(L) self.H = int(H) self.simulation_time = simulation_time self.is_debug = is_debug self.auto_continue = not self.is_debug self.mode = mode self.flow = Flow(lambd, mu, is_debug) self.queue = Queue(int(max_queue_size), is_debug) self.generated_request = Request(-1, 0, 0, 0) self.system_state = States.IDLE self.prev_system_state = States.IDLE self.served_count = 0 self.served_sum_w = 0 self.served_sum_wq = 0 self.servers = [] self.generated_requests = [] self.time = 0 self.prev_time = 0 self.up_down_time = 0 self.prev_up_down_time = 0 self.up_down_count = 0 self.up_down_mean = 0 self.state_time = dict.fromkeys(States.get_States_list(States), 0) self.state_count = dict.fromkeys(States.get_States_list(States), 0) for i in range(int(servers_count)): self.servers.append( Server(i, True if i < int(core_servers_count) else False, is_debug))
def run(self): self.logger.info('Main APP start: [PID %s]' % self.main_process) self.server = Server(bind_obj=ServerWorker(self)) self.logger.info('Server start') self.server.start() self.parser_params() agents = self.values() # start all agent self.logger.info('Worker Agent start') _ = [agent.start() for agent in agents] self.logger.info('Agent Monitor start') monitor = AgentMonitor(self) joinall(agents) for agent in agents: agent.get_end_signal() monitor.is_end = True self.logger.info('all workers were completed') self.logger.info('Main APP stop: [PID %s]' % self.main_process)
def add_server(self, server): """ Add a server to the servers database """ _server = Server(server) try: _version = _server.get_version() print '[i] Remote server version is %s' % _version _capacity = _server.get_capacity() print '[i] Remote server shares %s' % convert_bytes( _server.capacity) if _server.check(): _server.set_version(_version) _server.set_active(True) self._db.add(_server) return True else: return False except ServerIOError: return False
def test_failed_greedy_resource_allocation(): # Exception: Resource allocation for a task is infeasible, model solution is Infeasible. # The task setting is {'name': 'Foreknowledge Task 10', # 'storage': 30, 'computation': 20, 'results data': 9, 'deadline': 17.0, 'value': 17.62} # and the server setting has available bandwidth of 34 and available computation of 16 (storage: 40) task = ElasticTask('test task', required_storage=30, required_computation=20, required_results_data=9, deadline=17, value=17.62) server = Server('test server', storage_capacity=50, computation_capacity=50, bandwidth_capacity=50) server.available_storage = 40 server.available_computation = 16 server.available_bandwidth = 34 print(server.can_run(task)) resource_allocation = SumPercentage() _, _, _ = resource_allocation.allocate(task, server)
import webbrowser from core.server import Server HOST = "localhost" PORT = 8081 server = Server(HOST, PORT) webbrowser.open("http://{}:{}".format(HOST, PORT)) server.start()
from core.server import Server if __name__ == "__main__": s = Server() s.play_a_game()
help="run as server") parser.add_argument("-u", "--udp", action="store_true", help="use UDP socket (default is TCP)") parser.add_argument("-v", "--verbose", action="store_true", help="set verbosity mode") args = parser.parse_args() if args.udp: protocol = 'udp' else: protocol = 'tcp' if args.server: server = Server(hostname=args.hostname, protocol=protocol, port=args.port, max_conn=args.maxconn) server.start() else: screen = curses.initscr() client = Client(args.hostname, protocol, args.port) client.connect()
def __init__(self, url, password): self.url = url self.password = password self.server = Server(url, password)
import os import signal from core.server import Server import sqlite3 import settings def setup_db(): if not os.path.isfile(settings.db_name): conn = sqlite3.connect(settings.db_name) with open('createdb.sql', 'r') as f: conn.executescript(f.read()) conn.commit() conn.close() if __name__ == "__main__": try: port = int(sys.argv[1]) assert port >= 1 and port <= 65536, 'port number can only between 1 and 65536' except (ValueError, IndexError): print('Usage: {} [Port]'.format(sys.argv[0]), file=sys.stderr) exit(1) setup_db() server = Server('localhost', port) signal.signal(signal.SIGINT, lambda signal, frame: server.stop()) signal.signal(signal.SIGTERM, lambda signal, frame: server.stop()) server.run()
print("ERROR: Missing path to config file.") sys.exit(1) config = ProjectConfig(args.config) config.parse() print("=" * 33 + " CONFIGURATION " + "=" * 32) print("REPOSITORY: " + config.get_repository()) print("BRANCH: " + config.get_repository_branch()) print("PROJECT ROOT: " + config.get_project_root_path()) print("WWW DIRECTORY: " + config.get_project_www_path()) print("COMPOSE PATH: " + config.get_project_compose_path()) project = Project(config) server = Server(config) print() print("=" * 31 + " STOPPING PROJECT " + "=" * 31) server.stop() print() print("=" * 31 + " CREATING PROJECT " + "=" * 31) project.create_project() print() print("=" * 31 + " CLONING PROJECT " + "=" * 32) project.clone_repository() print() print("=" * 30 + " CREATING .ENV FILE " + "=" * 30)
\__\___| .__/ |_| \__, |\_____|_| |_|\__,_|\__| | |______ __/ | |_|______| |___/ %s%s %s''' % (red, green, config['version'], end)) parser = argparse.ArgumentParser() parser.add_argument('-ip', '--ip_address', help='IP address to set the connection', dest='ip') parser.add_argument('-p', '--port', help='Port to set the connection', dest='port') args = parser.parse_args() ip_address = args.ip port = args.port if ip_address and port: try: server = Server(str(ip_address), int(port)) server.server_connection() except Exception as identifier: print(''' %s %s''' % (error, identifier)) else: print(''' %s Error: Set ip address server and a port ''' % (error))
from sys import argv from core.server import Server if __name__ == '__main__': serv = Server(argv[1]) if len(argv) > 1 else Server() serv.run()
def test_server(self, url): """ Test a remote server to check if it is a valid vodstok storage server """ return Server(url).check()
import sys from core.server import Server from core.channel import Channel server = Server() channel = Channel(server) if sys.argv[1] == "server": server.start_server() elif sys.argv[1] == "channel": channel.setup_channel()
def __init__(self, parent=None, id=-1, title='PypMsg: Main Window', show=False): self.clients = [] #self.server = Server(self.reloadMessages) self.server = Server() self.scanner = Scanner(Scanner.SERVER) self.scanner.listen() self.atchQueue = Queue.Queue() wx.Frame.__init__(self, parent, id, title, size=(600, 400)) wx.EVT_CLOSE(self, self.OnClose) #panel = wx.Panel(self, -1) splitter = wx.SplitterWindow(self) leftPanel = wx.Panel(splitter) rightPanel = wx.Panel(splitter) self.msgList = lists.PListCtrl(leftPanel) self.msgList.InsertColumn(0, 'User Name', width=100) self.msgList.InsertColumn(2, 'Message') self.msgList.InsertColumn(1, 'Address', width=80) self.msgList.Bind(wx.EVT_LIST_ITEM_SELECTED, self.showFileList) self.msgList.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.showMessage) #ipAddrCtrl = wx.StaticText(leftPanel, label='My IP Address: ') msgVbox = wx.BoxSizer(wx.VERTICAL) #msgVbox.Add(ipAddrCtrl, 0, wx.EXPAND) msgVbox.Add(self.msgList, 1, wx.EXPAND | wx.TOP, 10) self.filList = wx.ListCtrl(rightPanel, style=wx.LC_LIST) self.filList.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.downloadAttachment) msgBtn = wx.Button(rightPanel, label='&New Message') msgBtn.Bind(wx.EVT_BUTTON, self.newMessageWin) relBtn = wx.Button(rightPanel, label="&Refresh") relBtn.Bind(wx.EVT_BUTTON, self.reloadMessages) clrBtn = wx.Button(rightPanel, label="&Clear") clrBtn.Bind(wx.EVT_BUTTON, self.clearMessages) btnVbox = wx.BoxSizer(wx.VERTICAL) btnVbox.Add( wx.StaticText(rightPanel, label='Attachments:\n(Double-Click to download)'), 0, wx.TOP) btnVbox.Add(self.filList, 1, wx.EXPAND) btnVbox.Add(msgBtn, 0, wx.EXPAND | wx.TOP, 10) btnVbox.Add(relBtn, 0, wx.EXPAND | wx.TOP, 10) btnVbox.Add(clrBtn, 0, wx.EXPAND | wx.TOP, 10) leftPanel.SetSizer(msgVbox) rightPanel.SetSizer(btnVbox) splitter.SplitVertically(leftPanel, rightPanel, -150) if not self.server.startServing(): wx.MessageDialog( None, 'An Instance of PypMsg is already running. Please close that before opening a new one. \ The current version of PypMsg does not support multiple-instances. Thank you.', 'Already Running', wx.OK | wx.ICON_ERROR | wx.CENTRE).ShowModal() raise SystemExit(1) self.reloadMessages() if show: self.Show()