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()
