def run_analysis(options): # Get our FTP IP try: ftp_ip = NET.get_ip_address(options.ftp_interface) except: logger.error("Could not find ip for the given interface. (%s)"% options.ftp_interface) # Add a sensors to physical machines if needed if options.machine_type == G.MACHINE_TYPES.PHYSICAL: has_memory = has_disk = False if options.machine_config is None: logger.error("No machine config file given.") return # This isn't the class we use in practice, but fake it here for simplicity machines = CONF.import_from_config(options.machine_config, "machine") if options.machine not in machines: logger.error("%s is not a valid machine from the config file."%options.machine) logger.error("Valid targets are: %s"%machines.keys()) return # Get our machine object machine = machines[options.machine] # Ensure that a sensor config is defined if options.sensor_config is None: logger.error("A sensor config file must be defined for physical analysis") return # Get the list of sensors sensors = CONF.import_from_config(options.sensor_config, "sensor") # Add sensors to our machine print "* Trying to find physical sensors for %s..."%options.machine added_sensors = machine.add_sensors(sensors) else: machine = VirtualMachine(options.machine, vm_type=options.machine_type, volatility_profile=options.profile) ftp_info = {'user':G.FTP_USER, 'pass':G.FTP_PASSWORD, 'ip':ftp_ip, 'port':G.FTP_PORT, 'dir':None } print "* Machine is: %s"%machine.power_status() ra = RemoteAnalysis(options.profile, machine.control, ftp_info) parameters = { # 1:'INTmark (write)', # 2:'INTmark (Read)', 3:'INTmem', # 4:'FLOATmark (write)', # 5:'FLOATmark (Read)', 6:'FLOATmem', # 7:'MMXmark (write)', # 8:'MMXmark (Read)', 9:'MMXmem', # 10:'SSEmark (write)', # 11:'SSEmark (Read)', 12:'SSEmem' } # Create a run for all of our parameters (Only *mem will run in batches) for b_param in parameters: # Should we be reading memory? if options.enable_sensor: memory_thread = MemoryThread(machine) memory_thread.daemon = True memory_thread.start() param_name = parameters[b_param] print "* Running %s test, %d times..."%(param_name, options.run_count) response = ra.run_analysis("ramspeed-win32.exe -b %d -l %d"%( b_param, options.run_count), "artifacts-memory", init_commands=[], bind_ip=ftp_ip) # Now store our results results_file = os.path.join(options.output_dir, "trial_b%d_l%d.txt"%(b_param, options.run_count)) sensor_file = os.path.join(options.output_dir, "trial_b%d_l%d_sensor.txt"%(b_param, options.run_count)) print "* Storing results (%d bytes) in %s."%(len(response),results_file) f = open(results_file, "w+") f.write(response) f.close() if options.enable_sensor: (time_elapsed, bytes_read) = memory_thread.join() f = open(sensor_file, "w+") f.write(str(time_elapsed)+"\t"+str(bytes_read)) f.close()
def run(self): logger.info("Started LO-PHI analysis scheduler. (PID: %d)" % os.getpid()) # Loop forever, consuming analyses and assigning machines to them while True: # Cleanup any previous analysis self._cleanup_pointers() # Get an analysis (analysis_file, command) = self.analysis_queue.get() # Initialize our analysis AnalysisClass = self.load_analysis(analysis_file) analysis = LoPhiAnalysisEngine(running_dict=ANALYSIS_STATUS, services_host=SERVICES_HOST) ANALYSIS_QUEUED.append(analysis.id) if command.machine is None: logger.debug("Got Analysis: %s" % AnalysisClass) machine_name = self.machine_queue.get() machine = self.machine_list[machine_name] logger.debug("Got Machine: %s" % machine) analysis.start(AnalysisClass, lophi_command=command, machine_name=machine_name, machine_list=self.machine_list, machine_queue=self.machine_queue) else: logger.debug("Got Machine: %s" % command.machine) # Did the user define a machine? machine_name = command.machine if machine_name in self.machine_list.keys(): # Get our machine machine = self.machine_list[machine_name] if machine.ALLOCATED >= 0: logger.warning( "Machine (%s) is already allocated to %d." % (machine.config.name, machine.ALLOCATED)) # Check to see if a vm with this name exists elif command.machine_type != G.MACHINE_TYPES.PHYSICAL: # Init a VM object vm = VirtualMachine(command.machine, command.machine_type) if vm.power_status( ) == G.SENSOR_CONTROL.POWER_STATUS.UNKNOWN: logger.error("Virtual machine (%s) does not exist." % command.machine) return False else: machine = vm else: logger.error("Could not find machine: %s" % machine_name) return False analysis.start(AnalysisClass, lophi_command=command, machine=machine) # Update our dict # This is neccesary to keep a pointer to the analysis so that the # scheduler won't kill the thread self.ANALYSIS_DICT.update({analysis.id: analysis}) # Print some status print "* Starting analysis (%s) on machine (%s)." % ( AnalysisClass.NAME, machine.config.name) time.sleep(1)
def __init__(self, options, positionals): """ Initialize our controller. This includes initializing all of the configurations and opening all of the appropriate logfiles. """ # Set our port to bind to self._sock = None self.PORT_NUM = options.port # AMQP Host (Only used to hand off to analysis self.services_host = options.services_host # What config file are we loading? sensor_config_file = options.sensor_config_file # What config file are we loading? machine_config_file = options.machine_config_file # Disk images config file images_config_file = options.images_config_file # Import our available sensors logger.debug("Importing sensor config file (%s)" % sensor_config_file) self.sensor_list = Configs.import_from_config(sensor_config_file, "sensor") # Import our available machines logger.debug("Importing machine config file (%s)" % machine_config_file) self.machine_list = Configs.import_from_config(machine_config_file, "machine") # Import our image mappings logger.debug("Importing images config file (%s)" % images_config_file) self.images_map = Configs.import_from_config(images_config_file, "images") # Provision the number of requested VMs print "* Initializing %d virtual machines..." % options.vm_count for x in range(0, options.vm_count): tmp_name = "lophi-%d" % x self.machine_list[tmp_name] = VirtualMachine(tmp_name, force_new=True) # Build our dictionary of queues # This queues are handed to analysis for scheduling self.MACHINE_QUEUES = {} self.ANALYSIS_SCHEDULER = {} print "* Assigning sensors to machines, and configure machines" for m in self.machine_list: # Setup their image maps self.machine_list[m].add_image_map( \ self.images_map[self.machine_list[m].type]) # Add sensors and PXE server to physical machines if self.machine_list[m].type == G.MACHINE_TYPES.PHYSICAL: # Add sensors self.machine_list[m].add_sensors(self.sensor_list) # Add pxe_server from lophinet.pxeserver import PXEServer pxe_server = PXEServer(options.pxe_server) self.machine_list[m].add_pxe_server(pxe_server) manager = multiprocessing.Manager() for m in self.machine_list: # Get our indices t = self.machine_list[m].type # New queue? if t not in self.MACHINE_QUEUES: machine_queue = manager.Queue() self.MACHINE_QUEUES[t] = machine_queue self.ANALYSIS_SCHEDULER[t] = LophiScheduler( self.machine_list, machine_queue) self.ANALYSIS_SCHEDULER[t].start() # Add to queue self.MACHINE_QUEUES[t].put(m) # Ensure that we can share this list with our analysis threads # self.machine_list = multiprocessing.Manager().dict(self.machine_list) # Setup our FTP info self.ftp_ip_physical = self.ftp_ip_virtual = None try: self.ftp_ip_physical = NET.get_ip_address(options.ftp_physical) except: logger.error("Could not find ip for physical FTP interface. (%s)" % options.ftp_physical) try: self.ftp_ip_virtual = NET.get_ip_address(options.ftp_virtual) except: logger.error("Could not find ip for virtual FTP interface. (%s)" % options.ftp_virtual) # Server stuff self.RUNNING = True # Init our multiprocess multiprocessing.Process.__init__(self) """
def run(self): logger.info("Started LO-PHI analysis scheduler. (PID: %d)"%os.getpid()) # Loop forever, consuming analyses and assigning machines to them while True: # Cleanup any previous analysis self._cleanup_pointers() # Get an analysis (analysis_file, command) = self.analysis_queue.get() # Initialize our analysis AnalysisClass = self.load_analysis(analysis_file) analysis = LoPhiAnalysisEngine(running_dict=ANALYSIS_STATUS, services_host=SERVICES_HOST) ANALYSIS_QUEUED.append(analysis.id) if command.machine is None: logger.debug("Got Analysis: %s"%AnalysisClass) machine_name = self.machine_queue.get() machine = self.machine_list[machine_name] logger.debug("Got Machine: %s"%machine) analysis.start(AnalysisClass, lophi_command=command, machine_name=machine_name, machine_list=self.machine_list, machine_queue=self.machine_queue) else: logger.debug("Got Machine: %s"%command.machine) # Did the user define a machine? machine_name = command.machine if machine_name in self.machine_list.keys(): # Get our machine machine = self.machine_list[machine_name] if machine.ALLOCATED >= 0: logger.warning("Machine (%s) is already allocated to %d."%(machine.config.name,machine.ALLOCATED)) # Check to see if a vm with this name exists elif command.machine_type != G.MACHINE_TYPES.PHYSICAL: # Init a VM object vm = VirtualMachine(command.machine,command.machine_type) if vm.power_status() == G.SENSOR_CONTROL.POWER_STATUS.UNKNOWN: logger.error("Virtual machine (%s) does not exist."%command.machine) return False else: machine = vm else: logger.error("Could not find machine: %s"%machine_name) return False analysis.start(AnalysisClass, lophi_command=command, machine=machine) # Update our dict # This is neccesary to keep a pointer to the analysis so that the # scheduler won't kill the thread self.ANALYSIS_DICT.update({analysis.id: analysis}) # Print some status print "* Starting analysis (%s) on machine (%s)."%(AnalysisClass.NAME, machine.config.name) time.sleep(1)
def run_analysis(options): # Get our FTP IP try: ftp_ip = NET.get_ip_address(options.ftp_interface) except: logger.error("Could not find ip for the given interface. (%s)" % options.ftp_interface) # Add a sensors to physical machines if needed if options.machine_type == G.MACHINE_TYPES.PHYSICAL: has_memory = has_disk = False if options.machine_config is None: logger.error("No machine config file given.") return # This isn't the class we use in practice, but fake it here for simplicity machines = CONF.import_from_config(options.machine_config, "machine") if options.machine not in machines: logger.error("%s is not a valid machine from the config file." % options.machine) logger.error("Valid targets are: %s" % machines.keys()) return # Get our machine object machine = machines[options.machine] # Ensure that a sensor config is defined if options.sensor_config is None: logger.error( "A sensor config file must be defined for physical analysis") return # Get the list of sensors sensors = CONF.import_from_config(options.sensor_config, "sensor") # Add sensors to our machine print "Trying to find physical sensors for %s..." % options.machine added_sensors = machine.add_sensors(sensors) if options.enable_sensor: machine.disk.sata_enable_all() else: machine = VirtualMachine(options.machine, vm_type=options.machine_type, volatility_profile=options.profile) ftp_info = { 'user': G.FTP_USER, 'pass': G.FTP_PASSWORD, 'ip': ftp_ip, 'port': G.FTP_PORT, 'dir': None } print machine.power_status() ra = RemoteAnalysis(options.profile, machine.control, ftp_info) for trial in range(44, options.run_count): print "Running trial #%d..." % trial # Should we fire up our disk sensor? # if options.enable_sensor: # log_dcap_filename = os.path.join(options.output_dir,"trial_%d.dcap"%trial) # log_dcap_queue = multiprocessing.Queue() # log_dcap_writer = CaptureWriter(log_dcap_filename, # log_dcap_queue) # log_dcap_writer.start() # # dcap_engine = DiskCaptureEngine(machine, log_dcap_queue) # dcap_engine.start() iozone_cmd = "iozone.exe -a -g 2G -i 0 -i 1" response = ra.run_analysis( iozone_cmd, None, init_commands=["cd C:\Program Files\Benchmarks\Iozone3_414"], bind_ip=ftp_ip) f = open(os.path.join(options.output_dir, "trial_%d.txt" % trial), "w+") f.write(response) f.close() # if options.enable_sensor: # dcap_engine.stop() # log_dcap_writer.stop() print response
def run_analysis(options): # Get our FTP IP try: ftp_ip = NET.get_ip_address(options.ftp_interface) except: logger.error("Could not find ip for the given interface. (%s)" % options.ftp_interface) # Add a sensors to physical machines if needed if options.machine_type == G.MACHINE_TYPES.PHYSICAL: has_memory = has_disk = False if options.machine_config is None: logger.error("No machine config file given.") return # This isn't the class we use in practice, but fake it here for simplicity machines = CONF.import_from_config(options.machine_config, "machine") if options.machine not in machines: logger.error("%s is not a valid machine from the config file." % options.machine) logger.error("Valid targets are: %s" % machines.keys()) return # Get our machine object machine = machines[options.machine] # Ensure that a sensor config is defined if options.sensor_config is None: logger.error( "A sensor config file must be defined for physical analysis") return # Get the list of sensors sensors = CONF.import_from_config(options.sensor_config, "sensor") # Add sensors to our machine print "* Trying to find physical sensors for %s..." % options.machine added_sensors = machine.add_sensors(sensors) else: machine = VirtualMachine(options.machine, vm_type=options.machine_type, volatility_profile=options.profile) ftp_info = { 'user': G.FTP_USER, 'pass': G.FTP_PASSWORD, 'ip': ftp_ip, 'port': G.FTP_PORT, 'dir': None } print "* Machine is: %s" % machine.power_status() ra = RemoteAnalysis(options.profile, machine.control, ftp_info) parameters = { # 1:'INTmark (write)', # 2:'INTmark (Read)', 3: 'INTmem', # 4:'FLOATmark (write)', # 5:'FLOATmark (Read)', 6: 'FLOATmem', # 7:'MMXmark (write)', # 8:'MMXmark (Read)', 9: 'MMXmem', # 10:'SSEmark (write)', # 11:'SSEmark (Read)', 12: 'SSEmem' } # Create a run for all of our parameters (Only *mem will run in batches) for b_param in parameters: # Should we be reading memory? if options.enable_sensor: memory_thread = MemoryThread(machine) memory_thread.daemon = True memory_thread.start() param_name = parameters[b_param] print "* Running %s test, %d times..." % (param_name, options.run_count) response = ra.run_analysis("ramspeed-win32.exe -b %d -l %d" % (b_param, options.run_count), "artifacts-memory", init_commands=[], bind_ip=ftp_ip) # Now store our results results_file = os.path.join( options.output_dir, "trial_b%d_l%d.txt" % (b_param, options.run_count)) sensor_file = os.path.join( options.output_dir, "trial_b%d_l%d_sensor.txt" % (b_param, options.run_count)) print "* Storing results (%d bytes) in %s." % (len(response), results_file) f = open(results_file, "w+") f.write(response) f.close() if options.enable_sensor: (time_elapsed, bytes_read) = memory_thread.join() f = open(sensor_file, "w+") f.write(str(time_elapsed) + "\t" + str(bytes_read)) f.close()
def main(options): """ Implement your function here """ # Keep track of the type of analysis that is possible (for physical) has_memory = has_disk = True # Add a sensors to physical machines if needed if options.machine_type == G.MACHINE_TYPES.PHYSICAL: has_memory = has_disk = False if options.machine_config is None: logger.error("No machine config file given.") return # This isn't the class we use in practice, but fake it here for simplicity machines = CONF.import_from_config(options.machine_config, "machine") if options.machine not in machines: logger.error("%s is not a valid machine from the config file." % options.machine) logger.error("Valid targets are: %s" % machines.keys()) return # Get our machine object machine = machines[options.machine] # Ensure that a sensor config is defined if options.sensor_config is None: logger.error( "A sensor config file must be defined for physical analysis") return # Get the list of sensors sensors = CONF.import_from_config(options.sensor_config, "sensor") # Add sensors to our machine print "Trying to find physical sensors for %s..." % options.machine added_sensors = machine.add_sensors(sensors) # See which sensors were added for sensor in added_sensors: print "* Added %s to %s" % (sensor.id, machine.config.name) if issubclass(sensor.__class__, MemorySensor): has_memory = True if issubclass(sensor.__class__, DiskSensor): has_disk = True else: machine = VirtualMachine(options.machine, vm_type=options.machine_type, volatility_profile=options.volatility_profile) if options.analysis is not None: analysis = analysis_scripts[options.analysis] lae = LoPhiAnalysisEngine() lae.start(analysis[0], machine=machine) print "Running Analysis (%s)..." % options.analysis while True: print "* The following commands are available" print " p - Pause, r - Resume, s - Stop" command = raw_input('cmd: ') if command == "p": lae.pause() print "Analysis PAUSED." elif command == "r": lae.resume() print "Analysis RESUMED." elif command == "s": lae.stop() print "Analysis STOPPED." sys.exit(0) else: print "Unrecognized command (%s)." % command if False and has_memory: print "Starting memory analysis" # Create a queue and start our analysis output_queue = multiprocessing.Queue() mem_analysis = MemoryAnalysisEngine(machine, output_queue, plugins=['pslist']) mem_cap = CaptureWriter("memory.cap", output_queue) # mem_cap.start() mem_analysis.start() for i in range(10): print output_queue.get() # mem_cap.stop() mem_analysis.stop() if has_disk: print "Starting disk analysis" # create a queue and start analysis output_queue = multiprocessing.Queue() disk_analysis = DiskAnalysisEngine(machine, output_queue) disk_cap = CaptureWriter("disk.cap", output_queue) # disk_cap.start() disk_analysis.start() for i in range(100): print output_queue.get() # disk_cap.stop() disk_analysis.stop()
def run_analysis(options): # Get our FTP IP try: ftp_ip = NET.get_ip_address(options.ftp_interface) except: logger.error("Could not find ip for the given interface. (%s)"% options.ftp_interface) # Add a sensors to physical machines if needed if options.machine_type == G.MACHINE_TYPES.PHYSICAL: has_memory = has_disk = False if options.machine_config is None: logger.error("No machine config file given.") return # This isn't the class we use in practice, but fake it here for simplicity machines = CONF.import_from_config(options.machine_config, "machine") if options.machine not in machines: logger.error("%s is not a valid machine from the config file."%options.machine) logger.error("Valid targets are: %s"%machines.keys()) return # Get our machine object machine = machines[options.machine] # Ensure that a sensor config is defined if options.sensor_config is None: logger.error("A sensor config file must be defined for physical analysis") return # Get the list of sensors sensors = CONF.import_from_config(options.sensor_config, "sensor") # Add sensors to our machine print "Trying to find physical sensors for %s..."%options.machine added_sensors = machine.add_sensors(sensors) if options.enable_sensor: machine.disk.sata_enable_all() else: machine = VirtualMachine(options.machine, vm_type=options.machine_type, volatility_profile=options.profile) ftp_info = {'user':G.FTP_USER, 'pass':G.FTP_PASSWORD, 'ip':ftp_ip, 'port':G.FTP_PORT, 'dir':None } print machine.power_status() ra = RemoteAnalysis(options.profile, machine.control, ftp_info) for trial in range(44,options.run_count): print "Running trial #%d..."%trial # Should we fire up our disk sensor? # if options.enable_sensor: # log_dcap_filename = os.path.join(options.output_dir,"trial_%d.dcap"%trial) # log_dcap_queue = multiprocessing.Queue() # log_dcap_writer = CaptureWriter(log_dcap_filename, # log_dcap_queue) # log_dcap_writer.start() # # dcap_engine = DiskCaptureEngine(machine, log_dcap_queue) # dcap_engine.start() iozone_cmd = "iozone.exe -a -g 2G -i 0 -i 1" response = ra.run_analysis(iozone_cmd, None, init_commands=["cd C:\Program Files\Benchmarks\Iozone3_414"], bind_ip=ftp_ip) f = open(os.path.join(options.output_dir,"trial_%d.txt"%trial), "w+") f.write(response) f.close() # if options.enable_sensor: # dcap_engine.stop() # log_dcap_writer.stop() print response