diff --git a/clmctest/monitoring/StreamingSim.py b/clmctest/monitoring/StreamingSim.py
index a7d8d9ce3aa74c4ec5e8be46dd64e36d704e9c85..d0b97f4178da058d1d8ec9c532fc094e75ba21be 100644
--- a/clmctest/monitoring/StreamingSim.py
+++ b/clmctest/monitoring/StreamingSim.py
@@ -77,10 +77,6 @@ class Sim(object):
# endpoint state->mu, sigma, secs normal distribution
config_delay_dist = {"placing": [10, 0.68], "booting": [10, 0.68], "connecting": [10, 0.68]}
- # Simulation configuration of the media component (MC) state changes
- # "MC state", [average (sec), stddev]
- mc_config_delay_dist = { "stopped":[1, 0.68], "starting": [5, 0.68], "running":[1, 0.68], "stopping": [2, 0.68]}
-
print("\nSimulation started. Generating data...")
# Place endpoints
@@ -105,31 +101,27 @@ class Sim(object):
max_delay = max(delay_time, max_delay)
sim_time += max_delay
- # move mpegdash_service media component state from 'stopped' to 'starting'
- max_delay = 0
+ # move mpegdash_service media component state from 'stopped' to 'starting'
+ # Total reports = 1, (0.2 seconds in 'stopped', 0.8 seconds in 'starting')
for ip_endpoint in ip_endpoints:
- agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
- agent_db_client = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- delay_avg = mc_config_delay_dist['stopped'][0]
- delay_std = delay_avg * mc_config_delay_dist['stopped'][1]
-
- delay_time = self._changeMCState(agent_db_client, sim_time, "mpegdash_service_config", delay_avg, delay_std, 0.7, 'stopped', 'starting')
- max_delay = max(delay_time, max_delay)
-
- sim_time += max_delay
+ agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
+ influxClient = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
+ self._changeMCState( influxClient, sim_time, 'mpegdash_service_config', 10, 2, 'stopped', 'starting' )
+
+ sim_time += TICK_TIME
# move mpegdash_service media component state from 'starting' to 'running'
- max_delay = 0
+ # Total reports = 5, (4.7 seconds in 'starting', 0.3 seconds in 'running')
for ip_endpoint in ip_endpoints:
- agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
- agent_db_client = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- delay_avg = mc_config_delay_dist['starting'][0]
- delay_std = delay_avg * mc_config_delay_dist['starting'][1]
-
- delay_time = self._changeMCState(agent_db_client, sim_time, "mpegdash_service_config", delay_avg, delay_std, 0.7, 'starting', 'running')
- max_delay = max(delay_time, max_delay)
+ agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
+ influxClient = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- sim_time += max_delay
+ for i in range( 0, 4 ):
+ self._writeMCSingleState( influxClient, 'mpegdash_service_config', 'starting', sim_time + (i * TICK_TIME) )
+
+ self._changeMCState( influxClient, sim_time + (4 * TICK_TIME), 'mpegdash_service_config', 10, 7, 'starting', 'running' )
+
+ sim_time += 5 * TICK_TIME
# Connect endpoints
max_delay = 0
@@ -207,39 +199,30 @@ class Sim(object):
ip_endpoint['request_queue'] -= int(requests_processed)
# update mpegdash_service media component state (continuously 'running')
- state_stats = {}
- state_stats['running'] = float(TICK_TIME)
- state_stats['avg_running'] = float(TICK_TIME)
- agent_db_client.write_points(lp.generate_mc_service_config("mpegdash_service_config",state_stats,sim_time))
+ self._writeMCSingleState( agent_db_client, 'mpegdash_service_config', 'running', sim_time )
sim_time += TICK_TIME
# Simulate tear-down of media components
# move mpegdash_service media component state from 'running' to 'stopping'
- max_delay = 0
+ # Total reports = 2, (1.8 seconds in 'running', 0.2 seconds in 'stopping')
for ip_endpoint in ip_endpoints:
- agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
- agent_db_client = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- delay_avg = mc_config_delay_dist['running'][0]
- delay_std = delay_avg * mc_config_delay_dist['running'][1]
+ agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
+ influxClient = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- delay_time = self._changeMCState(agent_db_client, sim_time, "mpegdash_service_config", delay_avg, delay_std, 0.7, 'running', 'stopping')
- max_delay = max(delay_time, max_delay)
-
- sim_time += max_delay
+ self._writeMCSingleState( influxClient, 'mpegdash_service_config', 'running', sim_time )
+ self._changeMCState( influxClient, sim_time + TICK_TIME, 'mpegdash_service_config', 10, 8, 'running', 'stopping' )
+
+ sim_time += 2 * TICK_TIME
# move mpegdash_service media component state from 'stopping' to 'stopped'
- max_delay = 0
+ # Total reports = 1, (0.9 seconds in 'stopping', 0.1 seconds in 'stopped')
for ip_endpoint in ip_endpoints:
- agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
- agent_db_client = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
- delay_avg = mc_config_delay_dist['stopping'][0]
- delay_std = delay_avg * mc_config_delay_dist['stopping'][1]
-
- delay_time = self._changeMCState(agent_db_client, sim_time, "mpegdash_service_config", delay_avg, delay_std, 0.7, 'stopping', 'stopped')
- max_delay = max(delay_time, max_delay)
-
- sim_time += max_delay
+ agent_url = urllib.parse.urlparse(ip_endpoint["agent_url"])
+ influxClient = InfluxDBClient(host=agent_url.hostname, port=agent_url.port, database=self.influx_db_name, timeout=10)
+ self._changeMCState( influxClient, sim_time, 'mpegdash_service_config', 10, 9, 'stopping', 'stopped' )
+
+ sim_time += TICK_TIME
# End simulation
end_time = sim_time
@@ -291,31 +274,50 @@ class Sim(object):
return delay_time
@staticmethod
- def _changeMCState(agent_db_client, sim_time, mc_measurement, mu, sigma, trans_ratio, transition_state, next_state):
+ def _writeMCSingleState(influxClient, measurement, state, sim_time):
"""
- Send INFLUX data indicating the time taken to transition to a new state
+
+ Write a single state as a sample over TICK_TIME
+
+ : influxClient - agent used to send metric data to CLMC
+ : measurement - name of influx measurement set
+ : state - state to be declared
+ : sim_time - time stamp for this measurement
- Returns the total time delay for the state change
"""
- # Calculate a randomized total time for the transition (and calculate relative ratios of time in transition and next state)
- total_delay_time = max( random.normalvariate(mu, sigma), 1 ) # minimum total delay is 1 second
- transition_time = total_delay_time * trans_ratio
- next_state_time = total_delay_time - transition_time
+ state_stats = {}
+ state_stats[state] = float( TICK_TIME )
+ state_stats['avg_' +state] = float( TICK_TIME )
+ influxClient.write_points( lp.generate_mc_service_config(measurement,state_stats,sim_time) )
+
+
+ @staticmethod
+ def _changeMCState(influxClient, sim_time, mc_measurement, sample_count, trans_sample_count, transition_state, next_state):
+ """
+ Send INFLUX data indicating the time taken to transition to a new state
+
+ : influxClient - agent used to send metric data to CLMC
+ : sim_time - simulation time at start of state changing period
+ : mc_measurement - measurement name
+ : sample_count - the total number of samples in the reporting period (TICK_TIME)
+ : trans_sample_count - the number of samples in the transition state
+ : transition_state - the state being exited
+ : next_state - the state being entered
+
+ """
mc_states = {}
- # Report time in transition (and add the same as average)
- mc_states[transition_state] = transition_time
- mc_states["avg_" +transition_state] = transition_time
-
- # Report time remaining in the next state (adding the same as the average)
- mc_states[next_state] = next_state_time
- mc_states["avg_" +next_state] = next_state_time
+ # Report total time in transition and its average of the reporting period
+ mc_states[transition_state] = (float(TICK_TIME) / sample_count) * trans_sample_count
+ mc_states["avg_" +transition_state] = mc_states[transition_state] / float(TICK_TIME)
- agent_db_client.write_points(lp.generate_mc_service_config(mc_measurement, mc_states, sim_time))
+ # Use the time remaining as the length for the time in the next state
+ mc_states[next_state] = float(TICK_TIME) - mc_states[transition_state]
+ mc_states["avg_" +next_state] = mc_states[next_state] / float(TICK_TIME)
- return total_delay_time
+ influxClient.write_points(lp.generate_mc_service_config(mc_measurement, mc_states, sim_time))
def run_simulation(generate=True, sTime=3600):
diff --git a/clmctest/monitoring/test_simresults.py b/clmctest/monitoring/test_simresults.py
index a058d4d3ce28289f1606cf351068b781b5873bbd..0d2e2893eb3bd1ce24f50dfde7482d8414cf187f 100644
--- a/clmctest/monitoring/test_simresults.py
+++ b/clmctest/monitoring/test_simresults.py
@@ -36,20 +36,18 @@ class TestSimulation(object):
# Media component state tests
('SELECT count(*) FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE ipendpoint=\'adaptive_streaming_I1_apache1\'',
- {"time" : "1970-01-01T00:00:00Z", "count_avg_running" : 3604, "count_avg_starting" : 3604, "count_avg_stopped" : 3604, "count_avg_stopping" : 3604, "count_running" : 3604, "count_starting" : 3604, "count_stopped" : 3604, "count_stopping" : 3604}),
+ {"time" : "1970-01-01T00:00:00Z", "count_avg_running" : 3609, "count_avg_starting" : 3609, "count_avg_stopped" : 3609, "count_avg_stopping" : 3609, "count_running" : 3609, "count_starting" : 3609, "count_stopped" : 3609, "count_stopping" : 3609}),
('SELECT count(*) FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE ipendpoint=\'adaptive_streaming_I1_apache2\'',
- {"time" : "1970-01-01T00:00:00Z", "count_avg_running" : 3604, "count_avg_starting" : 3604, "count_avg_stopped" : 3604, "count_avg_stopping" : 3604, "count_running" : 3604, "count_starting" : 3604, "count_stopped" : 3604, "count_stopping" : 3604}),
+ {"time" : "1970-01-01T00:00:00Z", "count_avg_running" : 3609, "count_avg_starting" : 3609, "count_avg_stopped" : 3609, "count_avg_stopping" : 3609, "count_running" : 3609, "count_starting" : 3609, "count_stopped" : 3609, "count_stopping" : 3609}),
('SELECT mean(avg_stopped) as "avg_stopped" FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE avg_stopped <>0',
- {"time" : "1970-01-01T00:00:00Z", "avg_stopped" : 0.9311386970408875}),
+ {"time" : "1970-01-01T00:00:00Z", "avg_stopped" : 0.15}),
('SELECT mean(avg_starting) as "avg_starting" FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE avg_starting <>0',
- {"time" : "1970-01-01T00:00:00Z", "avg_starting" : 1.4332962039049266}),
+ {"time" : "1970-01-01T00:00:00Z", "avg_starting" : 0.9166666666666666}),
('SELECT mean(avg_running) as "avg_running" FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE avg_running <>0',
- {"time" : "1970-01-01T00:00:00Z", "avg_running" : 0.9999273119631822}),
+ {"time" : "1970-01-01T00:00:00Z", "avg_running" : 0.9997502081598669}),
('SELECT mean(avg_stopping) as "avg_stopping" FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE avg_stopping <>0',
- {"time" : "1970-01-01T00:00:00Z", "avg_stopping" : 1.1135062967253757}),
- ('SELECT mean(avg_stopped) as "avg_stopped" FROM "CLMCMetrics"."autogen"."mpegdash_service_config" WHERE avg_stopped <>0',
- {"time" : "1970-01-01T00:00:00Z", "avg_stopped" : 0.9311386970408875})
+ {"time" : "1970-01-01T00:00:00Z", "avg_stopping" : 0.55})
])
def test_simulation( self, run_simulator, influx_db, query, expected_result ):