def __init__(self, args):

self.args = args

self.nodes = []

self.controller = None

self.data = None

# Start server thread to wait for clients

self.client = client.client(self.args)

self.client.set_riddler(self)

# Load node objects from network config

if not self.load_nodes():

self.quit()

return

# Connect to nodes

self.start_nodes()

def start(self):

# Create a data object for results and samples

#print "b"

#self.data = data.data(self.args) #FIX! RASP!

self.data = data.data_pandas(self.args)

self.data.add_nodes(self.nodes)

# Inform clients

self.client.export_event(interface.STARTED)

# Start test controller

#print(" Starting test controller ")

self.controller = controller.controller(self.args)

self.controller.nodes = self.nodes

self.controller.data = self.data

self.controller.start()

# Tell the controller to stop and wait for it

def stop_controller(self):

if self.controller:

self.controller.stop()

self.controller.join()

# Disconnect clients and wait for it

def stop_client(self):

if self.client:

self.client.stop()

self.client.join()

# Disconnect nodes

def stop_nodes(self):

# End nodes threads

for node in self.nodes:

node.stop()

# Wait for them to finish

for node in self.nodes:

node.join()

# Stop a running test

def stop_test(self):

if not self.controller:

return

# Tell controller to stop

print("Stopping test")

self.controller.stop()

# Inform clients

self.client.export_event(interface.STOPPED)

# Reconnect nodes to free controller

for node in self.nodes:

node.reconnect()

# Wait for controller to finish

self.controller.join()

# Stop everything and quit program

def quit(self):

print("Quitting. Please wait...")

print("Stopping nodes")

self.stop_nodes()

print("Stopping controller")

self.stop_controller()

print("Stopping client")

self.stop_client()

sys.exit(0)

# Load the nodes configuration and distribute node references

def load_nodes(self):

try:

c = __import__(self.args.nodes_file) #imports data from nodes file

self.nodes = c.node.nodes #Nodes are saved in class

except ImportError:

print("Unable to load nodes file: {0}".format(self.args.nodes_file))

return False

# Add client object to each node

for node in self.nodes:

node.client = self.client

# Add node objects to client server

for node in self.nodes:

self.client.export_node(node)

return True

# Start node thread and wait for information from each node

def start_nodes(self):

for node in self.nodes:

node.start()

try:

for node in self.nodes:

node.wait()

except KeyboardInterrupt:

print("Quit")

self.quit()

time.sleep(5)

def set_pause(self, pause):

if not self.controller:

return

self.controller.set_pause(pause)

for node in self.nodes:

node.pause()

if pause:

self.client.export_event(interface.PAUSED)

else:

self.client.export_event(interface.UNPAUSED)

# Clear the pause event in controller to pause current run

def toggle_pause(self):

if not self.controller:

return

print("Toggling pause")

if self.controller.toggle_pause():

self.client.export_event(interface.PAUSED)

else:

self.client.export_event(interface.UNPAUSED)

for node in self.nodes:

node.pause()

# Recover by reconnecting nodes

def recover(self):

if not self.controller:

return

print("Recovering")

self.controller.recover()

def save_data(self):

if not self.data:

return

# Read filename form console

path = raw_input("Filename: (Hit enter for '{0}')\n".format(self.args.data_file))

# If no name was entered, we use the configured one

if not path:

path = self.args.data_file

# Dump data to pickle file

data.dump_data(self.data, path)

print("Data saved to '{0}'".format(path))

def set_args(self, args):

self.args = args

print("")

print(" t Start test")

print(" p Toggle pause")

print(" s Stop test")

print(" r Recover")

print(" d Save data")

print(" q Quit")

print(" h Help")