def __init__(self): self._config = None # Load config self.load_config() # store master ip self._docean = DOcean(self._config['api-key']) # google drive if self._config['google-drive']: self._google_drive_session = 'google-session.json' self._google_drive = GoogleDriveAPIWrapper('',self._google_drive_session)
def __init__(self): self._config = None # Load config self.load_config() # Create DOcean API Wrapper self._docean = DOcean(self._config['api-key']) # Use GoogleDrive Upload API self._google_drive_uploader = None self._google_drive_session = 'google-session.json' # Check if we are using it if so run setup session if self._config['google-drive']: self._setup_session()
def __init__(self): self._config = None self._slaves = None self._slaves_used = None self._slaves_id = None # Load config self.load_config() # Create DOcean API Wrapper self._docean = DOcean(self._config['api-key']) # Check if Google Drive will be used # If so once all the children are initialized we kill the master if self._config['google-drive']: self._master_droplet_id = self._config['master-droplet-id']
class ElasticPowerTAC: # constructor def __init__(self): self._config = None # Load config self.load_config() # Create DOcean API Wrapper self._docean = DOcean(self._config['api-key']) # Use GoogleDrive Upload API self._google_drive_uploader = None self._google_drive_session = 'google-session.json' # Check if we are using it if so run setup session if self._config['google-drive']: self._setup_session() # load_config def load_config(self): # load from "config.json" try: config_file = "config.json" self._config = None with open(config_file,'r') as f: self._config = f.read() self._config = json.loads(self._config) except: print('config.json must be defined.') exit() # Google Drive API Session Setup def _setup_session(self): self._google_drive_uploader = GoogleDriveUpload(self._config['google-drive']['secret'], self._google_drive_session) # Wait creation process def wait_until_completed(self,droplet_id): # poll until last action is completed. while True: actions = self._docean.request_droplet_actions(droplet_id) # Check all actions are complete actions_all_completed = True for action in actions['actions']: if action['status'] != 'completed': actions_all_completed = False if not actions_all_completed: # If not finished sleep for 1 minute time.sleep(60) else: break # setup master droplet def setup_master_droplet(self): # Create master with specified image id status,new_droplet = self._docean.request_create( self._config['master-name'], self._config['master-image']['region'], self._config['master-image']['size'], self._config['master-image']['id'], self._config['master-image']['ssh_keys']) # Check status if status != 202: print('Unable to create master droplet') exit() droplet_info = new_droplet['droplet'] # wait for creation action to finish print('Initilized creation process of master') # Poll actions every minute until finished droplet_id = droplet_info['id'] self.wait_until_completed(droplet_id) # Completed print('Finished creating Master Droplet(%d)'%droplet_id) self._master_droplet = droplet_id # setup master environment def setup_master_environment(self): # Retrieve IP Address of Master Droplet response = self._docean.request_droplets() for droplet in response['droplets']: if droplet['id'] == self._master_droplet: self._master_ip = droplet['networks']['v4'][0]['ip_address'] break # Setup master_config dict master_config = {} master_config['local-ip'] = self._master_ip master_config['slave-name'] = "PTSlave-under-%s"%self._master_droplet master_config['slave-image'] = self._config['slave-image'] master_config['api-key'] = self._config['api-key'] master_config['slaves-used'] = self._config['slaves-used'] master_config['simulations'] = self._config['simulations'] if self._config['google-drive']: master_config['google-drive'] = self._config['google-drive'] master_config['master-droplet-id'] = self._master_droplet else: master_config['google-drive'] = False master_config_file = 'master.config.json' # Create necessary config.json file for master with open(master_config_file,'w+') as f: f.write(json.dumps(master_config)) # Attempt to ssh over completed = False while not completed: try: # Clone ElasticPowerTAC-Master cmd_clone = ['ssh','-o StrictHostKeyChecking=no',('root@%s'%self._master_ip), 'git clone --recursive https://github.com/frankyn/ElasticPowerTAC-Master.git'] handle = subprocess.call(cmd_clone) if handle != 0: raise "command error" # SCP master.config.json to master server cmd_mcj = ['scp',master_config_file, 'root@%s:%s'%(self._master_ip,'~/ElasticPowerTAC-Master/config.json')] handle = subprocess.call(cmd_mcj) if handle != 0: raise "command error" # Upload Google Drive Dependencies if self._config['google-drive']: # SCP session.json to master server cmd_cpgd = ['scp',self._google_drive_session, 'root@%s:%s'%(self._master_ip,'~/ElasticPowerTAC-Master/%s'%self._google_drive_session)] handle = subprocess.call(cmd_cpgd) if handle != 0: raise "command error" # Create Scenarios location cmd_mkdir = ['ssh', 'root@%s'%(self._master_ip), 'mkdir ~/ElasticPowerTAC-Master/scenarios'] handle = subprocess.call(cmd_mkdir) # Upload Scenarios for scenario_file in self._config['scenario-files']: cmd_cpsc = ['scp',scenario_file, 'root@%s:%s'%(self._master_ip,'~/ElasticPowerTAC-Master/%s'%scenario_file)] handle = subprocess.call(cmd_cpsc) # Run ElasticPowerTAC-Master cmd_run = ['ssh','root@%s'%self._master_ip, 'cd ~/ElasticPowerTAC-Master/;python master.py < /dev/null > /tmp/master-log 2>&1 &'] handle = subprocess.call(cmd_run) if handle != 0: raise "command error" # We are finished completed = True except: print('Unable to SSH in.. wait another minutes') time.sleep(60) print("Master has been initialized")
class ElasticPowerTACMaster: # constructor def __init__(self): self._config = None self._slaves = None self._slaves_used = None self._slaves_id = None # Load config self.load_config() # Create DOcean API Wrapper self._docean = DOcean(self._config['api-key']) # Check if Google Drive will be used # If so once all the children are initialized we kill the master if self._config['google-drive']: self._master_droplet_id = self._config['master-droplet-id'] # load_config def load_config(self): # load from "config.json" try: config_file = "config.json" self._config = None with open(config_file, 'r') as fd: self._config = fd.read() self._config = json.loads(self._config) except: print('config.json must be defined.') exit() # Wait creation process def wait_until_completed(self, droplet_id): # poll until last action is completed. actions_all_completed = False while not actions_all_completed: actions = self._docean.request_droplet_actions(droplet_id) # Check all actions are complete actions_all_completed = True for action in actions['actions']: if action['status'] != 'completed': actions_all_completed = False if not actions_all_completed: # If not finished sleep for 1 minute time.sleep(60) else: # Attempt an ssh ssh_all_completed = False while not ssh_all_completed: try: response = self._docean.request_droplets() for droplet in response['droplets']: if droplet['id'] in self._slaves_id: cmd_ls = ['ssh', '-o StrictHostKeyChecking=no', 'root@%s' % droplet['networks']['v4'][0]['ip_address'], 'ls'] handle = subprocess.call(cmd_ls) if handle != 0: raise "command error" # All passed ssh_all_completed = True except: time.sleep(30) ssh_all_completed = False # setup slave droplets def setup_slave_droplets(self): # slaves used? self._slaves_used = self._config['slaves-used'] # slave_id container self._slaves_id = [] for x in range(self._slaves_used): # Create master with specified image id status, new_droplet = self._docean.request_create( self._config['slave-name'], self._config['slave-image']['region'], self._config['slave-image']['size'], self._config['slave-image']['id'], self._config['slave-image']['ssh_keys']) # Check status if status != 202: print('Unable to create slave droplet') exit() self._slaves_id.append(new_droplet['droplet']['id']) # wait for creation action to finish print('Initilized creation process of slaves') # Poll actions every minute until all have finished for droplet_id in self._slaves_id: self.wait_until_completed(droplet_id) # Completed print('Finished creating Slave Droplets') # setup slave environment def setup_slave_environment(self): # Retrieve IP Address of Master Droplet response = self._docean.request_droplets() self._slaves = [] for droplet in response['droplets']: if droplet['id'] in self._slaves_id: self._slaves.append({"id": droplet['id'], "ip": droplet['networks']['v4'][0]['ip_address']}) simulation_partition_size = len(self._config['simulations']) // self._slaves_used for x in range(len(self._slaves)): slave_ip = self._slaves[x]['ip'] # Setup slave_config dict simulation_config = {} simulation_config['master-ip'] = self._config['local-ip'] # Partition simulations per slave part_start = simulation_partition_size * x part_end = simulation_partition_size * x + simulation_partition_size simulation_config['simulations'] = self._config['simulations'][part_start:part_end] if self._config['google-drive']: simulation_config['google-drive'] = True else: simulation_config['google-drive'] = False simulation_config_file = 'simulation.config.json' # Create necessary config.json file for simulation with open(simulation_config_file, 'w+') as f: f.write(json.dumps(simulation_config)) # Create necessary config.json file for slave slave_config = {} slave_config['droplet_id'] = self._slaves[x]['id'] slave_config['api-key'] = self._config['api-key'] slave_config['google-drive'] = self._config['google-drive'] slave_config['simulations'] = simulation_config['simulations'] slave_config_file = 'slave.config.json' with open(slave_config_file, 'w+') as f: f.write(json.dumps(slave_config)) # Clone ElasticPowerTAC-Simulation cmd_clone = ['ssh', '-o StrictHostKeyChecking=no', 'log@%s' % slave_ip, 'git clone --recursive https://github.com/frankyn/ElasticPowerTAC-Simulation.git'] subprocess.call(cmd_clone) # SCP master.config.json to Slave server cmd_mcj = ['scp', simulation_config_file, 'log@%s:%s' % (slave_ip, '~/ElasticPowerTAC-Simulation/config.json')] subprocess.call(cmd_mcj) # Clone ElasticPowerTAC-Slave cmd_clone = ['ssh', '-o StrictHostKeyChecking=no', 'root@%s' % slave_ip, 'git clone --recursive https://github.com/frankyn/ElasticPowerTAC-Slave.git'] subprocess.call(cmd_clone) # SCP master.config.json to Slave server cmd_mcj = ['scp', slave_config_file, 'root@%s:%s' % (slave_ip, '~/ElasticPowerTAC-Slave/config.json')] subprocess.call(cmd_mcj) # Create scenarios path on log@slave cmd_mkdir = ['ssh','log@%s'%slave_ip, 'mkdir ~/ElasticPowerTAC-Simulation/scenarios'] subprocess.call(cmd_mkdir) # Create scenarios path on slave cmd_mkdir = ['ssh','root@%s'%slave_ip, 'mkdir ~/ElasticPowerTAC-Slave/scenarios'] subprocess.call(cmd_mkdir) # Copy Simulation Files for simulation in simulation_config['simulations']: cmd_cpsim_files = ['scp','scenarios/%s'%simulation['simulation-file-name'], 'root@%s:~/ElasticPowerTAC-Slave/scenarios/%s'%(slave_ip,simulation['simulation-file-name'])] subprocess.call(cmd_cpsim_files) # SCP google-session.json if self._config['google-drive']: cmd_gd = ['scp', 'google-session.json', 'root@%s:%s' % (slave_ip, '~/ElasticPowerTAC-Slave/google-session.json')] subprocess.call(cmd_gd) # Run ElasticPowerTAC-Slave cmd_run = ['ssh', 'root@%s' % slave_ip, 'cd ~/ElasticPowerTAC-Slave/;python run.py < /dev/null > /tmp/slave-log 2>&1 &'] subprocess.call(cmd_run) print("Slaves have been initialized!") if self._config['google-drive']: self.cleanup_master() # called when google drive is the backup location def cleanup_master(self): self._docean.request_delete(self._config['master-droplet-id']) print('Goodbye.')
class ElasticPowerTAC_Slave: # constructor def __init__(self): self._config = None # Load config self.load_config() # store master ip self._docean = DOcean(self._config['api-key']) # google drive if self._config['google-drive']: self._google_drive_session = 'google-session.json' self._google_drive = GoogleDriveAPIWrapper('',self._google_drive_session) # load_config def load_config(self): # load from "config.json" try: config_file = "config.json" self._config = None with open(config_file, 'r') as f: self._config = f.read() self._config = json.loads(self._config) except: print('config.json must be defined.') exit() # setup slave environment def setup_slave_simulations(self): print("Slaves have been initialized!") self.setup_scenarios() # start simulation scenarios def start_slave_simulations(self): # start simulation runner os.chdir('/home/log/ElasticPowerTAC-Simulation') run_cmd = ['su', 'log', '-c', 'python simulation.py'] subprocess.call(run_cmd) os.chdir('/root/ElasticPowerTAC-Slave') # simulations are complete by this point if self._config['google-drive']: self.backup_on_google_drive() # backup on google drive def backup_on_google_drive(self): # iterate through files in simulation location and upload tar.gz files path = '/home/log/ElasticPowerTAC-Simulation' for filename in os.listdir(path): if filename.find('tar.gz')>=0: self._google_drive.insert_file(filename, filename, self._config['google-drive']['parent-id'], 'application/x-gzip', '%s/%s'%(path,filename)) # move scenarios from root to log location def setup_scenarios(self): # Location path run_mv = ['mv', '/root/ElasticPowerTAC-Slave/scenarios', '/home/log/ElasticPowerTAC-Simulation/'] subprocess.call(run_mv) run_chown = ['chown','log:log','/home/log/ElasticPowerTAC-Simulation/scenarios'] subprocess.call(run_chown) # destroy slave :) def clean_up(self): # start simulation cleanup # delete this slave print("goodbye....") self._docean.request_delete(self._config['droplet_id'])