Example #1
0
def delete_alarms(request):
    #ids = request.data.getlist('ids[]')
    err = False
    ids = request.data.get("ids[]")
    #LOG.info(ids)
    alarms = Alarm.objects.filter(id=ids)
    LOG.info("---------------- alarms are -------------" + str(alarms))
    for alarm in alarms:
        LOG.info("----------------------------DELETE-------------------")
        LOG.info("---------------- alarm id is ------------------------" +
                 str(alarm.alarm_ins_id))
        rc = create_rc_by_instance(alarm)
        LOG.info("--------------- rc is ------------" + str(rc))
        try:
            result = ceilometer.alarm_delete(rc, alarm.alarm_ins_id)
            alarm.delete()
        #LOG.info(ceilometer.alarm_list(rc))
        except:
            traceback.print_exc()
            return Response({
                'success': False,
                "msg": _('Fail to Delete Alarm!')
            })
    return Response({
        'success': True,
        "msg": _('Alarms have been deleted!')
    },
                    status=status.HTTP_201_CREATED)
Example #2
0
def flavor_create(instance):
    assert instance

    def _generate_name(instance):
        name = u"%s.cpu-%s-ram-%s-disk-%s-core-%s-socket-%s" % (
            settings.OS_NAME_PREFIX, instance.cpu, instance.memory,
            instance.sys_disk, instance.core, instance.socket)
        return name

    def _get_flavor_by_name(instance, name):
        rc = create_rc_by_instance(instance)
        flavor = None
        novaAdmin = get_nova_admin(instance)
        try:
            flavors = novaAdmin.flavors.list(rc)
        except Exception:
            flavors = []
            raise

        if flavors is not None:
            for f in flavors:
                if f.name == name:
                    flavor = f
                    break
        return flavor

    begin = datetime.datetime.now()
    rc = create_rc_by_instance(instance)
    name = _generate_name(instance)
    flavor = _get_flavor_by_name(instance, name)
    metadata = {
        "hw:cpu_cores": instance.core,
        "hw:cpu_sockets": instance.socket
    }
    if flavor is None:
        try:
            LOG.info(u"Flavor not exist, create new, [%s][%s].", instance,
                     name)

            novaadmin = get_nova_admin(instance)
            flavor = novaadmin.flavors.create(ram=instance.memory,
                                              name=name,
                                              vcpus=instance.cpu,
                                              disk=instance.sys_disk,
                                              is_public=True)
            flavor.set_keys(metadata)
            #LOG.info(flavor.get_keys(flavor))
        except nova.nova_exceptions.Conflict:
            LOG.info(u"Flavor name conflict, [%s][%s].", instance, name)
            flavor = _get_flavor_by_name(instance, name)
        except:
            raise

    end = datetime.datetime.now()
    LOG.info(u"Flavor create end, [%s][%s], apply [%s] seconds.", instance,
             name, (end - begin).seconds)
    return flavor
Example #3
0
def update(request):
    try:
	LOG.info("---------------------- UPDATE -----------------------")
	#LOG.info(request.data)
	resource_id = request.data.get("resource_id")
	has_resource = request.data.get("has_resource")
	resource_name = request.data.get("resource_name")
	alarmname = request.data.get("alarmname")
        #LOG.info("------------------ ALARM MODAL --------------------")
	update_alarm = Alarm.objects.get(id=request.data.get("id"))
	#LOG.info(update_alarm)
        rc = create_rc_by_instance(update_alarm)
	LOG.info("------------------ RC -----------------------------")
	#LOG.info(rc)
	#threshold_rule = update_alarm.threshold_rule
	#meter_name = update_alarm.meter_name
	#comparison_operator = update_alarm.comparison_operator
	#threshold = update_alarm.threshold
	#statistic = update_alarm.statistic
	#threshold_rule = ceilometer.make_threshold_rule(meter_name, comparison_operator, threshold, statistic = statistic)
        #threshold_rule['query'] = ceilometer.make_query(resource_id = resource_id)
        #LOG.info("------------------ THRESHOLD RULE -------------------------")
	#LOG.info(threshold_rule)
	#LOG.info("------------------ ORIGIN ALARM ---------------------------")
	#LOG.info(ceilometer.alarm_list(rc))
	#LOG.info("------------------ UPDATED ALARM --------------------------")
        resource_list = ["resource_id::" + resource_id]
        LOG.info("------------ resource_list is  -----------" + str(resource_list))
        LOG.info("--------- alarmname is ------------" + str(alarmname))
        name = alarmname + ";" + str(update_alarm.alarm_notification) + ";" + str(resource_id)
        LOG.info("888888")
        homeland = {'name':name, 'query': resource_list}

        LOG.info("*********** befor update the alarm ***********")
	try:
	    #LOG.info(ceilometer.alarm_update_query(rc, update_alarm.alarm_ins_id, alarmname, threshold_rule))
	    ceilometer.alarm_update(rc, update_alarm.alarm_ins_id, **homeland)
            LOG.info("************ after update **************")
	except:
	    traceback.print_exc()
	update_alarm.has_resource = has_resource
	update_alarm.resource_id = resource_id
	update_alarm.alarm_name = alarmname
	update_alarm.resource_name = resource_name
	update_alarm.save()
	#LOG.info("------------------ ALL ALARMS -----------------------------")
	#LOG.info(ceilometer.alarm_list(rc))
 
        return Response(
            {'success': True, "msg": _('Alarm is updated successfully!')},
            status=status.HTTP_201_CREATED)

    except Exception as e:

        return Response({"success": False, "msg": _(
            'Failed to update alarm for unknown reason.')})
