def main():
args = parse_args()
metrics.reset()
start_time = time.time()
logging.basicConfig(level=logging.INFO)
# Create a SimPy environment
env = simpy.Environment()
# Seed the random generator
random.seed(args.seed)
numpy.random.seed(args.seed)
# Parse network and get NetworkX object and ingress network list
network, ing_nodes = reader.read_network(args.network,
node_cap=10,
link_cap=10)
# Getting current SFC list, and the SF list of each SFC, and config
# use dummy placement and schedule for running simulator without algorithm
# TODO: make configurable via CLI
sf_placement = dummy_data.triangle_placement
schedule = dummy_data.triangle_schedule
# Getting current SFC list, and the SF list of each SFC, and config
sfc_list = reader.get_sfc(args.sf)
sf_list = reader.get_sf(args.sf, args.sfr)
config = reader.get_config(args.config)
# Create the simulator parameters object with the provided args
params = SimulatorParams(network,
ing_nodes,
sfc_list,
sf_list,
config,
args.seed,
sf_placement=sf_placement,
schedule=schedule)
log.info(params)
if args.trace:
trace = reader.get_trace(args.trace)
TraceProcessor(params, env, trace)
# Create a FlowSimulator object, pass the SimPy environment and params objects
simulator = FlowSimulator(env, params)
# Start the simulation
simulator.start()
# Run the simpy environment for the specified duration
env.run(until=args.duration)
# Record endtime and running_time metrics
end_time = time.time()
metrics.running_time(start_time, end_time)
# dump all metrics
log.info(metrics.metrics)
def setUp(self):
"""
Setup test environment
"""
logging.basicConfig(level=logging.ERROR)
self.env = simpy.Environment()
# Configure simulator parameters
network, ing_nodes, eg_nodes = reader.read_network(NETWORK_FILE,
node_cap=10,
link_cap=10)
sfc_list = reader.get_sfc(SERVICE_FUNCTIONS_FILE)
sf_list = reader.get_sf(SERVICE_FUNCTIONS_FILE, RESOURCE_FUNCTION_PATH)
config = reader.get_config(CONFIG_FILE)
self.metrics = Metrics(network, sf_list)
sf_placement = dummy_data.triangle_placement
schedule = dummy_data.triangle_schedule
# Initialize Simulator and SimulatoParams objects
self.simulator_params = SimulatorParams(log,
network,
ing_nodes,
eg_nodes,
sfc_list,
sf_list,
config,
self.metrics,
sf_placement=sf_placement,
schedule=schedule)
self.flow_simulator = FlowSimulator(self.env, self.simulator_params)
self.flow_simulator.start()
self.env.run(until=SIMULATION_DURATION)
def __init__(self,
agent_config,
simulator,
network_file,
service_file,
service_requirement_file,
seed=None,
sim_seed=None):
self.network_file = network_file
self.agent_config = agent_config
self.simulator = simulator
self.sim_seed = sim_seed
self.simulator_wrapper = None
self.current_simulator_state = None
self.last_succ_flow = 0
self.last_drop_flow = 0
self.last_gen_flow = 0
self.run_count = 0
self.np_random = np.random.RandomState()
self.seed(seed)
self.network, _, _ = read_network(self.network_file)
self.network_diameter = network_diameter(self.network)
self.sfc_list = get_sfc(service_file)
self.sf_list = get_sf(service_file)
self.service_requirement = get_sfc_requirement(
service_requirement_file)
# logger.info('service_requirement: ' + str(self.service_requirement))
self.env_limits = EnvironmentLimits(
len(self.network.nodes), self.sfc_list,
len(agent_config['observation_space']))
self.min_delay, self.max_delay = self.min_max_delay()
self.action_space = self.env_limits.action_space
self.observation_space = self.env_limits.observation_space
# logger.info('Observation space: ' + str(self.agent_config['observation_space']))
# order of permutation for shuffling state
self.permutation = None
# related to objective/reward
self.objective = self.agent_config['objective']
self.target_success = self.agent_config['target_success']
self.soft_deadline = self.agent_config['soft_deadline']
# start at the best case with the moving average to encourage high standards!
self.ewma_flows = 1
def __init__(self, network_file, service_functions_file, config_file, resource_functions_path="", test_mode=False,
test_dir=None):
super().__init__(test_mode)
# Number of time the simulator has run. Necessary to correctly calculate env run time of apply function
self.network_file = network_file
self.test_dir = test_dir
# init network, sfc, sf, and config files
self.network, self.ing_nodes, self.eg_nodes = reader.read_network(self.network_file)
self.sfc_list = reader.get_sfc(service_functions_file)
self.sf_list = reader.get_sf(service_functions_file, resource_functions_path)
self.config = reader.get_config(config_file)
self.metrics = Metrics(self.network, self.sf_list)
# Assume result path is the path where network file is in.
self.result_base_path = os.path.dirname(self.network_file)
if 'trace_path' in self.config:
# Quick solution to copy trace file to same path for network file as provided by calling algo.
trace_path = os.path.join(os.getcwd(), self.config['trace_path'])
copyfile(trace_path, os.path.join(self.result_base_path, os.path.basename(trace_path)))
self.prediction = False
# Check if future ingress traffic setting is enabled
if 'future_traffic' in self.config and self.config['future_traffic']:
self.prediction = True
self.params = SimulatorParams(logger, self.network, self.ing_nodes, self.eg_nodes, self.sfc_list, self.sf_list,
self.config, self.metrics, prediction=self.prediction)
write_schedule = False
if 'write_schedule' in self.config and self.config['write_schedule']:
write_schedule = True
write_flow_actions = False
if 'write_flow_actions' in self.config and self.config['write_flow_actions']:
write_flow_actions = True
# Create CSV writer
self.writer = ResultWriter(self.test_mode, self.test_dir, write_schedule, write_flow_actions)
self.params.writer = self.writer
self.episode = 0
self.params.episode = 0
self.last_apply_time = None
# Load trace file
if 'trace_path' in self.config:
trace_path = os.path.join(os.getcwd(), self.config['trace_path'])
self.trace = reader.get_trace(trace_path)
self.lstm_predictor = None
if 'lstm_prediction' in self.config and self.config['lstm_prediction']:
self.lstm_predictor = LSTM_Predictor(self.trace, params=self.params,
weights_dir=self.config['lstm_weights'])
def __init__(self,
network_file,
service_functions_file,
config_file,
resource_functions_path="",
test_mode=False,
test_dir=None):
# Number of time the simulator has run. Necessary to correctly calculate env run time of apply function
self.run_times = int(1)
self.network_file = network_file
self.test_mode = test_mode
self.test_dir = test_dir
# Create CSV writer
self.writer = ResultWriter(self.test_mode, self.test_dir)
# init network, sfc, sf, and config files
self.network, self.ing_nodes = reader.read_network(self.network_file,
node_cap=10,
link_cap=10)
self.sfc_list = reader.get_sfc(service_functions_file)
self.sf_list = reader.get_sf(service_functions_file,
resource_functions_path)
self.config = reader.get_config(config_file)
def init(self,
network_file,
service_functions_file,
config_file,
seed,
trace=None,
resource_functions_path=""):
# Initialize metrics, record start time
metrics.reset()
self.run_times = int(1)
self.start_time = time.time()
# Parse network and SFC + SF file
self.network, self.ing_nodes = reader.read_network(network_file,
node_cap=10,
link_cap=10)
self.sfc_list = reader.get_sfc(service_functions_file)
self.sf_list = reader.get_sf(service_functions_file,
resource_functions_path)
self.config = reader.get_config(config_file)
# Generate SimPy simulation environment
self.env = simpy.Environment()
# Instantiate the parameter object for the simulator.
self.params = SimulatorParams(self.network, self.ing_nodes,
self.sfc_list, self.sf_list, self.config,
seed)
# Trace handling
if trace:
trace = reader.get_trace(trace)
TraceProcessor(self.params, self.env, trace)
self.duration = self.params.run_duration
# Get and plant random seed
self.seed = seed
random.seed(self.seed)
numpy.random.seed(self.seed)
# Instantiate a simulator object, pass the environment and params
self.simulator = FlowSimulator(self.env, self.params)
# Start the simulator
self.simulator.start()
# Run the environment for one step to get initial stats.
self.env.step()
# Parse the NetworkX object into a dict format specified in SimulatorState. This is done to account
# for changing node remaining capacities.
# Also, parse the network stats and prepare it in SimulatorState format.
self.parse_network()
self.network_metrics()
# Record end time and running time metrics
self.end_time = time.time()
metrics.running_time(self.start_time, self.end_time)
simulator_state = SimulatorState(self.network_dict,
self.simulator.params.sf_placement,
self.sfc_list, self.sf_list,
self.traffic, self.network_stats)
# self.writer.write_state_results(self.env, simulator_state)
return simulator_state
def __init__(self, agent_config, network_file, service_file,
user_trace_file, ingress_distribution_file,
service_requirement_file, container_client_file,
container_server_file, container_lb_file, log_metrics_dir):
"""
Pass the configure file
Test if the container is working fine!?
"""
self.log_metrics_dir = log_metrics_dir
self.ingress_distribution_file = ingress_distribution_file
self.container_client_file = container_client_file
self.container_server_file = container_server_file
self.container_lb_file = container_lb_file
self.ingress_distribution = get_docker_services(
self.ingress_distribution_file)
self.network_file = network_file
self.agent_config = agent_config
self.user_trace_file = user_trace_file
self.service_requirement = get_sfc_requirement(
service_requirement_file)
#TODO: read csv file to list of arrays
# self.trace =
# self.np_random = np.random.RandomState()
# self.seed(seed)
self.network, _, _ = read_network(self.network_file)
self.network_diameter = network_diameter(self.network)
self.sfc_list = get_sfc(service_file)
self.sf_list = get_sf(service_file)
# # logger.info('service_requirement: ' + str(self.service_requirement))
self.env_limits = EnvironmentLimits(
len(self.network.nodes), self.sfc_list,
len(agent_config['observation_space']))
# self.min_delay, self.max_delay = self.min_max_delay()
self.action_space = self.env_limits.action_space
self.observation_space = self.env_limits.observation_space
# # logger.info('Observation space: ' + str(self.agent_config['observation_space']))
# # order of permutation for shuffling state
# self.permutation = None
# # related to objective/reward
self.objective = self.agent_config['objective']
self.episode_count = -1
self.dockerHelper = DockerHelper(
user_trace_file,
ingress_distribution_file_path=ingress_distribution_file,
docker_client_services_path=container_client_file,
docker_lb_container_path=container_lb_file,
service_list=list(self.sfc_list.keys()))
self.captureHelper = CaptureHelper(
docker_client_services_path=container_client_file,
docker_server_services_path=container_server_file,
ingress_distribution_file_path=ingress_distribution_file,
docker_lb_container_path=container_lb_file,
service_list=list(self.sfc_list.keys()))
logger.info(f"service_list: {list(self.sfc_list.keys())}")
logger.info(
"---------------------------------------------------------------------------------"
)
self.ingress_node = ["node3", "node2"]
self.info = dict()
