from pysqlite2 import dbapi2 as sqlite
  #import sys, os
  import sys, time, paramiko, os, requests, base64, json, time
  import Utils
  from Instance import Instance
  
  headers = {
      "accept": "application/json",
      "content-type": "application/json",
      "user-agent": "Ganeti RAPI Client",
  }
  
  
  class GanetiCluster(object):
      '''
      This class holds all instances that take part in the virtual cluster.
      It can create and stop new instances - and working in conjuction with the
      db specific classes set up various environments. 
      '''
  
  
      def __init__(self,properties_file):
          '''
          Constructor
          ''' 
          self.utils = Utils.Utils(properties_file)
  	self.base_url = 'https://192.168.1.6:5080/2/'
  	self.username = "ganeti_webmgr"
  	self.password = "9CCNPcF4SJyX"
  
  #        Make sure the sqlite file exists. if not, create it and the table we need
          con = sqlite.connect(self.utils.db_file)
          cur = con.cursor()
          try:
              instances = cur.execute('select * from instances'
                              ).fetchall()
              print """Already discovered instances from previous database file. Use describe_instances without arguments to update.
              """
              print "Found records:
  ", instances
          except sqlite.DatabaseError:
              cur.execute('create table instances(id text, image_id text, dns_name text, ip_address text, mac_address text, vpn text, state text, instance_type text, launch_time text, placement text, username text, password text)')
              con.commit()
              
          cur.close()
          con.close()
          
          
      def describe_instances(self, state=None, pattern=None):
  	instances = []
          if state != "pollDB":
  	    kwargs = {
  		    "headers": headers,
  		    "auth": (self.username, self.password),
  		    "verify": False,
  		    "params":"bulk=1"
  		}
  	    r = requests.request("get", self.base_url+"instances", **kwargs)
  	    list_answer = json.loads(r.content)
  	    for i in range(0,len(list_answer)):
  		   #TODO check the image id
  		   server_id = str(list_answer[i]['name']);
  		   server_image_id = str(list_answer[i]['os']);
  		   server_state = str(list_answer[i]['status']);
  		   server_instance_type = str(list_answer[i]['disk_usage'])+"_"+str(list_answer[i]['oper_vcpus'])+"_"+str(list_answer[i]['oper_ram']);
  		   server_launch_time = str(list_answer[i]['mtime']);
  		   server_placement = str(list_answer[i]['pnode']);
  		   server_vpn = str(list_answer[i]['pnode'])+":"+str(list_answer[i]['network_port']);
  		   server_dns_name = str(list_answer[i]['name']);
  		   server_mac_address = str(list_answer[i]['nic.macs'][0])
  		   server_ip_address = self.utils.mac_ip_mapping[server_dns_name][1];
  
  		   instance = Instance(server_id, server_image_id, server_dns_name, server_ip_address, server_mac_address, server_vpn, server_state, server_instance_type, server_launch_time, server_placement, "root","secretpw");
  		   is_mine = False
  		   r_tags = requests.request("get", self.base_url+"instances/"+server_id+"/tags", **kwargs)
  		   list_tag_answer = json.loads(r_tags.content)
  		   for j in range(0,len(list_tag_answer)):
  			if list_tag_answer[j] == "owner:"+self.utils.ownerTag:
  				is_mine = True
  				break
  		   if is_mine:
  			is_mine = False
  			if state:
  	                   if state == server_state:
  	                       instances.append(instance)
  	                else:
  	                   instances.append(instance)
  	    ## if simple call
              if not state:
                  self.utils.refresh_instance_db(instances)                    
          else :
              ## read from the local database
              con = sqlite.connect(self.utils.db_file)
              cur = con.cursor()
              instancesfromDB = []
              try:
                  instancesfromDB = cur.execute('select * from instances'
                              ).fetchall()
              except sqlite.DatabaseError:
                  con.rollback()
                  
              cur.close()
              con.close()
              
              
              for instancefromDB in instancesfromDB:
                  instances.append(self.utils.return_instance_from_tuple(instancefromDB))
              
          ## if you are using patterns and state, show only matching state and id's
          matched_instances = []
          if pattern:
              for instance in instances:
                  if instance.id.find(pattern) != -1:
                      matched_instances.append(instance)
                      
              if len(matched_instances) > 0:
                  return matched_instances
              else:
                  return None
          else:
              return instances
  
          
      def describe_images(self, pattern=None):
  	kwargs = {
  	    "headers": headers,
  	    "auth": (self.username, self.password),
  	    "verify": False
  	}
  	r = requests.request("get", self.base_url+"os", **kwargs)
  	images = json.loads(r.content)
  	return images

      def get_occupied_dns_names(self):
  	occupied = []
  	kwargs = {
  	    "headers": headers,
  	    "auth": (self.username, self.password),
  	    "verify": False,
  	    "params":"bulk=1"
  	}
  	r = requests.request("get", self.base_url+"instances", **kwargs)
  	list_answer = json.loads(r.content)
  	for i in range(0,len(list_answer)):
  	   occupied.append(str(list_answer[i]['name']));
  	return occupied
  	

      def run_instances(self, instance_count, os, disk, cpu, ram):

  	occupied = self.get_occupied_dns_names();
  	return self.run_instances_names(self.utils.getFree_dns_names(int(instance_count),occupied), os, disk, cpu, ram)

      
      def run_instances_names(self, names, os, disk, cpu, ram): 
          instances = []
  	pending_instances = {}
  	jobIDs = []
  	running_vm_cnt = 0
          for name in names:
  		print "running instance: " + name
  	        kwargs = {
  	            "headers": headers,
  	            "auth": (self.username, self.password),
  	            "verify": False
  	        }
  
                  body = {
                      "__version__": 1,
                      "mode": 'create',
                      "hypervisor": 'kvm',
                      "os_type": os,
                      "instance_name": name,
                      "disk_template": 'plain',
                      "disks": [{'size':disk}],
                      "beparams": {"memory":ram,"maxmem":ram,"minmem":ram,'vcpus':cpu},
                      "hvparams": {'vnc_bind_address':'0.0.0.0'},
                      "nics": [{'ip':self.utils.mac_ip_mapping[name][1],'mac':self.utils.mac_ip_mapping[name][0]}]
                  }
  		rabbit_limit = int(self.utils.rabbit_maxmem/int(ram))
  		if running_vm_cnt < rabbit_limit:
  			body['pnode'] = 'rabbit.delab.csd.auth.gr'
  		elif running_vm_cnt < rabbit_limit+int(self.utils.panther_maxmem/int(ram)):
  			body['pnode'] = 'panther.delab.csd.auth.gr'
  		else:
  			body['pnode'] = 'deer.delab.csd.auth.gr'
                  
                  kwargs["data"] = json.dumps(body)
  
                  r = requests.request("post", self.base_url+"instances", **kwargs)
                  jobID = json.loads(r.content)
  		jobIDs.append(jobID)
  
          	instance = Instance(name, os, name, self.utils.mac_ip_mapping[name][1], self.utils.mac_ip_mapping[name][0], "", "", disk+"_"+cpu+"_"+ram, str(time.time()), "", "root","secretpw");
  
  		pending_instances[str(jobID)] = instance
  		running_vm_cnt = running_vm_cnt + 1
  
  	failures = []
  	for JID in jobIDs:
  		status = ""
  		while status != "success":
  			time.sleep(5)
  			kwargs = {
  			    "headers": headers,
  			    "auth": (self.username, self.password),
  			    "verify": False
  			}	
  
  			body = {
  			    "fields": ['status'],
  			}
  
  			kwargs["data"] = json.dumps(body)
  
  			r = requests.request("get", self.base_url+"jobs/"+str(JID)+"/wait", **kwargs)
  			status = json.loads(r.content)['job_info'][0]
  #			print status
  			if (status == 'error'):
  				failures.append(JID)
  				break
  			elif(status == 'success'):
  				instances.append(pending_instances[str(JID)]);
  
  	#print failures
  	self.tag_instances_owner(instances)
          return instances
  
      def tag_instances_owner(self, instances):
  	jobIDs = []
  	headersTag = {
  	    "accept": "application/json",
  	    "user-agent": "Ganeti RAPI Client",
  	}
  	for instance in instances:
  		print "tagging instance: " + instance.id
  	        kwargs = {
  	            "headers": headersTag,
  	            "auth": (self.username, self.password),
  	            "verify": False
  	        }
  
                  body = {
                      "tag": ['owner:'+self.utils.ownerTag]
                  }
                  kwargs["params"] = body
  
                  r = requests.request("put", self.base_url+"instances/"+instance.id+"/tags", **kwargs)
                  jobID = json.loads(r.content)
  		jobIDs.append(jobID)
          
      def terminate_instances(self, names):
  	for name in names:
  	        kwargs = {
  	            "headers": headers,
  	            "auth": (self.username, self.password),
  	            "verify": False
  	        }
              	print "Terminating: ", name
  		r = requests.request("delete", self.base_url+"instances/"+str(name), **kwargs)
  		self.utils.free_ips.append(name)
              
      
      def block_until_running (self, instances):
          ''' Blocks until all defined instances have reached running state and an ip has been assigned'''
          ## Run describe instances until everyone is running
  	running_instances = []
  	remaining  = len(instances)
  	for instance in instances:
  		print "Waiting for", remaining, "instances to run"
  		name = instance.dns_name
  	        kwargs = {
  	            "headers": headers,
  	            "auth": (self.username, self.password),
  	            "verify": False
  	        }
  		status = ""
  		timeout = 300
  		while status != "running" and timeout > 0:
  			time.sleep(5)
  			r = requests.request("get", self.base_url+"instances/"+str(name), **kwargs)
              		status = json.loads(r.content)['status']
  			timeout = timeout - 5
  		if (timeout <= 0):
  			print "timeout while waiting for running state: " + str(name)
  		else:
  			remaining = remaining - 1
  			running_instances.append(instance)
  	#call describe_instances() to store instances to db
  	self.describe_instances()
          return self.block_until_ping(instances)
  
      def block_until_ping(self, instances):
          ''' Blocks until all defined instances have reached running state and an ip has been assigned'''
          ## Run describe instances until everyone is running
  	ping_instances = []
  	remaining  = len(instances)
  	for instance in instances:
  		print "Waiting for", remaining, "instances to ping"
  		ping = False
  		timeout = 150
  		while (not ping and timeout > 0):
  			response = os.system("ping -c 1 -W 4 " + instance.ip_address)
  		        if response == 0:
  			    ping = True;
  		        else:
  			    time.sleep(1);
  			timeout = timeout - 1
  		if (timeout <= 0):
  			print "timeout while trying to ping: " + str(instance.ip_address)
  		else:
  			remaining = remaining - 1
  			ping_instances.append(instance)
          return instances
              
  if __name__ == "__main__":
      euca = GanetiCluster('Coordinator_gf_r1_0p_6a_4r_4cl_smg_s_first_True_safe_timelimit.properties')
      euca.describe_instances();
      euca.block_until_ping(euca.block_until_running(euca.run_instances(['vm50.delab.csd.auth.gr','vm51.delab.csd.auth.gr'],'snf-image+hadoop_limit','5G','2','1G')));
      k = euca.describe_instances();
      euca.terminate_instances([k[0].dns_name,k[1].dns_name]);