def _prepare_monitor_proxy(self):
monitor_thread = ProvisionMonitor()
monitor_thread.start()
cloud_api = get_cloud_api(self.config)
args = InstancePatitioner().get_proxy_parameter('provision_proxy')
flavor_ids = args['flavor_ids']
image_ids = args['image_ids']
volume_ids = args['volume_ids']
nec_ids = args['net_ids']
meta_list = args['meta']
files = args['files']
name = args['name']
ProvisionProxyMonitorData()._set_key(args['meta']['key'])
start_time = time.time()
if image_ids and len(image_ids) > 0 and flavor_ids and len(
flavor_ids) > 0:
proxy_instance = cloud_api.run_instance(name, image_ids[0],
flavor_ids[0], nec_ids,
meta_list, files)
if not proxy_instance:
monitor_thread.terminate_monitor()
return None, None
while not cloud_api.is_instance_running(proxy_instance.id):
time.sleep(5)
print 'building proxy instance: %f s' % (time.time() - start_time)
build_time = time.time() - float(start_time)
network = neutron_provision(self.config)
ip_info = network.associate_proxy_ip(proxy_instance.id)
print "proxy self.proxy_instance.id-- public ip: %s, private ip: %s" % (
ip_info['floatingip']['fixed_ip_address'],
ip_info['floatingip']['floating_ip_address'])
InstancePatitioner().set_proxy_ip(
ip_info['floatingip']['fixed_ip_address'])
ProvisionProxyMonitorData()._set_pub_priv_ip(
ip_info['floatingip']['floating_ip_address'],
ip_info['floatingip']['fixed_ip_address'])
while not ProvisionProxyMonitorData().connected_with_proxy:
print '%f waiting for proxy http connect' % (time.time() -
start_time)
sleep(5)
print "proxy VM build time %f s, boot time:%f s" % (build_time,
(time.time() -
start_time))
print ProvisionProxyMonitorData()._get_info()
return monitor_thread, proxy_instance
def __init__(self):
threading.Thread.__init__(self)
self.instance_metric = ProvisionInstanceMetric()
self.terminate_flag = 0
self.metaConfigure = MetaConfigure()
self.host_ip = self.metaConfigure._get_provision_host_ip() or '0.0.0.0'
self.host_port = self.metaConfigure._get_provision_host_port() or 8675
self.proxy_port = self.metaConfigure._get_proxy_port() or 8821
self.report_online = self.metaConfigure._is_report_online()
self.self_stopped = False
self.httpd = make_server('', self.host_port,
self.provision_monitor_app)
self.httpd.timeout = self.metaConfigure._get_http_timeout()
self.proxy_data = ProvisionProxyMonitorData(host_port=self.host_port)
def __init__(self):
threading.Thread.__init__(self)
self.instance_metric = ProvisionInstanceMetric()
self.terminate_flag = 0
self.metaConfigure = MetaConfigure()
self.host_ip = self.metaConfigure._get_provision_host_ip() or '0.0.0.0'
self.host_port = self.metaConfigure._get_provision_host_port() or 8675
self.proxy_port = self.metaConfigure._get_proxy_port() or 8821
self.report_online =self.metaConfigure._is_report_online()
self.self_stopped = False
self.httpd = make_server('', self.host_port, self.provision_monitor_app)
self.httpd.timeout = self.metaConfigure._get_http_timeout()
self.proxy_data = ProvisionProxyMonitorData(host_port = self.host_port)
def start_workload(self):
''' a serial of concurrency client behaviors
'''
monitor, proxy_instance = self._prepare_monitor_proxy()
if not proxy_instance:
print 'error while creating proxy instance...please check it'
return
reporter = ProvisionReporter(self.config)
reporter.start_reporter()
instanceGC = InstanceGC(self.config)
instanceGC.start()
clientGC = ClientGC(self.config)
clientGC.startGC()
client_queue = clientGC.get_client_queue()
instanceManager = InstanceManager(self.config)
instanceManager.start()
instance_queue = instanceManager.get_instance_queue()
begin_time = time.time()
if self.config.client_generate == "fixed":
#for i in range(self.config.client_number):
# pth = self.new_provision(client_iter, timeout)
# pth.start()
# thread_list.append(gth)
print 'not implement yet'
pass
else:
timeout = self.timeout
client_iter = 0
while (timeout > 0 and client_iter < self.config.client_number):
pth = self.new_provision(client_iter, timeout, instance_queue)
pth.start()
client_queue.put(pth)
#thread_list.append(pth)
client_iter += 1
sleep(self.config.client_interval)
timeout -= self.config.client_interval
clientGC.joinGC()
print "provision threads have terminated"
instanceManager.terminateIM()
print "instance mannage thread has terminate"
instanceGC.join()
print "instance GC thread has terminate"
reporter.terminate_reporter()
print "reporter thread has terminated"
monitor.terminate_monitor()
print "monitor thread has terminated"
total_time = time.time() - begin_time
print "total time: %d" % total_time
mtable = ProvisionInstanceMetric()._pretty_metric()
print mtable
filename = 'seq' + str(self.config.client_interval) + '_num' + str(
self.config.client_number) + '_life' + str(
self.config.min_lifetime) + ':' + str(
self.config.max_lifetime) + '_provision.res'
with open(filename, 'w') as f:
f.write(str(mtable))
f.close()
ip = ProvisionProxyMonitorData()._get_info()['pub']
proxy_instance.remove_floating_ip(ip)
proxy_instance.delete()
class ProvisionMonitor(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.instance_metric = ProvisionInstanceMetric()
self.terminate_flag = 0
self.metaConfigure = MetaConfigure()
self.host_ip = self.metaConfigure._get_provision_host_ip() or '0.0.0.0'
self.host_port = self.metaConfigure._get_provision_host_port() or 8675
self.proxy_port = self.metaConfigure._get_proxy_port() or 8821
self.report_online = self.metaConfigure._is_report_online()
self.self_stopped = False
self.httpd = make_server('', self.host_port,
self.provision_monitor_app)
self.httpd.timeout = self.metaConfigure._get_http_timeout()
self.proxy_data = ProvisionProxyMonitorData(host_port=self.host_port)
def terminate_monitor(self):
self.self_stopped = True
self.join()
def run(self):
self.serve()
def serve(self):
print "Serving on port %d..." % self.host_port
while not self.self_stopped:
self.httpd.handle_request()
if self.metaConfigure._is_debug():
print 'handle one request or timeout ...'
print "Stop monitor server..."
#self.httpd.serve_forever()
def provision_monitor_app(self, environ, start_response):
print 'one request coming'
status = '200 OK' # HTTP Status
headers = [('Content-type', 'text/plain')] # HTTP Headers
start_response(status, headers)
proxy_req = urlparse.parse_qs(environ['QUERY_STRING'])
print proxy_req.keys()
if 'VMType' in proxy_req.keys():
if proxy_req['VMType'] == ['proxy'
] and 'PublicIP' in proxy_req.keys(
) and 'CurTime' in proxy_req.keys():
print "proxy private ip: %s" % self.proxy_data.priv_ip
#if proxy_req['PrivateIP'][0] != self.proxy_data.priv_ip :
if proxy_req['Key'][0] != self.proxy_data.key:
print "recieve old proxy vm connection: %s" % proxy_req
return ["Error: old provison proxy connection"]
self.proxy_data.connected_with_proxy = True
#if 'PrivateIP' in proxy_req.keys():
# self.proxy_data._set_pub_priv_ip(proxy_req['PublicIP'][0], proxy_req['PrivateIP'][0])
#else:
# self.proxy_data._set_pub_ip(proxy_req['PublicIP'][0])
monitor_base = time.time()
self.proxy_data._sync_time(proxy_req['CurTime'][0],
monitor_base)
print self.proxy_data._get_info()
print "hahhah, proxy connection is coming!!!!"
return ["200 OK!!!%s" % monitor_base]
#if proxy_req['VMType'] == ['instance'] and 'VMStatus' in proxy_req.keys() and 'VMName' in proxy_req.keys() and 'VMIP' in proxy_req.keys() and 'Timestamp' in proxy_req.keys():
if proxy_req['VMType'] == ['instance'
] and 'VMStatus' in proxy_req.keys(
) and 'VMName' in proxy_req.keys(
) and 'Timestamp' in proxy_req.keys():
instance = self.instance_metric._get_instance_by_name(
proxy_req['VMName'][0])
if instance is None:
print 'can not find instance from metric'
print proxy_req['VMName']
return ["no found"]
if proxy_req['VMStatus'][0] == 'BOOTED':
ip_lease = 0
if 'IPLease' in proxy_req.keys():
ip_lease = proxy_req['IPLease'][0]
ProvisionInstanceMetric()._update_instance(
instance, "RUNNING", proxy_req['Timestamp'][0],
ip_lease) #time.time())
print "instance[%s] has finished booted, booted time[%s], dhcp time:%s" % (
proxy_req['VMName'], proxy_req['Timestamp'],
str(proxy_req['IPLease'][0]))
elif proxy_req['VMStatus'][0] == 'DELETED':
ProvisionInstanceMetric()._update_instance(
instance, "DELETED",
proxy_req['Timestamp'][0]) #time.time())
print "instance[%s] has been deleted, deleted time[%s]" % (
proxy_req['VMName'], proxy_req['Timestamp'])
return ["200 OK"]
return [
"Error:(%s) do not include \'hostname\', \'ip\' and \'status[boot|terminate]\'"
% environ['QUERY_STRING']
]
class ProvisionMonitor(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.instance_metric = ProvisionInstanceMetric()
self.terminate_flag = 0
self.metaConfigure = MetaConfigure()
self.host_ip = self.metaConfigure._get_provision_host_ip() or '0.0.0.0'
self.host_port = self.metaConfigure._get_provision_host_port() or 8675
self.proxy_port = self.metaConfigure._get_proxy_port() or 8821
self.report_online =self.metaConfigure._is_report_online()
self.self_stopped = False
self.httpd = make_server('', self.host_port, self.provision_monitor_app)
self.httpd.timeout = self.metaConfigure._get_http_timeout()
self.proxy_data = ProvisionProxyMonitorData(host_port = self.host_port)
def terminate_monitor(self):
self.self_stopped = True
self.join()
def run(self):
self.serve()
def serve(self):
print "Serving on port %d..." % self.host_port
while not self.self_stopped:
self.httpd.handle_request()
if self.metaConfigure._is_debug():
print 'handle one request or timeout ...'
print "Stop monitor server..."
#self.httpd.serve_forever()
def provision_monitor_app(self, environ, start_response):
print 'one request coming'
status = '200 OK' # HTTP Status
headers = [('Content-type', 'text/plain')] # HTTP Headers
start_response(status, headers)
proxy_req = urlparse.parse_qs(environ['QUERY_STRING'])
print proxy_req.keys()
if 'VMType' in proxy_req.keys():
if proxy_req['VMType'] == ['proxy'] and 'PublicIP' in proxy_req.keys() and 'CurTime' in proxy_req.keys():
print "proxy private ip: %s" % self.proxy_data.priv_ip
#if proxy_req['PrivateIP'][0] != self.proxy_data.priv_ip :
if proxy_req['Key'][0] != self.proxy_data.key :
print "recieve old proxy vm connection: %s" % proxy_req
return ["Error: old provison proxy connection"]
self.proxy_data.connected_with_proxy=True
#if 'PrivateIP' in proxy_req.keys():
# self.proxy_data._set_pub_priv_ip(proxy_req['PublicIP'][0], proxy_req['PrivateIP'][0])
#else:
# self.proxy_data._set_pub_ip(proxy_req['PublicIP'][0])
monitor_base = time.time()
self.proxy_data._sync_time(proxy_req['CurTime'][0], monitor_base)
print self.proxy_data._get_info()
print "hahhah, proxy connection is coming!!!!"
return ["200 OK!!!%s" % monitor_base]
#if proxy_req['VMType'] == ['instance'] and 'VMStatus' in proxy_req.keys() and 'VMName' in proxy_req.keys() and 'VMIP' in proxy_req.keys() and 'Timestamp' in proxy_req.keys():
if proxy_req['VMType'] == ['instance'] and 'VMStatus' in proxy_req.keys() and 'VMName' in proxy_req.keys() and 'Timestamp' in proxy_req.keys():
instance = self.instance_metric._get_instance_by_name(proxy_req['VMName'][0])
if instance is None:
print 'can not find instance from metric'
print proxy_req['VMName']
return ["no found"]
if proxy_req['VMStatus'][0] == 'BOOTED' :
ip_lease = 0
if 'IPLease' in proxy_req.keys():
ip_lease = proxy_req['IPLease'][0]
ProvisionInstanceMetric()._update_instance(instance, "RUNNING", proxy_req['Timestamp'][0], ip_lease) #time.time())
print "instance[%s] has finished booted, booted time[%s], dhcp time:%s" % (proxy_req['VMName'], proxy_req['Timestamp'], str(proxy_req['IPLease'][0]))
elif proxy_req['VMStatus'][0] == 'DELETED' :
ProvisionInstanceMetric()._update_instance(instance, "DELETED", proxy_req['Timestamp'][0]) #time.time())
print "instance[%s] has been deleted, deleted time[%s]" % (proxy_req['VMName'], proxy_req['Timestamp'])
return ["200 OK"]
return ["Error:(%s) do not include \'hostname\', \'ip\' and \'status[boot|terminate]\'" % environ['QUERY_STRING']]