Example #4
0
    def _get_flavor_by_name(instance, name):
        rc = create_rc_by_instance(instance)
        flavor = None
        novaAdmin = get_nova_admin(instance)
        try:
            flavors = novaAdmin.flavors.list(rc)
        except Exception:
            flavors = []
            raise

        if flavors is not None:
            for f in flavors:
                if f.name == name:
                    flavor = f
                    break
        return flavor
Example #5
0
def instance_resize(request):
    ins = Instance.objects.get(id=request.data['id'])
    LOG.info(request.data)
    if ins.sys_disk > int(request.data['sys_disk']):
        return Response({
            "success": False,
            "msg": "Disk too smal.Please enter a bigger disk size."
        })
    if int(request.data['vcpu']) == ins.cpu and int(
            request.data['core']) == ins.core and int(
                request.data['socket']) == ins.socket and int(
                    request.data['memory']) == ins.memory and int(
                        request.data['sys_disk']) == ins.sys_disk:
        return Response({"success": False, "msg": "No change!"})
    org_cpu = ins.cpu
    org_core = ins.core
    org_socket = ins.socket
    org_memory = ins.memory
    org_sys_disk = ins.sys_disk
    ins.cpu = request.data['vcpu']
    ins.core = request.data['core']
    ins.socket = request.data['socket']
    ins.memory = request.data['memory']
    ins.sys_disk = request.data['sys_disk']
    ins.save()
    #ins_ser = InstanceSerializer(ins)
    #LOG.info(ins_ser.data)
    rc = create_rc_by_instance(ins)
    try:
        new_flavor = flavor_create(ins)
        instance = nova.server_get(rc, ins.uuid)
        nova.server_resize(rc, ins.uuid, new_flavor)
        ins.status = 14
        ins.save()
    except Exception as e:
        #traceback.print_exc()
        ins.cpu = org_cpu
        ins.core = org_core
        ins.socket = org_socket
        ins.memory = org_memory
        ins.sys_disk = org_sys_disk
        ins.save()
        return Response({"success": False, "msg": str(e)})
    #return Response(serializer.data)
    return Response({"success": True})
Example #6
0
def delete_alarms(request):
    #ids = request.data.getlist('ids[]')
    err = False
    ids = request.data.get("ids[]")
    #LOG.info(ids)
    alarms = Alarm.objects.filter(id=ids)
    LOG.info("---------------- alarms are -------------" + str(alarms))
    for alarm in alarms:
        LOG.info("----------------------------DELETE-------------------")
	LOG.info("---------------- alarm id is ------------------------" + str(alarm.alarm_ins_id))
	rc = create_rc_by_instance(alarm)
        LOG.info("--------------- rc is ------------" + str(rc))
        try:
	    result = ceilometer.alarm_delete(rc, alarm.alarm_ins_id)
	    alarm.delete()
            #LOG.info(ceilometer.alarm_list(rc))
        except:
    	    traceback.print_exc()
	    return Response({'success': False, "msg":_('Fail to Delete Alarm!')})
    return Response({'success': True, "msg": _('Alarms have been deleted!')}, status=status.HTTP_201_CREATED)
Example #7
0
def instance_verify_resize(request):
    ins = Instance.objects.get(id=request.data['id'])
    rc = create_rc_by_instance(ins)
    try:
        LOG.info(request.data['action'])
        instance = nova.server_get(rc, ins.uuid)
        if request.data['action'] == 'confirm':
            nova.server_confirm_resize(rc, ins.uuid)
        elif request.data['action'] == 'revert':
            nova.server_revert_resize(rc, ins.uuid)
        else:
            return Response({"success": False, "msg": "Wrong action!!!"})
        time.sleep(3)
        instance = nova.server_get(rc, ins.uuid)
        ins.status = get_ins_status(instance)
        if ins.status == 99:
            LOG.info("--------------- WAIT --------------------")
            ins.status = 11
            return Response({"success": False, "msg": "Verify timeout!"})
        flavor = nova.flavor_get(rc, instance.flavor['id'])
        LOG.info(flavor.vcpus)
        LOG.info(flavor.ram)
        extra = nova.flavor_get_extras(rc, flavor.id, True)
        core = extra['hw:cpu_cores']
        socket = extra['hw:cpu_sockets']
        LOG.info(core)
        LOG.info(socket)

        ins.cpu = flavor.vcpus
        ins.memory = flavor.ram
        ins.core = core
        ins.socket = socket
        ins.status = get_ins_status(instance)
        ins.save()
        return Response({"success": True, "msg": "Verify resize!"})
    except:
        traceback.print_exc()
        return Response({"success": False, "msg": "Fail to verify resize!"})
