def getPolicy(self, idx): if idx == 1: return policy.Policy('config/p1_ModelWin.txt', self.getNumActions(), self.getNumStates()) if idx == 2: return policy.Policy('config/p2_ModelWin.txt', self.getNumActions(), self.getNumStates()) else: print("Unknown policy given to ModelWin::getPolicy") exit()
def __init__(self, gamma, tau, hiddenSize, numInputs, actionSpace, device = torch.device('cpu')): self.device = device self.actionSpace = actionSpace self.numInputs = numInputs self.model = p.Policy(hiddenSize, numInputs, actionSpace, device).to(device=device) self.target = p.Policy(hiddenSize, numInputs, actionSpace, device).to(device=device) hardUpdate(self.target, self.model) self.gamma = gamma self.tau = tau self.optimizer = Adam(self.model.parameters(), lr=1e-4, weight_decay=1e-5) self.loss = torch.nn.MSELoss(reduction='sum')
def __init__(self): self.server_config = server.server_config self.servers = self.get_servers() self.total_servers = len(self.servers) self.policy_obj = policy.Policy(self.total_servers) self.current_connection_count_list = [] for each in self.servers: self.current_connection_count_list.append(0) self.last_server = 0 self.curr_conn_list = [] self.policy = policy.Policy(self.total_servers) self.persi_hit = 0
def test_check_policy(): """ Test that packet match against policy works correctly """ #*** Instantiate tc, flows and identities classes, specifying #*** a particular main_policy file to use: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static.yaml") flow = flows_module.Flow(config) ident = identities.Identities(config, policy) #*** Note: cannot query a classification until a packet has been #*** ingested - will throw error #*** Ingest a packet: #*** Test Flow 1 Packet 1 (Client TCP SYN): # 10.1.0.1 10.1.0.2 TCP 74 43297 > http [SYN] flow.ingest_packet(DPID1, INPORT1, pkts.RAW[0], datetime.datetime.now()) #*** Check policy: policy.check_policy(flow, ident) #*** Should not match any rules in that policy: logger.debug("flow.classification.classified=%s", flow.classification.classified) assert flow.classification.classified == 1 assert flow.classification.classification_tag == "" assert flow.classification.actions == {} #*** Re-instantiate policy with different policy that should classify: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static_3.yaml") #*** Re-ingest packet: #*** Test Flow 1 Packet 1 (Client TCP SYN): # 10.1.0.1 10.1.0.2 TCP 74 43297 > http [SYN] flow.ingest_packet(DPID1, INPORT1, pkts.RAW[0], datetime.datetime.now()) #*** Check policy: policy.check_policy(flow, ident) #*** Should match policy: assert flow.classification.classified == 1 assert flow.classification.classification_tag == "Constrained Bandwidth Traffic" logger.debug("flow.classification.actions=%s", flow.classification.actions) assert flow.classification.actions == { 'set_desc': 'Constrained Bandwidth Traffic', 'qos_treatment': 'constrained_bw' }
def getPolicy(self, idx): if idx == 1: return policy.Policy('config/p1.txt', self.getNumActions(), self.getNumStates()) if idx == 2: return policy.Policy('config/p2.txt', self.getNumActions(), self.getNumStates()) if idx == 3: return policy.Policy('config/p3.txt', self.getNumActions(), self.getNumStates()) if idx == 4: return policy.Policy('config/p4.txt', self.getNumActions(), self.getNumStates()) if idx == 5: return policy.Policy('config/p5.txt', self.getNumActions(), self.getNumStates()) else: print("Unknown policy given to Gridworld::getPolicy") exit()
def load_policy_network(name): in_dim = preprocessing.state_to_tensor.features out_dim = preprocessing.action_to_tensor.features model = L.Classifier(policy.Policy(in_dim, out_dim)) serializers.load_npz('%s.model.npz' % name, model) def policy_network(gs): state = preprocessing.state_to_tensor(gs) Y = model.predictor([state]).data[0] actions = [] for idx, pos in gs.legal_moves(): action = preprocessing.action_to_tensor(gs, idx, pos, gs.size) actions.append(action) # 确保即使actions为空列表,也要构造一个int型的空np数组 actions = np.array(actions, dtype=np.int32) Y = Y[actions] Y = Y.reshape((1, Y.size)) Y = Variable(Y) P = F.softmax(Y).data[0] for idx, pos in enumerate(gs.legal_moves()): yield pos, P[idx] return policy_network
def delete_prereq(): with open('configure.json') as file: json_text = json.load(file) # Delete Thing thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) thing_obj.delete() # Delete certificate cert_id_filename = thing_name + '_cert_id.txt' cert_id_file = open(cert_id_filename, 'r') cert_id = cert_id_file.read() cert_obj = certs.Certificate(cert_id) cert_obj.delete() cert_id_file.close() cert_id_file_path = os.path.abspath(cert_id_filename) os.chmod(cert_id_file_path, 0o666) os.remove(cert_id_filename) # Delete cert_pem file and private_key_pem file cert_pem_filename = thing_name + '_cert.pem' private_key_pem_filename = thing_name + '_private_key.pem' cert_pem_file_path = os.path.abspath(cert_pem_filename) private_key_pem_file_path = os.path.abspath(private_key_pem_filename) os.chmod(cert_pem_file_path, 0o666) os.chmod(private_key_pem_file_path, 0o666) os.remove(cert_pem_filename) os.remove(private_key_pem_filename) # Delete policy policy_obj = policy.Policy(thing_name) policy_obj.delete()
def cleanup(): certIdlength = 64 with open('configure.json') as file: json_text = json.load(file) thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) principals = thing_obj.list_principals() # Delete certificates and policies attached to thing for eachPrincipal in principals: certId = eachPrincipal[-certIdlength:] certarn = eachPrincipal cert_obj = certs.Certificate(certId) # Get policies attached to certificate policies_attached = cert_obj.list_policies() # Delete certificate cert_obj.delete() # Delete policies attached to the certificate for each_policy in policies_attached: policy_obj = policy.Policy(each_policy['policyName']) policy_obj.delete() # Delete Thing thing_obj.delete()
def __init__(self, controll_config, samples, en_data, en_train, en_auto_sla, accuracy, sleep_interval, sample_len, llcM): #self.logging.basicConfig('logger.log',logging.INFO) #self.logger = logging.getLogger('example1') self.enable_data_driven = en_data self.enable_training = en_train self.enable_auto_sla = en_auto_sla self.sleep_interval = sleep_interval self.allGroups = samples # ["app1","app2"] self.sample_len = sample_len self.controlConfig = controll_config self.slas = {} self.policies = {} for g in samples: self.policies[g] = po.Policy(g, self.allGroups, controll_config, accuracy) self.slas[g] = controll_config[g]["SLA"]["ipc"] self.currentInfo = {} self.llcM = llcM self.throttled_group = set() self.relax_count = 0
def one_step_lookahead(self, value, error_prob=0): new_policy_matrix = [[[None for y in xrange(self.length)] for x in xrange(self.width)] for h in xrange(self.num_headings)] for state in self.state_space.states: possible_states = self.state_space.get_adjacent_states(state) max_action_value = float("-inf") best_action = None for action_tuple in ac.action_space: action = ac.Action(action_tuple[0], action_tuple[1]) action_value = 0 for next_state in possible_states: x, y, h = next_state.get_state() action_value += self.transition_prob( error_prob, state, action, next_state) * value[h][x][y] # add all Psa(s')V(s') if action_value > max_action_value: max_action_value = action_value best_action = action x, y, h = state.get_state() new_policy_matrix[h][x][y] = best_action new_policy = pol.Policy(new_policy_matrix) return new_policy
def delete_prereq(): with open('configure.json') as file: json_text = json.load(file) # Delete Thing thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) thing_obj.delete() # Delete certificate cert_id_filename = thing_name + '_cert_id_file' cert_id_file = open(cert_id_filename, 'r') cert_id = cert_id_file.read() cert_obj = certs.Certificate(cert_id) cert_obj.delete() os.remove(cert_id_filename) # Delete cert_pem file and private_key_pem file cert_pem_filename = thing_name + '_cert_pem_file' private_key_pem_filename = thing_name + '_private_key_pem_file' os.remove(cert_pem_filename) os.remove(private_key_pem_filename) # Delete policy policy_name = thing_name + '_amazon_freertos_policy' policy_obj = policy.Policy(policy_name) policy_obj.delete()
def get_target(s_real, discount, max_reward=[999999, 0], depth=0): """returns the optimal target given a state""" if depth == depth_to_check: return 1, s_real.reward() p = policy.Policy() for i in range(8): s = state.State( p, ev_profile=s_real.EV_PROFILE, time=s_real.time, house_demand=s_real.house_demand, ev_at_home=s_real.ev_at_home, ev_charge=s_real.ev_charge, bat_charge=s_real.bat_charge, flexi_charge=s_real.flexi_charge, ev_capacity=s_real.EV_CAPACITY, battery_capacity=s_real.BATTERY_CAPACITY, variable_load_power_req=s_real.VARIABLE_LOAD_POWER_REQ, solar_generation_capacity=s_real.SOLAR_GENERATION_CAPACITY, solar_generated=s_real.solar_generated) p.manual_update(i) s.update(p) reward = s.reward() + get_target(s, discount, max_reward, depth + 1)[1] * discount if reward < max_reward[0]: max_reward = [reward, i] result = [0 for i in range(8)] result[max_reward[1]] = 1 return result, max_reward[0]
def prereq(): with open('configure.json') as file: json_text = json.load(file) # Validate that the entries in the JSON are valid. validate_json_text(json_text) # Create a Thing thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) if not thing_obj.create(): # Create a Certificate cert_obj = certs.Certificate() result = cert_obj.create() # Store certId cert_id = result['certificateId'] cert_id_filename = thing_name + '_cert_id_file' print('Writing certificate ID to: {}'.format(cert_id_filename)) cert_id_file = open(cert_id_filename, 'w') cert_id_file.write(cert_id) cert_id_file_path = os.path.abspath(cert_id_filename) os.chmod(cert_id_file_path, 0o444) cert_id_file.close() # Store cert_pem as file cert_pem = result['certificatePem'] cert_pem_filename = thing_name + '_cert_pem_file' print('Writing certificate PEM to: {}'.format(cert_pem_filename)) cert_pem_file = open(cert_pem_filename, 'w') cert_pem_file.write(cert_pem) cert_pem_file_path = os.path.abspath(cert_pem_filename) os.chmod(cert_pem_file_path, 0o444) cert_pem_file.close() # Store private key PEM as file private_key_pem = result['keyPair']['PrivateKey'] private_key_pem_filename = thing_name + '_private_key_pem_file' print( 'Writing private key PEM to: {}'.format(private_key_pem_filename)) private_key_pem_file = open(private_key_pem_filename, 'w') private_key_pem_file.write(private_key_pem) private_key_pem_file_path = os.path.abspath(private_key_pem_filename) os.chmod(private_key_pem_file_path, 0o444) private_key_pem_file.close() # Create a Policy policy_document = misc.create_policy_document() policy_name = thing_name + '_amazon_freertos_policy' policy_obj = policy.Policy(policy_name, policy_document) policy_obj.create() # Attach certificate to Thing cert_obj.attach_thing(thing_name) # Attach policy to certificate cert_obj.attach_policy(policy_name) print("Completed prereq operation!")
def test_start_crawler(): plc = policy.Policy() plc.CRAWLER_TYPE = 2 plc.CRAWLER_NUMBER = 1 plc.APPLY_TIME_INTERVAL = True plc.START_FILTER[URL] = "www.gdgpo.gov.cn" start_crawler.start_crawlers(plc)
def test_check_tc_rule(): #*** Instantiate classes: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static.yaml") flow = flows_module.Flow(config) ident = identities.Identities(config, policy) #*** Test Flow 1 Packet 1 (Client TCP SYN): # 10.1.0.1 10.1.0.2 TCP 74 43297 > http [SYN] flow.ingest_packet(DPID1, INPORT1, pkts.RAW[0], datetime.datetime.now()) #*** Set policy.pkt as work around for not calling parent method that sets it: policy.pkt = flow.packet #*** main_policy_regression_static.yaml shouldn't match HTTP (rule 0): tc_rules = policy_module.TCRules(policy) tc_rule = policy_module.TCRule(tc_rules, policy, 0) tc_rule_result = tc_rule.check_tc_rule(flow, ident) assert tc_rule_result.match == False assert tc_rule_result.continue_to_inspect == False assert tc_rule_result.classification_tag == "" assert tc_rule_result.actions == {} #*** main_policy_regression_static_3.yaml should match HTTP (rule 0): policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static_3.yaml") ident = identities.Identities(config, policy) tc_rules = policy_module.TCRules(policy) tc_rule = policy_module.TCRule(tc_rules, policy, 0) tc_rule_result = tc_rule.check_tc_rule(flow, ident) assert tc_rule_result.match == True assert tc_rule_result.continue_to_inspect == False assert tc_rule_result.classification_tag == "Constrained Bandwidth Traffic" assert tc_rule_result.actions == { 'qos_treatment': 'constrained_bw', 'set_desc': 'Constrained Bandwidth Traffic' }
def test_harvest_DHCP(): """ Test harvesting identity metadata from an IPv4 DHCP request Note: this test is very basic and does not cover much... TBD: cover more scenarios and DHCP message types """ #*** Instantiate flow, policy and identities objects: flow = flows_module.Flow(config) policy = policy_module.Policy(config) identities = identities_module.Identities(config, policy) #*** Client to Server DHCP Request: flow.ingest_packet(DPID1, INPORT1, pkts_dhcp.RAW[2], datetime.datetime.now()) identities.harvest(pkts_dhcp.RAW[2], flow.packet) flow_pkt = flow.packet assert identities.dhcp_msg.dpid == DPID1 assert identities.dhcp_msg.in_port == INPORT1 assert identities.dhcp_msg.eth_src == flow_pkt.eth_src assert identities.dhcp_msg.eth_dst == flow_pkt.eth_dst assert identities.dhcp_msg.ip_src == flow_pkt.ip_src assert identities.dhcp_msg.ip_dst == flow_pkt.ip_dst assert identities.dhcp_msg.tp_src == flow_pkt.tp_src assert identities.dhcp_msg.tp_dst == flow_pkt.tp_dst assert identities.dhcp_msg.transaction_id == '0xabc5667f' assert identities.dhcp_msg.host_name == 'pc1' assert identities.dhcp_msg.message_type == 'DHCPREQUEST' #*** Server to Client DHCP ACK: #*** Set ingest time so we can check validity based on lease ingest_time = datetime.datetime.now() flow.ingest_packet(DPID1, INPORT2, pkts_dhcp.RAW[3], ingest_time) identities.harvest(pkts_dhcp.RAW[3], flow.packet) flow_pkt = flow.packet assert identities.dhcp_msg.dpid == DPID1 assert identities.dhcp_msg.in_port == INPORT2 assert identities.dhcp_msg.eth_src == flow_pkt.eth_src assert identities.dhcp_msg.eth_dst == flow_pkt.eth_dst assert identities.dhcp_msg.ip_src == flow_pkt.ip_src assert identities.dhcp_msg.ip_dst == flow_pkt.ip_dst assert identities.dhcp_msg.tp_src == flow_pkt.tp_src assert identities.dhcp_msg.tp_dst == flow_pkt.tp_dst assert identities.dhcp_msg.transaction_id == '0xabc5667f' assert identities.dhcp_msg.host_name == '' assert identities.dhcp_msg.ip_assigned == '10.1.0.1' assert identities.dhcp_msg.message_type == 'DHCPACK' assert identities.dhcp_msg.lease_time == 300 result_identity = identities.findbynode('pc1') logger.debug("result_identity=%s", result_identity) assert result_identity['mac_address'] == pkts_dhcp.ETH_SRC[2] assert result_identity['ip_address'] == '10.1.0.1'
def __init__(self, text=None, part2=False): # 1. Set the initial values self.part2 = part2 self.text = text self.policies = [] # 2. Process text (if any) if text is not None and len(text) > 0: for line in text: self.policies.append(policy.Policy(text=line))
def prereq(): with open('configure.json') as file: json_text = json.load(file) # If using existing policy, make sure policy exists before # creating the thing thing_name = json_text.get('thing_name', "") mac_addr = json_text.get('mac_addr', "") # Create a Thing thing_obj = thing.Thing(thing_name) if not thing_obj.create(): # Create a Certificate cert_obj = certs.Certificate() result = cert_obj.create() # Store certId cert_id = result['certificateId'] cert_id_filename = thing_name + '_cert_id.txt' cert_id_file = open(cert_id_filename, 'w') cert_id_file.write(cert_id) cert_id_file_path = os.path.abspath(cert_id_filename) os.chmod(cert_id_file_path, 0o664) cert_id_file.close() # Store cert_pem as file cert_pem = result['certificatePem'] cert_pem_filename = thing_name + '_cert.pem' cert_pem_file = open(cert_pem_filename, 'w') cert_pem_file.write(cert_pem) cert_pem_file_path = os.path.abspath(cert_pem_filename) os.chmod(cert_pem_file_path, 0o664) cert_pem_file.close() # Store private key PEM as file private_key_pem = result['keyPair']['PrivateKey'] private_key_pem_filename = thing_name + '_private_key.pem' private_key_pem_file = open(private_key_pem_filename, 'w') private_key_pem_file.write(private_key_pem) private_key_pem_file_path = os.path.abspath(private_key_pem_filename) os.chmod(private_key_pem_file_path, 0o664) private_key_pem_file.close() # Create thing policy policy_document_text = misc.create_policy_document_text(thing_name) if policy_document_text: policy_obj = policy.Policy(thing_name, policy_document_text) cert_policy_name = policy_obj.create() print('Creating Certificate Policy {}'.format(cert_policy_name)) # Attach the Policy to the Cert, Cert to thing cert_obj.attach_thing(thing_name) cert_obj.attach_policy(cert_policy_name)
def add_new_policy(self, wiera, policy_spec): # if policy_id not in self.policies: wiera_id = policy_spec['id'] if wiera_id in self.policies: return self.policies[wiera_id] new_policy = policy.Policy(wiera, policy_spec) new_policy_id = new_policy.get_policy_id() self.policies[new_policy_id] = new_policy return new_policy
def __init__(self): #Topics & Subs, Pubs lidarscan_topic = '/scan' drive_topic = '/drive' self.pol = pl.Policy() self.lidar_sub = rospy.Subscriber(lidarscan_topic, LaserScan, self.lidar_callback) self.drive_pub = rospy.Publisher(drive_topic, AckermannDriveStamped, queue_size=20)
def prereq(): with open('configure.json') as configure_file: json_text = json.load(configure_file) # Create a Thing thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) if not thing_obj.create(): # Create a Certificate cert_obj = certs.Certificate() result = cert_obj.create() # Store certId cert_id = result['certificateId'] cert_id_filename = thing_name + '_cert_id_file.txt' cert_id_file = open(cert_id_filename, 'w') cert_id_file.write(cert_id) cert_id_file_path = os.path.abspath(cert_id_filename) os.chmod(cert_id_file_path, 0o444) cert_id_file.close() # Store cert_pem as file cert_pem = result['certificatePem'] cert_pem_filename = thing_name + '_cert_pem_file.pem' cert_pem_file = open(cert_pem_filename, 'w') cert_pem_file.write(cert_pem) cert_pem_file_path = os.path.abspath(cert_pem_filename) os.chmod(cert_pem_file_path, 0o444) cert_pem_file.close() # Store private key PEM as file private_key_pem = result['keyPair']['PrivateKey'] private_key_pem_filename = thing_name + '_private_key_pem_file.pem' private_key_pem_file = open(private_key_pem_filename, 'w') private_key_pem_file.write(private_key_pem) private_key_pem_file_path = os.path.abspath(private_key_pem_filename) os.chmod(private_key_pem_file_path, 0o444) private_key_pem_file.close() # Create a Policy policy_document = misc.create_policy_document() policy_name = thing_name + '_amazon_freertos_policy' policy_obj = policy.Policy(policy_name, policy_document) policy_obj.create() # Attach certificate to Thing cert_obj.attach_thing(thing_name) # Attach policy to certificate cert_obj.attach_policy(policy_name)
def test_get_classification(): """ Test get_classification which takes a flow_hash and return a dictionary of a classification object for the flow_hash (if found), otherwise a dictionary of an empty classification object. """ #*** Instantiate flow, policy and identities objects: flow = flows_module.Flow(config) policy = policy_module.Policy(config) ident = identities_module.Identities(config, policy) #*** Initial main_policy that matches tcp-80: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static_3.yaml") #*** Ingest Flow 1 Packet 0 (Client TCP SYN): flow.ingest_packet(DPID1, INPORT1, pkts.RAW[0], datetime.datetime.now()) #*** Classify the packet: policy.check_policy(flow, ident) logger.debug("pkt0 flow classification is %s", flow.classification.dbdict()) #*** Write classification result to classifications collection: flow.classification.commit() #*** Retrieve classification via get_classification and check results: clasfn_result = api.get_classification(flow.classification.flow_hash) assert clasfn_result['classified'] == 1 assert clasfn_result[ 'classification_tag'] == "Constrained Bandwidth Traffic" assert clasfn_result['actions'][ 'set_desc'] == "Constrained Bandwidth Traffic" assert clasfn_result['actions']['qos_treatment'] == "constrained_bw"
def __init__(self, name, x, y, n, edge_proximity, gamma, hpolicy, mpolicy, frequencies_dict): '''Defines an agent, which represents a node in the city-level infection network. :param str name: name of the city :param int x: width :param int y: height :param int n: num agents in city :param float edge_proximity: edge proximity (proxy for infectivity) :param float gamma: experimental gamma denominator :param str hpolicy: health policy name :param list[str, dict] mpolicy: movement policy name :param dict frequencies_dict: dictionary of special point frequencies ''' self.POLICIES = None self.gamma = gamma # gamma naught for covid 19 self.num_infected = 0 self.num_removed = 0 self.num_susceptible = 0 self.num_quarantined = 0 self.N = n self.name = name self.width = x self.height = y self.datafile = '{}x{}x{}parameter_sweep_data.txt'.format( self.width, self.height, self.N) self.area = self.width * self.height self.agents_per_market = frequencies_dict['market'] self.agents_per_transit = frequencies_dict['transit'] self.agents_per_work = frequencies_dict['work'] self.agents_per_home = frequencies_dict['home'] self.past_networks = [] self.network = None self.edge_proximity = edge_proximity # proxy for infectivity self.policy = policy.Policy(hpolicy, mpolicy) self.agents = [Agent(i, self) for i in range(0, self.N)] self.quarantine_center_location = None self.quarantine_threshold = 4 self.quarantine_rate = 0.05 self.setup_agent_central_locations() self.agent_dict = {v.number: v for v in self.agents}
def prereq(): with open('configure.json') as file: json_text = json.load(file) aws_config = json_text["aws_config"] optiga_config = json_text["optiga_trust_config"] # Create a Certificate cert_obj = certs.Certificate() result = cert_obj.create(optiga_config['executable_path'], optiga_config['i2c_device'], optiga_config['privatekey_objectid'], optiga_config['certificate_objectid']) # Create a Thing if doesn't exist thing_name = aws_config['thing_name'] thing_obj = thing.Thing(thing_name) if not thing_obj.exists(): thing_obj.create() # Store certId cert_id = result['certificateId'] cert_id_filename = thing_name + '_cert_id_file' cert_id_file = open(cert_id_filename, 'w') cert_id_file.write(cert_id) cert_id_file_path = os.path.abspath(cert_id_filename) os.chmod(cert_id_file_path, 0o444) cert_id_file.close() # Store cert_pem as file cert_pem = result['certificatePem'] cert_pem_filename = thing_name + '_cert_pem_file' cert_pem_file = open(cert_pem_filename, 'w') cert_pem_file.write(cert_pem) cert_pem_file_path = os.path.abspath(cert_pem_filename) os.chmod(cert_pem_file_path, 0o444) cert_pem_file.close() # Create a Policy if doesn't exist policy_obj = policy.Policy(aws_config['policy_name']) if not policy_obj.exists(): policy_document = misc.create_policy_document() policy_obj.attach_rules(policy_document) policy_obj.create() # Attach certificate to Thing cert_obj.attach_thing(aws_config['thing_name']) # Attach policy to certificate cert_obj.attach_policy(aws_config['policy_name'])
def test_custom_classifiers(): """ Check deduplicated list of custom classifiers works """ #*** Instantiate policy, specifying #*** a particular main_policy file to use that has no custom classifiers: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static.yaml") assert policy.tc_rules.custom_classifiers == [] #*** Instantiate policy, specifying #*** a custom statistical main_policy file to use that has a #*** custom classifier: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_statistical.yaml") assert policy.tc_rules.custom_classifiers == [ 'statistical_qos_bandwidth_1' ]
def setup(): with open('configure.json') as file: json_text = json.load(file) # Create a Thing thing_name = json_text['thing_name'] thing_obj = thing.Thing(thing_name) if not thing_obj.create(): # Create a Certificate cert_obj = certs.Certificate() result = cert_obj.create() # Store cert_pem cert_pem = result['certificatePem'] # Store Private key PEM private_key_pem = result['keyPair']['PrivateKey'] wifi_ssid = json_text['wifi_ssid'] wifi_passwd = json_text['wifi_password'] wifi_security = json_text['wifi_security'] # Modify 'aws_clientcredential.h' file misc.client_credential( wifi_ssid = wifi_ssid, wifi_passwd = wifi_passwd, wifi_security = wifi_security, thing_name = thing_name, credentials_or_keys = "client_credential") # Modify 'aws_clientcredential_keys.h' file misc.client_credential( client_certificate_pem = cert_pem, clientprivate_key_pem = private_key_pem, credentials_or_keys = "client_keys") # Create a Policy policy_document = misc.create_policy_document() policy_name = thing_name + '_amazon_freertos_policy' policy_obj = policy.Policy(policy_name, policy_document) policy_obj.create() # Attach certificate to Thing cert_obj.attach_thing(thing_name) # Attach policy to certificate cert_obj.attach_policy(policy_name)
def test_harvest_LLDP(): """ Test harvesting identity metadata from LLDP packets """ #*** Instantiate flow, policy and identities objects: flow = flows_module.Flow(config) policy = policy_module.Policy(config) identities = identities_module.Identities(config, policy) #*** Test no result found by checking before LLDP ingestion: result_identity = identities.findbynode(pkts_lldp.LLDP_SYSTEM_NAME[0]) assert result_identity == 0 #*** LLDP packet 0: flow.ingest_packet(DPID1, INPORT1, pkts_lldp.RAW[0], datetime.datetime.now()) identities.harvest(pkts_lldp.RAW[0], flow.packet) result_identity = identities.findbynode(pkts_lldp.LLDP_SYSTEM_NAME[0]) assert result_identity['host_name'] == pkts_lldp.LLDP_SYSTEM_NAME[0] assert result_identity['host_desc'] == pkts_lldp.LLDP_SYSTEM_DESC[0] assert result_identity['dpid'] == DPID1 assert result_identity['in_port'] == INPORT1 assert result_identity['mac_address'] == pkts_lldp.ETH_SRC[0] assert result_identity['harvest_type'] == 'LLDP' #*** LLDP packet 1: flow.ingest_packet(DPID1, INPORT1, pkts_lldp.RAW[1], datetime.datetime.now()) identities.harvest(pkts_lldp.RAW[1], flow.packet) result_identity = identities.findbynode(pkts_lldp.LLDP_SYSTEM_NAME[1]) assert result_identity['host_name'] == pkts_lldp.LLDP_SYSTEM_NAME[1] assert result_identity['host_desc'] == pkts_lldp.LLDP_SYSTEM_DESC[1] assert result_identity['dpid'] == DPID1 assert result_identity['in_port'] == INPORT1 assert result_identity['mac_address'] == pkts_lldp.ETH_SRC[1] assert result_identity['harvest_type'] == 'LLDP' #*** LLDP packet 2: flow.ingest_packet(DPID1, INPORT1, pkts_lldp.RAW[2], datetime.datetime.now()) identities.harvest(pkts_lldp.RAW[2], flow.packet) result_identity = identities.findbynode(pkts_lldp.LLDP_SYSTEM_NAME[2]) assert result_identity['host_name'] == pkts_lldp.LLDP_SYSTEM_NAME[2] assert result_identity['host_desc'] == pkts_lldp.LLDP_SYSTEM_DESC[2] assert result_identity['dpid'] == DPID1 assert result_identity['in_port'] == INPORT1 assert result_identity['mac_address'] == pkts_lldp.ETH_SRC[2] assert result_identity['harvest_type'] == 'LLDP'
def test_qos(): """ Test the assignment of QoS queues based on a qos_treatment action """ #*** Instantiate policy, specifying #*** a particular main_policy file to use that has no custom classifiers: policy = policy_module.Policy( config, pol_dir_default="config/tests/regression", pol_dir_user="******", pol_filename="main_policy_regression_static.yaml") assert policy.qos('default_priority') == 0 assert policy.qos('constrained_bw') == 1 assert policy.qos('high_priority') == 2 assert policy.qos('low_priority') == 3 assert policy.qos('foo') == 0
def optimal_control_es(mdp, start, gamma, episode_length, iterations): p = policy.Policy() for i in range(iterations): # Need to completly Randomize the Initial State action of the trajectory exploring_act0 = int(random.uniform(0, mdp.A - 1)) next_state0 = mdp.next_state(start, exploring_act0) exploring_act1 = int(random.uniform(0, mdp.A - 1)) next_state1 = mdp.next_state(start, exploring_act1) episode, rewards, actions = get_episode(mdp, next_state1, episode_length, p) episode = [start, next_state0] + episode rewards = [ mdp.next_reward(start, exploring_act0), mdp.next_reward(next_state0, exploring_act1) ] + rewards actions = [exploring_act0, exploring_act1] + actions Q = dict() G = 0 #print(str(episode) + " " + str(actions)) print(str(i) + "...") def contains(l, a): for i in l: if a == i: return True return False state_actions = list(zip(episode, actions)) for i in reversed(range(1, len(state_actions))): G = gamma * G + rewards[i] if not contains(state_actions[:i - 1], (episode[i], actions[i])): Q[(episode[i], actions[i])] = (Q[(episode[i], actions[i])][0] + G, Q[(episode[i], actions[i])][1] + 1) if (episode[i], actions[i]) in Q else (G, 1) rewards_action = [] for a in range(mdp.A): if (episode[i], a) in Q: rewards_action.append(Q[(episode[i], a)][0] / Q[(episode[i], a)][1]) else: rewards_action.append(0) p.update(episode[i], rewards_action.index(max(rewards_action))) return p
def test_get_dns_ip(): """ Test looking up a DNS CNAME to get an IP address """ #*** Instantiate flow, policy and identities objects: flow = flows_module.Flow(config) policy = policy_module.Policy(config) identities = identities_module.Identities(config, policy) #*** DNS packet 1 (NAME to CNAME, then second answer with IP for CNAME): flow.ingest_packet(DPID1, INPORT1, pkts_dns.RAW[1], datetime.datetime.now()) identities.harvest(pkts_dns.RAW[1], flow.packet) logger.debug("Testing lookup of CNAME=%s", pkts_dns.DNS_CNAME[1]) result_ip = api.get_dns_ip(pkts_dns.DNS_CNAME[1]) assert result_ip == pkts_dns.DNS_IP[1]