def getVolumeListTree(self, reg) :
logging.debug("_seungjin_ getVolumeListTree called")
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try :
volume_name = Machine_volumes.objects.get(volume_id = volume.id).volume_name
except :
volume_name = ""
volume_json_string = volume_json_string + """
{
"id" : "%s",
"text" : "%s (%s)",
"leaf" : "false"
}, """ % (
volume_no ,
volume_name ,
volume.id ,
)
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"","\"\"","%s" % "["+volume_json_string[0:-2]+"]")
def getMachineImageTree(self,req):
image_ids = self.euca.process_args()
image_json_string = ""
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
image_no = 0
for image in images :
if image.type == "machine" :
# atmosphere info
try :
machine_image_name = Machine_images.objects.get(image_id = image.id).image_name
except :
machine_image_name = ""
# end of atmos info
image_no = image_no + 1
#image.id, image.location, image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
if image.is_public:
image.is_public = "public"
else :
image.is_puiblic = "private"
image_json_string = image_json_string +"""
{
"id" : "%s",
"text" : "%s (%s)",
"leaf" : "false"
}, """ % (
image_no, machine_image_name, image.id
)
r = "[%s]" % image_json_string[0:-2]
#return r
return atmo_util.jsoner("\"success\"","\"\"","%s" % r)
def getVolumeListTree(self, reg):
logging.debug("_seungjin_ getVolumeListTree called")
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try:
volume_name = Machine_volumes.objects.get(
volume_id=volume.id).volume_name
except:
volume_name = ""
volume_json_string = volume_json_string + """
{
"id" : "%s",
"text" : "%s (%s)",
"leaf" : "false"
}, """ % (
volume_no,
volume_name,
volume.id,
)
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"", "\"\"",
"%s" % "[" + volume_json_string[0:-2] + "]")
def removeKeyPair(self, req) :
euca_conn = self.euca.make_connection()
keypair = euca_conn.delete_key_pair(req.POST['keypair_name'])
if keypair == True:
return atmo_util.jsoner("\"success\"","\"\"","\"\"")
else :
return "2"
def removeKeyPair(self, req):
euca_conn = self.euca.make_connection()
keypair = euca_conn.delete_key_pair(req.POST['keypair_name'])
if keypair == True:
return atmo_util.jsoner("\"success\"", "\"\"", "\"\"")
else:
return "2"
def getUserId(self, req):
# get userid based on ec2_access_key
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
#return userinfo.username
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % userinfo.username)
def getMachineImageTree(self, req):
image_ids = self.euca.process_args()
image_json_string = ""
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
image_no = 0
for image in images:
if image.type == "machine":
# atmosphere info
try:
machine_image_name = Machine_images.objects.get(
image_id=image.id).image_name
except:
machine_image_name = ""
# end of atmos info
image_no = image_no + 1
#image.id, image.location, image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
if image.is_public:
image.is_public = "public"
else:
image.is_puiblic = "private"
image_json_string = image_json_string + """
{
"id" : "%s",
"text" : "%s (%s)",
"leaf" : "false"
}, """ % (image_no, machine_image_name, image.id)
r = "[%s]" % image_json_string[0:-2]
#return r
return atmo_util.jsoner("\"success\"", "\"\"", "%s" % r)
def getVmTypes(self, req):
ca = CloudAdmin()
r = ""
for type in ca.getInstanceTypeSize():
r += """{"name" : "%s" , "cpus" : "%s" , "memory" : "%s" , "disc" : "%s"},""" % (
type[1], type[2], type[3], type[4])
return atmo_util.jsoner("\"success\"", "\"\"", "[" + r[:-1] + "]")
def getKeyPairsList(self, req) :
euca_conn = self.euca.make_connection()
keypairs = euca_conn.get_all_key_pairs()
keypairs_list = ''
for keypair in keypairs :
keypair_string = """{"keypair_name" : "%s", "keypair_fingerprint" : "%s"},\n""" % (keypair.name, keypair.fingerprint)
keypairs_list = keypairs_list + keypair_string
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % keypairs_list[0:-2])
def getImageList(self, req):
# list image list
image_ids = self.euca.process_args()
image_json_string = ""
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
for image in images:
if image.type == "machine":
# get atmosphere info
try:
image_name = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_name
except:
image_name = ""
try:
image_description = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_description
if image_description == None:
image_descriontino = ""
except:
image_description = ""
try:
image_tags = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_tags
if image_tags == None:
image_tags = ""
except:
image_tags = "no tags"
#image.id, image.location, image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
if image.is_public:
image.is_public = "public"
else:
image.is_public = "private"
image_description = image_description.replace(
"\n", "<br>") if image_description != None else ""
image_json_string = image_json_string + """
{
"image_name" : "%s",
"image_description" : "%s",
"image_tags" : "%s",
"image_id" : "%s" ,
"image_location" : "%s" ,
"image_ownerid" : "%s" ,
"image_state" : "%s" ,
"image_is_public" : "%s" ,
"image_product_codes" : "%s" ,
"image_architecture" : "%s" ,
"image_type" : "%s" ,
"image_ramdisk_id" : "%s" ,
"image_kernel_id" : "%s"
}, """ % (image_name, image_description, image_tags, image.id,
image.location, image.ownerId, image.state, image.is_public,
image.product_codes, image.architecture, image.type,
image.ramdisk_id, image.kernel_id)
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % image_json_string[0:-2])
def getImageList(self, req):
# list image list
image_ids = self.euca.process_args()
image_json_string = ""
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
for image in images :
if image.type == "machine" :
# get atmosphere info
try :
image_name = Machine_images.objects.filter(image_id = image.id).order_by('-id')[0].image_name
except :
image_name = ""
try :
image_description = Machine_images.objects.filter(image_id = image.id).order_by('-id')[0].image_description
if image_description == None :
image_descriontino = ""
except :
image_description = ""
try :
image_tags = Machine_images.objects.filter(image_id = image.id).order_by('-id')[0].image_tags
if image_tags == None :
image_tags = ""
except :
image_tags = "no tags"
#image.id, image.location, image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
if image.is_public:
image.is_public = "public"
else :
image.is_public = "private"
image_description = image_description.replace("\n", "<br>") if image_description != None else ""
image_json_string = image_json_string +"""
{
"image_name" : "%s",
"image_description" : "%s",
"image_tags" : "%s",
"image_id" : "%s" ,
"image_location" : "%s" ,
"image_ownerid" : "%s" ,
"image_state" : "%s" ,
"image_is_public" : "%s" ,
"image_product_codes" : "%s" ,
"image_architecture" : "%s" ,
"image_type" : "%s" ,
"image_ramdisk_id" : "%s" ,
"image_kernel_id" : "%s"
}, """ % (
image_name,
image_description,
image_tags,
image.id,
image.location,
image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
)
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % image_json_string[0:-2])
def getKeyPairsList(self, req):
euca_conn = self.euca.make_connection()
keypairs = euca_conn.get_all_key_pairs()
keypairs_list = ''
for keypair in keypairs:
keypair_string = """{"keypair_name" : "%s", "keypair_fingerprint" : "%s"},\n""" % (
keypair.name, keypair.fingerprint)
keypairs_list = keypairs_list + keypair_string
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % keypairs_list[0:-2])
def getUserProfile(self,req):
userinfo = Ec2_keys.objects.get(ec2_access_key = self.euca.ec2_user_access_key)
# TODO
# quota info
p = User_resource_quotas.objects.filter(userid=self.userid)
if p.count() == 0 :
cpu_limit = mem_limit = 'Unlimited'
else :
cpu_limit = str(p[0].cpu)
mem_limit = str(p[0].memory)
user_profile = '{"userid":"%s"},{"ec2_access_key":"%s"},{"ec2_secret_key":"%s"},{"ec2_url":"%s"},{"s3_url":"%s"},{"token":"%s"},{"api_server":"%s"},{"quota_cpu":"%s"},{"quota_mem":"%s"}' % (userinfo.username,self.ec2_access_key,self.ec2_secret_key,self.ec2_url,self.s3_url,req.META['HTTP_X_AUTH_TOKEN'],req.META['HTTP_X_API_SERVER'],cpu_limit,mem_limit)
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % user_profile)
def getVolumeList(self,req) :
logging.debug("_seungjin_ method call : getVolumeList")
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try :
volume_name = Machine_volumes.objects.get(volume_id = volume.id).volume_name
except :
volume_name = ""
try :
volume_description = Machine_volumes.objects.get(volume_id = volume.id).volume_description
except :
volume_description = ""
try :
volume_tags = Machine_volumes.objects.get(volume_id = volume.id).volume_tags
except :
volume_tags = ""
volume_descriptoin_html = volume_description.replace("\n", "<br>") if volume_description is not None else ""
volume_json_string = volume_json_string + """
{
"no" : "%s",
"name" : "%s",
"description" : "%s",
"tags" : "%s" ,
"id" : "%s",
"size" : "%s",
"snapshot_id" : "%s",
"status" : "%s",
"create_time" : "%s" ,
"attach_data_instance_id" : "%s" ,
"attach_data_device" : "%s" ,
"attach_data_attach_time" : "%s"
}, """ % (
volume_no ,
volume_name ,
volume_descriptoin_html ,
volume_tags,
volume.id ,
volume.size ,
volume.snapshot_id,
volume.status,
volume.create_time,
volume.attach_data.instance_id,
volume.attach_data.device,
volume.attach_data.attach_time
)
logging.debug("_seungjin_ 2" + "["+volume_json_string[0:-2]+"]")
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % volume_json_string[0:-2])
def getKeyPairsListTree(self, req) :
euca_conn = self.euca.make_connection()
keypairs = euca_conn.get_all_key_pairs()
keypairs_list = ''
keypair_id = 0
for keypair in keypairs :
keypair_id = keypair_id + 1
keypair_string = """{"id" : "%s", "text" : "%s", "leaf" : "false"},""" % (keypair_id,keypair.name)
keypairs_list = keypairs_list + keypair_string
#print atmo_util.jsoner(keypairs_list[0:-1])
#return "[%s]" % keypairs_list[0:-1]
logging.debug(keypairs_list)
return atmo_util.jsoner("\"success\"","null","[%s]" % keypairs_list[0:-1])
def getAttachedVolumeList(self,req) :
#euca = Euca2ool()
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try :
volume_name = Machine_volumes.objects.get(volume_id = volume.id).volume_name
except :
volume_name = ""
try :
volume_description = Machine_volumes.objects.get(volume_id = volume.id).volume_description
except :
volume_description = ""
try :
volume_tags = Machine_volumes.objects.get(volume_id = volume.id).volume_tags
except :
volume_tags = ""
volume_json_string = volume_json_string + """
{
"no" : "%s",
"name" : "%s",
"description" : "%s",
"tags" : "%s" ,
"id" : "%s",
"size" : "%s",
"snapshot_id" : "%s",
"status" : "%s",
"create_time" : "%s" ,
"attach_data_instance_id" : "%s" ,
"attach_data_device" : "%s" ,
"attach_data_attach_time" : "%s"
}, """ % (
volume_no ,
volume_name ,
volume_description.replace("\n", "<br>"),
volume_tags,
volume.id ,
volume.size ,
volume.snapshot_id,
volume.status,
volume.create_time,
volume.attach_data.instance_id,
volume.attach_data.device,
volume.attach_data.attach_time
)
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % volume_json_string[0:-2])
def createKeyPair(self, req) :
logging.debug(req)
euca_conn = self.euca.make_connection()
keypair = None
logging.debug("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
userinfo = Ec2_keys.objects.get(ec2_access_key = self.euca.ec2_user_access_key)
keypair_name = userinfo.username + "_" +req.POST['keypair_name']
#logging.debug(">>>>>>")
#logging.debug(keypair_name)
keypair = euca_conn.create_key_pair(keypair_name)
#logging.debug(keypair.material.replace('\n','\\n'))
key_string = keypair.material.replace('\n','\\n');
keypair_string = '%s\\t%s\\t%s' % (keypair.name, keypair.fingerprint, key_string)
return atmo_util.jsoner("\"success\"","null","\"%s\"" % keypair_string)
def getKeyPairsListTree(self, req):
euca_conn = self.euca.make_connection()
keypairs = euca_conn.get_all_key_pairs()
keypairs_list = ''
keypair_id = 0
for keypair in keypairs:
keypair_id = keypair_id + 1
keypair_string = """{"id" : "%s", "text" : "%s", "leaf" : "false"},""" % (
keypair_id, keypair.name)
keypairs_list = keypairs_list + keypair_string
#print atmo_util.jsoner(keypairs_list[0:-1])
#return "[%s]" % keypairs_list[0:-1]
logging.debug(keypairs_list)
return atmo_util.jsoner("\"success\"", "null",
"[%s]" % keypairs_list[0:-1])
def getVolumeList(self, req):
logging.debug("_seungjin_ method call : getVolumeList")
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try:
volume_name = Machine_volumes.objects.get(
volume_id=volume.id).volume_name
except:
volume_name = ""
try:
volume_description = Machine_volumes.objects.get(
volume_id=volume.id).volume_description
except:
volume_description = ""
try:
volume_tags = Machine_volumes.objects.get(
volume_id=volume.id).volume_tags
except:
volume_tags = ""
volume_descriptoin_html = volume_description.replace(
"\n", "<br>") if volume_description is not None else ""
volume_json_string = volume_json_string + """
{
"no" : "%s",
"name" : "%s",
"description" : "%s",
"tags" : "%s" ,
"id" : "%s",
"size" : "%s",
"snapshot_id" : "%s",
"status" : "%s",
"create_time" : "%s" ,
"attach_data_instance_id" : "%s" ,
"attach_data_device" : "%s" ,
"attach_data_attach_time" : "%s"
}, """ % (volume_no, volume_name, volume_descriptoin_html, volume_tags,
volume.id, volume.size, volume.snapshot_id, volume.status,
volume.create_time, volume.attach_data.instance_id,
volume.attach_data.device, volume.attach_data.attach_time)
logging.debug("_seungjin_ 2" + "[" + volume_json_string[0:-2] + "]")
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % volume_json_string[0:-2])
def getUserProfile(self, req):
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
# TODO
# quota info
p = User_resource_quotas.objects.filter(userid=self.userid)
if p.count() == 0:
cpu_limit = mem_limit = 'Unlimited'
else:
cpu_limit = str(p[0].cpu)
mem_limit = str(p[0].memory)
user_profile = '{"userid":"%s"},{"ec2_access_key":"%s"},{"ec2_secret_key":"%s"},{"ec2_url":"%s"},{"s3_url":"%s"},{"token":"%s"},{"api_server":"%s"},{"quota_cpu":"%s"},{"quota_mem":"%s"}' % (
userinfo.username, self.ec2_access_key, self.ec2_secret_key,
self.ec2_url, self.s3_url, req.META['HTTP_X_AUTH_TOKEN'],
req.META['HTTP_X_API_SERVER'], cpu_limit, mem_limit)
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % user_profile)
def createKeyPair(self, req):
logging.debug(req)
euca_conn = self.euca.make_connection()
keypair = None
logging.debug("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
keypair_name = userinfo.username + "_" + req.POST['keypair_name']
#logging.debug(">>>>>>")
#logging.debug(keypair_name)
keypair = euca_conn.create_key_pair(keypair_name)
#logging.debug(keypair.material.replace('\n','\\n'))
key_string = keypair.material.replace('\n', '\\n')
keypair_string = '%s\\t%s\\t%s' % (keypair.name, keypair.fingerprint,
key_string)
return atmo_util.jsoner("\"success\"", "null",
"\"%s\"" % keypair_string)
def getAttachedVolumeList(self, req):
#euca = Euca2ool()
euca_conn = self.euca.make_connection()
volumes = euca_conn.get_all_volumes()
volume_json_string = u''
volume_no = 0
for volume in volumes:
volume_no = volume_no + 1
try:
volume_name = Machine_volumes.objects.get(
volume_id=volume.id).volume_name
except:
volume_name = ""
try:
volume_description = Machine_volumes.objects.get(
volume_id=volume.id).volume_description
except:
volume_description = ""
try:
volume_tags = Machine_volumes.objects.get(
volume_id=volume.id).volume_tags
except:
volume_tags = ""
volume_json_string = volume_json_string + """
{
"no" : "%s",
"name" : "%s",
"description" : "%s",
"tags" : "%s" ,
"id" : "%s",
"size" : "%s",
"snapshot_id" : "%s",
"status" : "%s",
"create_time" : "%s" ,
"attach_data_instance_id" : "%s" ,
"attach_data_device" : "%s" ,
"attach_data_attach_time" : "%s"
}, """ % (volume_no, volume_name,
volume_description.replace("\n", "<br>"), volume_tags,
volume.id, volume.size, volume.snapshot_id, volume.status,
volume.create_time, volume.attach_data.instance_id,
volume.attach_data.device, volume.attach_data.attach_time)
#return "["+volume_json_string[0:-2]+"]"
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % volume_json_string[0:-2])
def getEc2SecretKey(self, req):
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % self.ec2_secret_key)
def getEc2SecretKey(self,req):
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % self.ec2_secret_key)
def getEc2AccessKey(self, req):
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % self.ec2_access_key)
def getEc2Url(self,req):
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % self.ec2_url)
def launchApp(self, req):
# euca-run-instance -t m1.small -z iplanto1 -f atmo-init.rb emi-123
if req.method == "POST":
# quota check starts
instance_type = req.POST['instance_size']
min_count = 1
max_count = 1
requested_cpu = int(
self.convertMachineTypeStringToNum(instance_type)
['cpu']) * int(max_count)
requested_mem = int(
self.convertMachineTypeStringToNum(instance_type)
['mem']) * int(max_count)
quota_check = self.checkEc2ResourceQuota(
newly_requested_cpu=requested_cpu,
newly_requested_mem=requested_mem)
if quota_check['result'] == "unavailable":
quota_check_json = '{"limit_cpu":%s, "limit_mem":%s, "current_cpu":%s, "current_mem":%s }' % (
quota_check['limit_cpu'], quota_check['limit_mem'],
quota_check['current_cpu'], quota_check['current_mem'])
return atmo_util.jsoner("\"fail\"", "\"quota over\"",
quota_check_json)
instance_name = req.POST['instance_name']
image_id = req.POST['image_id'] if req.POST['image_id'] else None
keyname = None
kernel_id = None
ramdisk_id = None
instance_type = req.POST['instance_size']
group_names = []
user_data = None
user_data_file = None
addressing_type = None
zone = None
#user_data_file = open(os.path.abspath(os.path.dirname(__file__))+'/../../api/v1/atmo-init.rb', 'r')
#user_data = user_data_file.read()
#user_data_file.close()
user_data = Machine_image_userdata_scripts.objects.get(
script_id=(Applications.objects.get(
application_id=req.POST['application_id']).
machine_image_user_data_scripts_script_id)).script
logging.debug(user_data)
instance_token = str(uuid.uuid4())
instance_service_url = Configs.objects.get(
key="instance_service_url").value
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
instance_config = """{
"atmosphere":{ "servicename":"instance service",
"instance_service_url":"%s",
"token":"%s",
"userid":"%s"
}
}""" % (instance_service_url, instance_token, userinfo.username)
user_data = user_data + "\narg = '" + instance_config + "'\nmain(arg)\n\n"
euca_conn = self.euca.make_connection()
try:
reservation = euca_conn.run_instances(
image_id=image_id,
min_count=min_count,
max_count=max_count,
key_name=keyname,
security_groups=group_names,
user_data=user_data,
addressing_type=addressing_type,
instance_type=instance_type,
placement=zone,
kernel_id=kernel_id,
ramdisk_id=ramdisk_id)
except Exception, e:
logging.error("cloud error 272")
return atmo_util.jsoner("\"fail\"", "\"\"", "\"%s\"" % e)
instance_id = None
for group in reservation.groups:
for instance in reservation.instances:
inst = Instances(
instance_name=req.POST['instance_name'],
instance_description=
"Atmosphere application\nLaunched by Atmosphere APP launcher",
instance_tags='APP, ' + req.POST['instance_name'],
reservation=reservation.id,
owner_id=reservation.owner_id,
group_id=group.id,
instance_id=instance.id,
machine_image=instance.image_id,
public_dns_name=instance.public_dns_name,
private_dns_name=instance.private_dns_name,
current_state=instance.state,
ami_index=instance.ami_launch_index,
product_code=instance.product_codes,
machine_size=instance.instance_type,
placement=instance.placement,
key_name=instance.key_name,
launch_time=instance.launch_time,
kernel=instance.kernel,
ramdisk=instance.ramdisk,
launch_request_time=datetime.datetime.now(),
instance_token=instance_token,
launch_response_time=None)
inst.save()
instance_id = instance.id
logging.debug("launched new instanca/app: " + instance_id)
return atmo_util.jsoner("\"success\"", "\"\"",
"\"%s\"" % str(instance_id))
def getEc2AccessKey(self,req):
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % self.ec2_access_key)
def getUserId(self,req):
# get userid based on ec2_access_key
userinfo = Ec2_keys.objects.get(ec2_access_key = self.euca.ec2_user_access_key)
#return userinfo.username
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % userinfo.username)
def getAppList(self, req):
#application_stacks = Applications.objects.all()
application_stacks = Applications.objects.order_by('application_name')
applications_json = ""
for o in application_stacks:
logging.debug(o.application_name)
applications_json = applications_json+ """{
"application_name":"%s",
"application_icon_path":"%s",
"application_id":"%s",
"application_creator":"%s",
"application_created":"%s",
"application_version":"%s",
"application_category":"%s",
"application_type":"%s",
"platform":"%s",
"machine_image_id":"%s",
"kernel_id":"%s",
"ramdisk_id":"%s",
"system_minimum_requirements":"%s",
"application_tags":"%s",
"application_description":"%s",
"is_sys_app":true
}, """ % (
o.application_name,
o.application_icon_path,
o.application_id,
o.application_creator,
o.application_created,
o.application_version,
o.application_category,
o.application_type,
o.platform,
o.machine_image_id,
o.kernel_id,
o.ramdisk_id,
o.system_minimum_requirements,
o.application_tags,
o.application_description.replace('\n', '')
)
#user application stacks
user_application_stacks = User_applications.objects.filter(user_id=self.userid).order_by('application_order')
for p in user_application_stacks:
applications_json = applications_json+ """{
"application_name":"%s",
"application_icon_path":"%s",
"application_id":"u_%s",
"application_creator":"%s",
"application_created":"%s",
"application_version":"%s",
"application_category":"%s",
"application_type":"%s",
"platform":"%s",
"machine_image_id":"%s",
"kernel_id":"%s",
"ramdisk_id":"%s",
"system_minimum_requirements":"%s",
"application_tags":"%s",
"application_description":"%s",
"application_order":"%s",
"is_sys_app":false
}, """ % (
p.application_name,
p.application_icon_path,
p.application_id,
p.user_id,
p.application_created,
p.application_version,
p.application_category,
p.application_type,
p.platform,
p.machine_image_id,
p.kernel_id,
p.ramdisk_id,
p.system_minimum_requirements,
p.application_tags,
p.application_description,
p.application_order
)
return atmo_util.jsoner("\"success\"","null","["+applications_json[0:-2]+"]")
def launchInstance(self, req):
if req.method == "POST":
req_item_list = []
for i in req.POST.iteritems():
req_item_list.append(i[0])
#should be nicely done by dynamically. ugly hugh
if u'instance_size' in req_item_list:
instance_type = req.POST['instance_size']
else:
return atmo_util.jsoner(
"\"fail\"", "\"\"",
"\"%s\"" % "required parameter 'instance_size' missing")
#if u'num_of_instances' in req_item_list : min_count = str(req.POST['num_of_instances'])
#else : min_count = u'1'
#min_count = req.POST['num_of_instances'] if req.POST['num_of_instances'] else 1
#if u'num_of_instances' in req_item_list : max_count = str(req.POST['num_of_instances'])
#else : max_count = u'1'
#max_count = req.POST['num_of_instances'] if req.POST['num_of_instances'] else 1
max_count = 1
min_count = 1
if u'num_of_instances' in req_item_list:
if (req.POST['num_of_instances']
== None) or (req.POST['num_of_instances'].strip()
== ""):
max_count = min_count = 1
else:
max_count = req.POST['num_of_instances']
min_count = req.POST['num_of_instances']
if u'callback_resource_url' in req_item_list:
callback_resource_url = req.POST['callback_resource_url']
else:
callback_reousrce_url = None
requested_cpu = int(
self.convertMachineTypeStringToNum(instance_type)
['cpu']) * int(max_count)
requested_mem = int(
self.convertMachineTypeStringToNum(instance_type)
['mem']) * int(max_count)
quota_check = self.checkEc2ResourceQuota(
newly_requested_cpu=requested_cpu,
newly_requested_mem=requested_mem)
if quota_check['result'] == "unavailable":
quota_check_json = '{"limit_cpu":%s, "limit_mem":%s, "current_cpu":%s, "current_mem":%s }' % (
quota_check['limit_cpu'], quota_check['limit_mem'],
quota_check['current_cpu'], quota_check['current_mem'])
return atmo_util.jsoner("\"fail\"", "\"quota over\"",
quota_check_json)
#logging.debug(self.convertMachineTypeStringToNum(instance_type)['cpu'])
# quota check ends
if u'image_id' in req_item_list: image_id = req.POST['image_id']
else:
return atmo_util.jsoner(
"\"fail\"", "\"\"",
"\"%s\"" % "required parameter 'image_id' missing")
#image_id = req.POST['image_id'] if req.POST['image_id'] else None
if u'auth_key' in req_item_list: keyname = req.POST['auth_key']
else:
return atmo_util.jsoner(
"\"fail\"", "\"\"",
"\"%s\"" % "required parameter 'auth_key' missing")
#keyname = req.POST['auth_key']
kernel_id = None
ramdisk_id = None
group_names = []
user_data = None
user_data_file = None
addressing_type = None
zone = None
#user_data_file = open(os.path.abspath(os.path.dirname(__file__))+'/../../api/v1/atmo-init.rb', 'r')
#user_data = user_data_file.read()
#user_data_file.close()
# default user_data?
# what if user_data is null??
if len(Machine_images.objects.filter(image_id=image_id)) > 0:
#user_data = Machine_image_userdata_scripts.objects.get(script_id=(Machine_images.objects.get(image_id = image_id).machine_image_user_data_scripts_script_id)).script
user_data = Machine_image_userdata_scripts.objects.get(
script_id=(
Machine_images.objects.filter(
image_id=image_id).order_by('-id')
[0].machine_image_user_data_scripts_script_id)).script
else:
user_data = None
instance_token = str(uuid.uuid4())
instance_service_url = Configs.objects.get(
key="instance_service_url").value
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
instance_config = """{
"atmosphere":{ "servicename":"instance service",
"instance_service_url":"%s",
"token":"%s",
"userid":"%s"
}
}""" % (instance_service_url, instance_token, userinfo.username)
if user_data != None:
user_data = user_data + "\narg = '" + instance_config + "'\nmain(arg)\n\n"
else:
user_data = ""
euca_conn = self.euca.make_connection()
try:
reservation = euca_conn.run_instances(
image_id=image_id,
min_count=min_count,
max_count=max_count,
key_name=keyname,
security_groups=group_names,
user_data=user_data,
addressing_type=addressing_type,
instance_type=instance_type,
placement=zone,
kernel_id=kernel_id,
ramdisk_id=ramdisk_id)
except Exception, e:
return atmo_util.jsoner("\"fail\"", "\"\"", "\"%s\"" % e)
instance_id = None
for group in reservation.groups:
for instance in reservation.instances:
inst = Instances(
instance_name=req.POST['instance_name'],
instance_description=req.POST['instance_description'],
instance_tags=req.POST['instance_tags'],
reservation=reservation.id,
owner_id=reservation.owner_id,
group_id=group.id,
instance_id=instance.id,
machine_image=instance.image_id,
public_dns_name=instance.public_dns_name,
private_dns_name=instance.private_dns_name,
current_state=instance.state,
ami_index=instance.ami_launch_index,
product_code=instance.product_codes,
machine_size=instance.instance_type,
placement=instance.placement,
key_name=instance.key_name,
launch_time=instance.launch_time,
kernel=instance.kernel,
ramdisk=instance.ramdisk,
launch_request_time=datetime.datetime.now(),
instance_token=instance_token,
launch_response_time=None)
instance_id = instance.id
inst.save()
if u'callback_resource_url' in req_item_list:
ilh = Instance_launch_hooks(
instance_id=instance.id,
owner_id=reservation.owner_id,
webhook_url=req.POST['callback_resource_url'],
webhook_header_params=None,
requested_time=datetime.datetime.now())
ilh.save()
return atmo_util.jsoner("\"success\"", "\"\"",
"\"%s\"" % str(instance_id))
class Ec2_cloud(object, atmo_image):
# this kind of class variable definition is not for python
# need to fix this thing
# but it works now so will fix later
# seung-jin
# this class is quite java-style
# will fix more like python style later
#euca = None
#ec2_access_key = None
#ec2_secret_key = None
#ec2_url = None
#s3_url = None
def __init__(self, ec2_access_key, ec2_secret_key, ec2_url, s3_url):
self.euca = Euca2ool()
self.euca.ec2_user_access_key = ec2_access_key
self.euca.ec2_user_secret_key = ec2_secret_key
self.euca.ec2_url = ec2_url
self.euca.s3_url = s3_url
self.ec2_access_key = ec2_access_key
self.ec2_secret_key = ec2_secret_key
self.ec2_url = ec2_url
self.s3_url = s3_url
self.userid = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key).username
# this getters does not need in python
# will fix later
def getEc2AccessKey(self, req):
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % self.ec2_access_key)
def getEc2SecretKey(self, req):
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % self.ec2_secret_key)
def getEc2Url(self, req):
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % self.ec2_url)
def getS3Url(self, req):
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % self.s3_url)
def getUserId(self, req):
# get userid based on ec2_access_key
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
#return userinfo.username
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % userinfo.username)
def getUserProfile(self, req):
userinfo = Ec2_keys.objects.get(
ec2_access_key=self.euca.ec2_user_access_key)
# TODO
# quota info
p = User_resource_quotas.objects.filter(userid=self.userid)
if p.count() == 0:
cpu_limit = mem_limit = 'Unlimited'
else:
cpu_limit = str(p[0].cpu)
mem_limit = str(p[0].memory)
user_profile = '{"userid":"%s"},{"ec2_access_key":"%s"},{"ec2_secret_key":"%s"},{"ec2_url":"%s"},{"s3_url":"%s"},{"token":"%s"},{"api_server":"%s"},{"quota_cpu":"%s"},{"quota_mem":"%s"}' % (
userinfo.username, self.ec2_access_key, self.ec2_secret_key,
self.ec2_url, self.s3_url, req.META['HTTP_X_AUTH_TOKEN'],
req.META['HTTP_X_API_SERVER'], cpu_limit, mem_limit)
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % user_profile)
def getImageList(self, req):
# list image list
image_ids = self.euca.process_args()
image_json_string = ""
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
for image in images:
if image.type == "machine":
# get atmosphere info
try:
image_name = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_name
except:
image_name = ""
try:
image_description = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_description
if image_description == None:
image_descriontino = ""
except:
image_description = ""
try:
image_tags = Machine_images.objects.filter(
image_id=image.id).order_by('-id')[0].image_tags
if image_tags == None:
image_tags = ""
except:
image_tags = "no tags"
#image.id, image.location, image.ownerId, image.state, image.is_public, image.product_codes, image.architecture, image.type, image.ramdisk_id, image.kernel_id
if image.is_public:
image.is_public = "public"
else:
image.is_public = "private"
image_description = image_description.replace(
"\n", "<br>") if image_description != None else ""
image_json_string = image_json_string + """
{
"image_name" : "%s",
"image_description" : "%s",
"image_tags" : "%s",
"image_id" : "%s" ,
"image_location" : "%s" ,
"image_ownerid" : "%s" ,
"image_state" : "%s" ,
"image_is_public" : "%s" ,
"image_product_codes" : "%s" ,
"image_architecture" : "%s" ,
"image_type" : "%s" ,
"image_ramdisk_id" : "%s" ,
"image_kernel_id" : "%s"
}, """ % (image_name, image_description, image_tags, image.id,
image.location, image.ownerId, image.state, image.is_public,
image.product_codes, image.architecture, image.type,
image.ramdisk_id, image.kernel_id)
return atmo_util.jsoner("\"success\"", "\"\"",
"[%s]" % image_json_string[0:-2])
def getInstanceList(self, req):
return_json_str = "[]"
euca_conn = self.euca.make_connection()
try:
reservations = euca_conn.get_all_instances()
except Exception, ex:
logging.error('cloud.py : ' + ex)
#euca.disaply_error_and_exit('%s' % ex)
instance_ids = ""
instance_num = 0
instance_json_string = ""
# reservation
for reservation in reservations:
reservation_string = '%s\t%s' % (reservation.id,
reservation.owner_id)
group_delim = '\t'
for group in reservation.groups:
reservation_string += '%s%s' % (group_delim, group.id)
group_delim = ', '
#print 'RESERVATION\t%s' % (reservation_string)
instances = []
for instance in reservation.instances:
if instance.id in instance_ids:
instances.append(instance)
else:
instances = reservation.instances
for instance in instances:
instance_num = instance_num + 1
try:
instance_name = Instances.objects.get(
instance_id=instance.id).instance_name
except:
instance_name = ""
try:
instance_description = Instances.objects.get(
instance_id=instance.id).instance_description
except:
instance_description = ""
try:
instance_tags = Instances.objects.get(
instance_id=instance.id).instance_tags
except:
instance_tags = ""
if instance:
instance_image_name = ""
try:
instance_image_name = Machine_images.objects.get(
image_id=instance.image_id).image_name
except:
instasnce_image_name = ""
instance_json_string = instance_json_string + """
{
"instance_num" : "%s" ,
"instance_name" : "%s" ,
"instance_description" : "%s",
"instance_tags" : "%s",
"reservation_id" : "%s" ,
"reservation_owner_id" : "%s" ,
"group_id" : "%s" ,
"instance_id" : "%s" ,
"instance_image_id": "%s" ,
"instance_image_name" : "%s" ,
"instance_public_dns_name" : "%s" ,
"instance_private_dns_name" : "%s" ,
"instance_state" : "%s" ,
"instance_key_name" : "%s" ,
"instance_ami_launch_index" : "%s" ,
"instance_product_codes" : "%s" ,
"instance_instance_type" : "%s" ,
"instance_launch_time" : "%s" ,
"instance_placement" : "%s" ,
"instance_kernel" : "%s" ,
"instance_ramdisk" : "%s"
}, """ % (instance_num, instance_name,
instance_description.replace("\n", "<br>"),
instance_tags, reservation.id, reservation.owner_id,
group.id, instance.id, instance.image_id,
instance_image_name, instance.public_dns_name, instance.
private_dns_name, instance.state, instance.key_name,
instance.ami_launch_index, instance.product_codes,
instance.instance_type, instance.launch_time,
instance.placement, instance.kernel, instance.ramdisk)
return_json_str = "[%s]" % instance_json_string[0:-2]
a = simplejson.loads(return_json_str)
#return simplejson.dumps(a)
return atmo_util.jsoner("\"success\"", "\"\"", simplejson.dumps(a))
def getMethodsList(self):
return atmo_util.jsoner("\"fail\"", "\"not yet implemented\"", "\"\"")
def getMethodsList(self):
return atmo_util.jsoner("\"fail\"","\"not yet implemented\"","\"\"")
def getEc2Url(self, req):
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % self.ec2_url)
def getS3Url(self, req):
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % self.s3_url)
def getVmTypes(self,req) :
ca = CloudAdmin()
r = ""
for type in ca.getInstanceTypeSize() : r += """{"name" : "%s" , "cpus" : "%s" , "memory" : "%s" , "disc" : "%s"},""" % (type[1],type[2],type[3],type[4])
return atmo_util.jsoner("\"success\"","\"\"", "["+r[:-1]+"]")
def launchInstance(self, req) :
if req.method == "POST":
req_item_list = [];
for i in req.POST.iteritems(): req_item_list.append(i[0])
#should be nicely done by dynamically. ugly hugh
if u'instance_size' in req_item_list : instance_type = req.POST['instance_size']
else : return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % "required parameter 'instance_size' missing")
#if u'num_of_instances' in req_item_list : min_count = str(req.POST['num_of_instances'])
#else : min_count = u'1'
#min_count = req.POST['num_of_instances'] if req.POST['num_of_instances'] else 1
#if u'num_of_instances' in req_item_list : max_count = str(req.POST['num_of_instances'])
#else : max_count = u'1'
#max_count = req.POST['num_of_instances'] if req.POST['num_of_instances'] else 1
max_count = 1
min_count = 1
if u'num_of_instances' in req_item_list :
if (req.POST['num_of_instances'] == None) or (req.POST['num_of_instances'].strip() == "") :
max_count = min_count = 1
else :
max_count = req.POST['num_of_instances']
min_count = req.POST['num_of_instances']
if u'callback_resource_url' in req_item_list : callback_resource_url = req.POST['callback_resource_url']
else : callback_reousrce_url = None
requested_cpu = int(self.convertMachineTypeStringToNum(instance_type)['cpu']) * int(max_count)
requested_mem = int(self.convertMachineTypeStringToNum(instance_type)['mem']) * int(max_count)
quota_check = self.checkEc2ResourceQuota(newly_requested_cpu=requested_cpu,newly_requested_mem=requested_mem)
if quota_check['result'] == "unavailable" :
quota_check_json = '{"limit_cpu":%s, "limit_mem":%s, "current_cpu":%s, "current_mem":%s }' % (quota_check['limit_cpu'], quota_check['limit_mem'], quota_check['current_cpu'], quota_check['current_mem'])
return atmo_util.jsoner("\"fail\"","\"quota over\"",quota_check_json)
#logging.debug(self.convertMachineTypeStringToNum(instance_type)['cpu'])
# quota check ends
if u'image_id' in req_item_list : image_id = req.POST['image_id']
else : return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % "required parameter 'image_id' missing")
#image_id = req.POST['image_id'] if req.POST['image_id'] else None
if u'auth_key' in req_item_list : keyname = req.POST['auth_key']
else : return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % "required parameter 'auth_key' missing")
#keyname = req.POST['auth_key']
kernel_id = None
ramdisk_id = None
group_names = [ ]
user_data = None
user_data_file = None
addressing_type = None
zone = None
#user_data_file = open(os.path.abspath(os.path.dirname(__file__))+'/../../api/v1/atmo-init.rb', 'r')
#user_data = user_data_file.read()
#user_data_file.close()
# default user_data?
# what if user_data is null??
if len(Machine_images.objects.filter(image_id = image_id)) > 0 :
#user_data = Machine_image_userdata_scripts.objects.get(script_id=(Machine_images.objects.get(image_id = image_id).machine_image_user_data_scripts_script_id)).script
user_data = Machine_image_userdata_scripts.objects.get(script_id=(Machine_images.objects.filter(image_id = image_id).order_by('-id')[0].machine_image_user_data_scripts_script_id)).script
else:
user_data = None
instance_token = str(uuid.uuid4())
instance_service_url = Configs.objects.get(key="instance_service_url").value
userinfo = Ec2_keys.objects.get(ec2_access_key = self.euca.ec2_user_access_key)
instance_config = """{
"atmosphere":{ "servicename":"instance service",
"instance_service_url":"%s",
"token":"%s",
"userid":"%s"
}
}""" % ( instance_service_url, instance_token, userinfo.username )
if user_data != None :
user_data = user_data + "\narg = '" + instance_config + "'\nmain(arg)\n\n"
else :
user_data = ""
euca_conn = self.euca.make_connection()
try :
reservation = euca_conn.run_instances (
image_id = image_id,
min_count = min_count,
max_count = max_count,
key_name = keyname,
security_groups = group_names,
user_data = user_data,
addressing_type = addressing_type,
instance_type = instance_type,
placement = zone,
kernel_id = kernel_id,
ramdisk_id = ramdisk_id
)
except Exception, e:
return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % e)
instance_id = None
for group in reservation.groups:
for instance in reservation.instances:
inst = Instances(
instance_name = req.POST['instance_name'],
instance_description = req.POST['instance_description'],
instance_tags = req.POST['instance_tags'],
reservation = reservation.id ,
owner_id = reservation.owner_id,
group_id = group.id,
instance_id = instance.id ,
machine_image = instance.image_id,
public_dns_name = instance.public_dns_name,
private_dns_name = instance.private_dns_name,
current_state = instance.state,
ami_index = instance.ami_launch_index,
product_code = instance.product_codes,
machine_size = instance.instance_type,
placement = instance.placement,
key_name = instance.key_name,
launch_time = instance.launch_time,
kernel = instance.kernel,
ramdisk = instance.ramdisk,
launch_request_time = datetime.datetime.now(),
instance_token = instance_token,
launch_response_time = None
)
instance_id = instance.id
inst.save()
if u'callback_resource_url' in req_item_list :
ilh = Instance_launch_hooks(
instance_id = instance.id,
owner_id = reservation.owner_id,
webhook_url = req.POST['callback_resource_url'],
webhook_header_params = None,
requested_time = datetime.datetime.now()
)
ilh.save()
return atmo_util.jsoner("\"success\"","\"\"","\"%s\"" % str(instance_id ))
def getS3Url(self,req):
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % self.s3_url)
def launchApp(self, req):
# euca-run-instance -t m1.small -z iplanto1 -f atmo-init.rb emi-123
if req.method == "POST":
# quota check starts
instance_type = req.POST['instance_size']
min_count = 1
max_count = 1
requested_cpu = int(self.convertMachineTypeStringToNum(instance_type)['cpu']) * int(max_count)
requested_mem = int(self.convertMachineTypeStringToNum(instance_type)['mem']) * int(max_count)
quota_check = self.checkEc2ResourceQuota(newly_requested_cpu=requested_cpu,newly_requested_mem=requested_mem)
if quota_check['result'] == "unavailable" :
quota_check_json = '{"limit_cpu":%s, "limit_mem":%s, "current_cpu":%s, "current_mem":%s }' % (quota_check['limit_cpu'], quota_check['limit_mem'], quota_check['current_cpu'], quota_check['current_mem'])
return atmo_util.jsoner("\"fail\"","\"quota over\"",quota_check_json)
instance_name = req.POST['instance_name']
image_id = req.POST['image_id'] if req.POST['image_id'] else None
keyname = None
kernel_id = None
ramdisk_id = None
instance_type = req.POST['instance_size']
group_names = [ ]
user_data = None
user_data_file = None
addressing_type = None
zone = None
#user_data_file = open(os.path.abspath(os.path.dirname(__file__))+'/../../api/v1/atmo-init.rb', 'r')
#user_data = user_data_file.read()
#user_data_file.close()
user_data = Machine_image_userdata_scripts.objects.get(script_id=(Applications.objects.get(application_id = req.POST['application_id']).machine_image_user_data_scripts_script_id)).script
logging.debug(user_data)
instance_token = str(uuid.uuid4())
instance_service_url = Configs.objects.get(key="instance_service_url").value
userinfo = Ec2_keys.objects.get(ec2_access_key = self.euca.ec2_user_access_key)
instance_config = """{
"atmosphere":{ "servicename":"instance service",
"instance_service_url":"%s",
"token":"%s",
"userid":"%s"
}
}""" % (
instance_service_url,
instance_token,
userinfo.username
)
user_data = user_data + "\narg = '" + instance_config + "'\nmain(arg)\n\n"
euca_conn = self.euca.make_connection()
try :
reservation = euca_conn.run_instances (
image_id = image_id,
min_count = min_count,
max_count = max_count,
key_name = keyname,
security_groups = group_names,
user_data = user_data,
addressing_type = addressing_type,
instance_type = instance_type,
placement = zone,
kernel_id = kernel_id,
ramdisk_id = ramdisk_id
)
except Exception, e:
logging.error("cloud error 272")
return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % e)
instance_id = None
for group in reservation.groups:
for instance in reservation.instances:
inst = Instances(
instance_name = req.POST['instance_name'],
instance_description = "Atmosphere application\nLaunched by Atmosphere APP launcher",
instance_tags = 'APP, ' + req.POST['instance_name'],
reservation = reservation.id ,
owner_id = reservation.owner_id,
group_id = group.id,
instance_id = instance.id ,
machine_image = instance.image_id,
public_dns_name = instance.public_dns_name,
private_dns_name = instance.private_dns_name,
current_state = instance.state,
ami_index = instance.ami_launch_index,
product_code = instance.product_codes,
machine_size = instance.instance_type,
placement = instance.placement,
key_name = instance.key_name,
launch_time = instance.launch_time,
kernel = instance.kernel,
ramdisk = instance.ramdisk,
launch_request_time = datetime.datetime.now(),
instance_token = instance_token,
launch_response_time = None
)
inst.save()
instance_id = instance.id
logging.debug("launched new instanca/app: " + instance_id)
return atmo_util.jsoner("\"success\"","\"\"","\"%s\"" % str(instance_id ))
def getAppList(self, req):
#application_stacks = Applications.objects.all()
application_stacks = Applications.objects.order_by('application_name')
applications_json = ""
for o in application_stacks:
logging.debug(o.application_name)
applications_json = applications_json + """{
"application_name":"%s",
"application_icon_path":"%s",
"application_id":"%s",
"application_creator":"%s",
"application_created":"%s",
"application_version":"%s",
"application_category":"%s",
"application_type":"%s",
"platform":"%s",
"machine_image_id":"%s",
"kernel_id":"%s",
"ramdisk_id":"%s",
"system_minimum_requirements":"%s",
"application_tags":"%s",
"application_description":"%s",
"is_sys_app":true
}, """ % (o.application_name, o.application_icon_path,
o.application_id, o.application_creator,
o.application_created, o.application_version,
o.application_category, o.application_type, o.platform,
o.machine_image_id, o.kernel_id, o.ramdisk_id,
o.system_minimum_requirements, o.application_tags,
o.application_description.replace('\n', ''))
#user application stacks
user_application_stacks = User_applications.objects.filter(
user_id=self.userid).order_by('application_order')
for p in user_application_stacks:
applications_json = applications_json + """{
"application_name":"%s",
"application_icon_path":"%s",
"application_id":"u_%s",
"application_creator":"%s",
"application_created":"%s",
"application_version":"%s",
"application_category":"%s",
"application_type":"%s",
"platform":"%s",
"machine_image_id":"%s",
"kernel_id":"%s",
"ramdisk_id":"%s",
"system_minimum_requirements":"%s",
"application_tags":"%s",
"application_description":"%s",
"application_order":"%s",
"is_sys_app":false
}, """ % (p.application_name, p.application_icon_path,
p.application_id, p.user_id, p.application_created,
p.application_version, p.application_category,
p.application_type, p.platform, p.machine_image_id,
p.kernel_id, p.ramdisk_id, p.system_minimum_requirements,
p.application_tags, p.application_description,
p.application_order)
return atmo_util.jsoner("\"success\"", "null",
"[" + applications_json[0:-2] + "]")
def registerImage(self,request):
manifest_json = simplejson.loads(request.POST['manifest'])
request_user = request.META['HTTP_X_AUTH_USER']
# check required field's existance
emi_id = manifest_json['image_id']
# self.ec2_access_key
# self.ec2_sec`
#euca_local = Euca2ool('s:z:', ['zone=', 'snapshot=', 'size='], compat=True)
#ec2_user_access_key = self.ec2_access_key
#ec2_user_secret_key = self.ec2_secret_key
#ec2_url = self.ec2_url
#s3_url = self.s3_url
#euca_conn = euca_local.make_connection()
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
logging.debug(images)
image_list = []
for image in images:
image_list.append(image.id)
if image.id in emi_id:
#image.id, image.location, image.ownerId, image.state
if request_user != image.ownerId:
return atmo_util.jsoner("\"failed\"","\"\"","\"You don't have access to image %s\"" % emi_id)
if emi_id not in image_list:
return atmo_util.jsoner("\"failed\"","\"\"","%s" % "Image '"+emi_id+"' does not exit. Please upload/register image first")
# ok done. Let's update database
logging.debug(manifest_json['image_name'])
logging.debug(manifest_json['image_description'])
logging.debug(manifest_json['image_tags'])
logging.debug(manifest_json['image_id'])
logging.debug(request_user)
logging.debug(manifest_json['image_ramdisk_id'])
logging.debug(manifest_json['image_kernel_id'])
logging.debug(manifest_json['atmo_init_script_id'])
machine_image = Machine_images(
image_name = manifest_json['image_name'],
image_description = manifest_json['image_description'],
image_tags = manifest_json['image_tags'],
image_id = manifest_json['image_id'],
image_ownerid = request_user,
image_ramdisk_id = manifest_json['image_ramdisk_id'],
image_kernel_id = manifest_json['image_kernel_id'],
machine_image_user_data_scripts_script_id = manifest_json['atmo_init_script_id'],
registered_at = datetime.datetime.now()
)
machine_image.save()
#image.id
#image.location
#image.ownerId
#image.state
# check emi-id is new
# check emi is really owned by user
#logging.debug(">>>" + self.ec2_access_key)
for key in manifest_json:
#logging.debug(key + " > " + manifest_json[key])
pass
return atmo_util.jsoner("\"success\"","\"\"","[%s]" % "Success")
instance_num = instance_num + 1
if instance.state == "running":
try:
instance_name = Instances.objects.get(
instance_id=instance.id).instance_name
except:
instance_name = ""
instance_json_string = instance_json_string + """
{
"id" : "%s" ,
"text" : "%s (%s)" ,
"leaf" : "false"
}, """ % (instance_num, instance_name, instance.id)
return_json_str = "[%s]" % instance_json_string[0:-2]
#return return_json_str
return atmo_util.jsoner("\"success\"", "\"\"", return_json_str)
def launchInstance(self, req):
if req.method == "POST":
req_item_list = []
for i in req.POST.iteritems():
req_item_list.append(i[0])
#should be nicely done by dynamically. ugly hugh
if u'instance_size' in req_item_list:
instance_type = req.POST['instance_size']
else:
return atmo_util.jsoner(
"\"fail\"", "\"\"",
"\"%s\"" % "required parameter 'instance_size' missing")
def registerImage(self, request):
manifest_json = simplejson.loads(request.POST['manifest'])
request_user = request.META['HTTP_X_AUTH_USER']
# check required field's existance
emi_id = manifest_json['image_id']
# self.ec2_access_key
# self.ec2_sec`
#euca_local = Euca2ool('s:z:', ['zone=', 'snapshot=', 'size='], compat=True)
#ec2_user_access_key = self.ec2_access_key
#ec2_user_secret_key = self.ec2_secret_key
#ec2_url = self.ec2_url
#s3_url = self.s3_url
#euca_conn = euca_local.make_connection()
euca_conn = self.euca.make_connection()
images = euca_conn.get_all_images()
logging.debug(images)
image_list = []
for image in images:
image_list.append(image.id)
if image.id in emi_id:
#image.id, image.location, image.ownerId, image.state
if request_user != image.ownerId:
return atmo_util.jsoner(
"\"failed\"", "\"\"",
"\"You don't have access to image %s\"" % emi_id)
if emi_id not in image_list:
return atmo_util.jsoner(
"\"failed\"", "\"\"", "%s" % "Image '" + emi_id +
"' does not exit. Please upload/register image first")
# ok done. Let's update database
logging.debug(manifest_json['image_name'])
logging.debug(manifest_json['image_description'])
logging.debug(manifest_json['image_tags'])
logging.debug(manifest_json['image_id'])
logging.debug(request_user)
logging.debug(manifest_json['image_ramdisk_id'])
logging.debug(manifest_json['image_kernel_id'])
logging.debug(manifest_json['atmo_init_script_id'])
machine_image = Machine_images(
image_name=manifest_json['image_name'],
image_description=manifest_json['image_description'],
image_tags=manifest_json['image_tags'],
image_id=manifest_json['image_id'],
image_ownerid=request_user,
image_ramdisk_id=manifest_json['image_ramdisk_id'],
image_kernel_id=manifest_json['image_kernel_id'],
machine_image_user_data_scripts_script_id=manifest_json[
'atmo_init_script_id'],
registered_at=datetime.datetime.now())
machine_image.save()
#image.id
#image.location
#image.ownerId
#image.state
# check emi-id is new
# check emi is really owned by user
#logging.debug(">>>" + self.ec2_access_key)
for key in manifest_json:
#logging.debug(key + " > " + manifest_json[key])
pass
return atmo_util.jsoner("\"success\"", "\"\"", "[%s]" % "Success")
instance_name = Instances.objects.get(instance_id = instance.id).instance_name
except :
instance_name = ""
instance_json_string = instance_json_string + """
{
"id" : "%s" ,
"text" : "%s (%s)" ,
"leaf" : "false"
}, """ % (
instance_num ,
instance_name ,
instance.id
)
return_json_str = "[%s]" % instance_json_string[0:-2]
#return return_json_str
return atmo_util.jsoner("\"success\"","\"\"",return_json_str)
def launchInstance(self, req) :
if req.method == "POST":
req_item_list = [];
for i in req.POST.iteritems(): req_item_list.append(i[0])
#should be nicely done by dynamically. ugly hugh
if u'instance_size' in req_item_list : instance_type = req.POST['instance_size']
else : return atmo_util.jsoner("\"fail\"","\"\"","\"%s\"" % "required parameter 'instance_size' missing")
#if u'num_of_instances' in req_item_list : min_count = str(req.POST['num_of_instances'])
#else : min_count = u'1'
#min_count = req.POST['num_of_instances'] if req.POST['num_of_instances'] else 1