Example #8
0
def update(request):
    try:
        LOG.info("---------------------- UPDATE -----------------------")
        #LOG.info(request.data)
        resource_id = request.data.get("resource_id")
        has_resource = request.data.get("has_resource")
        resource_name = request.data.get("resource_name")
        alarmname = request.data.get("alarmname")
        #LOG.info("------------------ ALARM MODAL --------------------")
        update_alarm = Alarm.objects.get(id=request.data.get("id"))
        #LOG.info(update_alarm)
        rc = create_rc_by_instance(update_alarm)
        LOG.info("------------------ RC -----------------------------")
        #LOG.info(rc)
        #threshold_rule = update_alarm.threshold_rule
        #meter_name = update_alarm.meter_name
        #comparison_operator = update_alarm.comparison_operator
        #threshold = update_alarm.threshold
        #statistic = update_alarm.statistic
        #threshold_rule = ceilometer.make_threshold_rule(meter_name, comparison_operator, threshold, statistic = statistic)
        #threshold_rule['query'] = ceilometer.make_query(resource_id = resource_id)
        #LOG.info("------------------ THRESHOLD RULE -------------------------")
        #LOG.info(threshold_rule)
        #LOG.info("------------------ ORIGIN ALARM ---------------------------")
        #LOG.info(ceilometer.alarm_list(rc))
        #LOG.info("------------------ UPDATED ALARM --------------------------")
        resource_list = ["resource_id::" + resource_id]
        LOG.info("------------ resource_list is  -----------" +
                 str(resource_list))
        LOG.info("--------- alarmname is ------------" + str(alarmname))
        name = alarmname + ";" + str(
            update_alarm.alarm_notification) + ";" + str(resource_id)
        LOG.info("888888")
        homeland = {'name': name, 'query': resource_list}

        LOG.info("*********** befor update the alarm ***********")
        try:
            #LOG.info(ceilometer.alarm_update_query(rc, update_alarm.alarm_ins_id, alarmname, threshold_rule))
            ceilometer.alarm_update(rc, update_alarm.alarm_ins_id, **homeland)
            LOG.info("************ after update **************")
        except:
            traceback.print_exc()
        update_alarm.has_resource = has_resource
        update_alarm.resource_id = resource_id
        update_alarm.alarm_name = alarmname
        update_alarm.resource_name = resource_name
        update_alarm.save()
        #LOG.info("------------------ ALL ALARMS -----------------------------")
        #LOG.info(ceilometer.alarm_list(rc))

        return Response(
            {
                'success': True,
                "msg": _('Alarm is updated successfully!')
            },
            status=status.HTTP_201_CREATED)

    except Exception as e:

        return Response({
            "success": False,
            "msg": _('Failed to update alarm for unknown reason.')
        })
Example #9
0
def instance_action(user, instance_id, action):
    if action not in ALLOWED_INSTANCE_ACTIONS.keys():
        return {"OPERATION_STATUS": OPERATION_FAILED,
                "status": "Unsupported action [%s]" % action}
    #instance = Instance.objects.get(pk=instance_id, user=user, deleted=False)
    instance = Instance.objects.get(pk=instance_id, deleted=False)
    # restoring instance can't do any action!

    if BackupItem.is_any_restoring(instance):
        return {"OPERATION_STATUS": OPERATION_FORBID,
                "MSG": _("Cannot operate this instance because it's in "
                         "restore process."),
                "status": instance.status}

    if action in ('reboot', 'power_on'):
        for volume in instance.volume_set.all():

            if BackupItem.is_any_restoring(volume):
                return {"OPERATION_STATUS": OPERATION_FAILED,
                        "MSG": _("Cannot operate this instance because "
                                 "one volume attached to it is in "
                                 "restore process."),
                        "status": instance.status}

    if action == 'terminate' and \
        BackupItem.living.filter(
            resource_id=instance.id,
            resource_type=Instance.__name__).exists():

        return {"OPERATION_STATUS": OPERATION_FAILED,
                "MSG": _("This instance have backup chains, please delete "
                         "these first."),
                "status": instance.status}

    if action == 'terminate':
        Order.disable_order_and_bills(instance)

    Operation.log(instance, obj_name=instance.name, action=action)
    
    if action == "vnc_console":
        return get_instance_vnc_console(instance)

    _ACTION_MAPPING = {
        "reboot": _server_reboot,
        "terminate": _server_delete,
        "power_on": _server_start,
        "power_off": _server_stop,
        "restore": _server_unpause,
        "pause": _server_pause,
    }

    try:
        rc = create_rc_by_instance(instance)
        act = _ACTION_MAPPING.get(action)
        act(rc, instance)
        instance.status = INSTANCE_ACTION_NEXT_STATE[action]
        instance.save()
        instance_status_synchronize_task.delay(instance, action)
    except Exception as ex:
        LOG.exception("Instance action [%s] raise exception, [%s].",
                            action, instance)
        return {"OPERATION_STATUS": OPERATION_FAILED, 
                "status": "%s" % ex.message}
    else: 
        return {"OPERATION_STATUS": OPERATION_SUCCESS, "status": instance.status}