

In [ ]:

    
import os
import sys
import threading

lib_path = os.path.abspath(os.path.join('.', '..'))
sys.path.append(lib_path)

Import framework modules



In [ ]:

    
from role_criteria import RoleCriteria
from logical_node import LogicalNode
from network import LiveNetwork

Define the role criteria template class



In [ ]:

    
class CompPowerRoleCriteria(RoleCriteria):
  
    def __init__(self, grade_vector, name):
        self.__GRADE_VECTOR__ = grade_vector
        self.__PROCESSING_POWER__ = self.__GRADE_VECTOR__[0]
        self.__MEMORY_CAPABILITIES__ = self.__GRADE_VECTOR__[1]
        self.__GPU_POWER__ = self.__GRADE_VECTOR__[2]
        self.__NETWORK_SPEED__ = self.__GRADE_VECTOR__[3]
        self.__STORAGE__CAP = self.__GRADE_VECTOR__[4]
        self.name = name       
    
    def evaluate_against(self, node_parameters):
        """
        Used to compare roles from a 5 element list of values.  
        Returns the sum of the node_parameters if all characteristics are satisfied.
        Otherwise, returns 0.
        """
        
        num_characteristics_satisfied = 0
        
        if node_parameters[0] >= self.__PROCESSING_POWER__:
            num_characteristics_satisfied += 1
        if node_parameters[1] >= self.__MEMORY_CAPABILITIES__:
            num_characteristics_satisfied += 1
        if node_parameters[2] >= self.__GPU_POWER__:
            num_characteristics_satisfied += 1
        if node_parameters[3] >= self.__NETWORK_SPEED__:
            num_characteristics_satisfied += 1
        if node_parameters[4] >= self.__STORAGE__CAP:
            num_characteristics_satisfied += 1
            
        # All characteristics must be satisfied
        if num_characteristics_satisfied == 5:
            return sum(node_parameters)
        else:
            return 0

Instantiate role criterias to create different roles



In [ ]:

    
# [processing_power, memory_capabilities, gpu_power, network_speed, storage_cap]
role_criterias = [
    CompPowerRoleCriteria([1, 1, 1, 1, 1], "Mobile"),
    CompPowerRoleCriteria([2, 3, 2, 2, 4], "Desktop"),
    CompPowerRoleCriteria([5, 5, 5, 5, 5], "Server")
]

Instantiate logical nodes with different parameters



In [ ]:

    
# [processing_power, memory_capabilities, gpu_power, network_speed, storage_cap]
nodes = [
    LogicalNode(0, [1, 1, 1, 1, 1], role_criterias),
    LogicalNode(1, [2, 2, 2, 2, 2], role_criterias),
    LogicalNode(2, [4, 4, 4, 4, 4], role_criterias),
    LogicalNode(3, [5, 5, 5, 5, 5], role_criterias)
]

Set up the network



In [ ]:

    
node_ip_addresses = [("localhost", 5000 + i) for i in range(len(nodes))]
networks = [LiveNetwork(node, node_ip_addresses) for node in nodes]
server_starters = [threading.Thread(target=network.start_server) for network in networks]
for server_starter in server_starters:
    server_starter.start()

Run the role assignment algorithm



In [ ]:

    
client = LiveNetwork.create_conn(node_ip_addresses[2])
token = client.root.begin_logical_assignment()

Inspect the results



In [ ]:

    
if token:
    print "Error - one or more roles could not be assigned"
    for role_id in token.unassigned_roles:
        print "Role %d: %s" % (role_id, role_criterias[role_id].name)
else:
    print "Success - all roles assigned!"
    for node in nodes:
        if node.assigned_role is not None:
            print "Node %d's role: %s" % (node.node_id, role_criterias[node.assigned_role].name)

Force an assignment failure



In [ ]:

    
nodes[2].parameters = [4, 4, 4, 4, 3]

Clean up



In [ ]:

    
for network in networks:
    network.stop_server()