def del_vm_disk_qos(volume_uuid, session_uuid = None):
    action = api_actions.DeleteVolumeQosAction()
    action.uuid = volume_uuid

    test_util.action_logger('DeleteVolumeQos [volume:] %s' % (volume_uuid))
    evt = account_operations.execute_action_with_session(action, session_uuid)
    return evt

def get_ip_capacity_by_l3s(l3_network_list, session_uuid = None):
    action = api_actions.GetIpAddressCapacityAction()
    action.l3NetworkUuids = l3_network_list
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger('Get L3s: [%s] IP Capacity' % \
            l3_network_list)
    return evt

def delete_security_group(sg_uuid, session_uuid=None):
    action = api_actions.DeleteSecurityGroupAction()
    action.uuid = sg_uuid
    action.timeout = 12000
    test_util.action_logger('Delete [Security Group:] %s' % sg_uuid)
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    return evt

def delete_vcenter(vcenter_uuid, timeout=240000, session_uuid=None):
    action = api_actions.DeleteVCenterAction()
    action.uuid = vcenter_uuid
    action.timeout = timeout
    test_util.action_logger('Delete VCenter [uuid:] %s' % vcenter_uuid)
    evt = account_operations.execute_action_with_session(action, session_uuid)
    return evt.inventory

def attach_port_forwarding(pf_rule_uuid, vm_nic_uuid, session_uuid=None):
    action = api_actions.AttachPortForwardingRuleAction()
    action.ruleUuid = pf_rule_uuid
    action.vmNicUuid = vm_nic_uuid
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger("Port Forwarding Rule [uuid:] %s is attached to %s" % (pf_rule_uuid, vm_nic_uuid))
    return evt.inventory

def delete_autoScaling_template(uuid,session_uuid=None):
	action = api_actions.DeleteAutoScalingTemplateAction()
        action.time = 30000
        action.uuid = uuid
        test_util.action_logger('Delete autoscaling VM Template :%s' % action.uuid)
        evt = acc_ops.execute_action_with_session(action, session_uuid)
        return evt.success

def delete_loadbalancer(uuid,session_uuid = None):
	action = api_actions.DeleteLoadBalancerAction()
	action.uuid = uuid
	action.time = 30000
	test_util.action_logger("delete load balancer %s" %(action.uuid))
	evt = acc_ops.execute_action_with_session(action,session_uuid)
	return evt

def delete_vrouter_route_table(vrrt_uuid, session_uuid=None):
    action = api_actions.DeleteVRouterRouteTableAction()
    action.uuid = vrrt_uuid
    action.timeout = 12000
    test_util.action_logger('Delete [VRouter Route Table]: %s' % vrrt_uuid)
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    return evt

def create_virtual_router_offering(name, cpuNum, memorySize, imageUuid, zoneUuid, managementNetworkUuid, publicNetworkUuid=None, description=None, allocatorStrategy=None, offeringType=None, session_uuid = None):
    action = api_actions.CreateVirtualRouterOfferingAction()
    action.name = name
    action.cpuNum = cpuNum
    action.memorySize = memorySize
    action.imageUuid = imageUuid
    action.zoneUuid = zoneUuid
    action.managementNetworkUuid = managementNetworkUuid
    if publicNetworkUuid != None:
        action.publicNetworkUuid = publicNetworkUuid
    else:
        action.publicNetworkUuid = managementNetworkUuid
    if description != None:
        action.description = description
    if allocatorStrategy != None:
        action.allocatorStrategy = allocatorStrategy
    if offeringType != None:
        action.type = offeringType
    action.timeout = 12000
    test_util.action_logger('create virtual router offering: name: %s cpuNum: %s, memorySize: %s,\
             publicNetworkUuid: %s, managementNetworkUuid: %s, imageUuid: %s '\
            % (action.name, action.cpuNum, action.memorySize,\
             action.publicNetworkUuid, action.managementNetworkUuid, action.imageUuid))
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.test_logger('Virtual Router Offering: %s is created' % evt.inventory.uuid)
    return evt.inventory

def set_l3_mtu(l3_uuid, mtu, session_uuid = None):
    action = api_actions.SetL3NetworkMtuAction()
    action.l3NetworkUuid = l3_uuid
    action.mtu = mtu
    action.timeout = 300000
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger("Set [L3:] %s [mtu:] %s" % (l3_uuid, mtu))

def get_l3_mtu(l3_uuid, session_uuid = None):
    action = api_actions.GetL3NetworkMtuAction()
    action.l3NetworkUuid = l3_uuid
    action.timeout = 300000
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger("Get [L3:] %s mtu" % l3_uuid)
    return evt.mtu

def detach_eip(eip_uuid, session_uuid=None):
    action = api_actions.DetachEipAction()
    action.uuid = eip_uuid
    action.timeout = 24000
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger("[EIP:] %s is detached" % eip_uuid)
    return evt.inventory

def start_vm(vm_uuid, session_uuid=None, timeout=240000):
    action = api_actions.StartVmInstanceAction()
    action.uuid = vm_uuid
    action.timeout = timeout
    test_util.action_logger('Start VM [uuid:] %s' % vm_uuid)
    evt = account_operations.execute_action_with_session(action, session_uuid)
    return evt.inventory

def suspend_vm(vm_uuid, session_uuid=None):
    action = api_actions.PauseVmInstanceAction()
    action.uuid = vm_uuid
    action.timeout = 240000
    test_util.action_logger('Pause VM [uuid:] %s' % vm_uuid)
    evt = account_operations.execute_action_with_session(action, session_uuid)
    return evt.inventory

def remove_vm_from_affinity_group(affinityGroupUuid, vm_uuid, timeout=240000, session_uuid=None):
    action = api_actions.RemoveVmFromAffinityGroupAction()
    action.affinityGroupUuid = affinityGroupUuid
    action.uuid = vm_uuid
    test_util.action_logger('Remove VM [uuid:] %s to Affinity Group [uuid:] %s' % (affinityGroupUuid, vm_uuid))
    evt = account_operations.execute_action_with_session(action, session_uuid) 
    return evt.inventory

def destroy_vrouter(vrouter_uuid, session_uuid=None):
    action = api_actions.DestroyVmInstanceAction()
    action.uuid = vrouter_uuid
    action.timeout = 12000
    test_util.test_logger('Destroy vRouter uuid: {}'.format(vrouter_uuid))
    result = acc_ops.execute_action_with_session(action, session_uuid)
    return result.success

def create_alarm(comparisonOperator, period, threshold, namespace, metric_name, type_alarm=None, name=None, repeat_interval=None, labels=None, actions=None, resource_uuid=None, session_uuid=None):
        action = api_actions.CreateAlarmAction()
        test_util.test_logger("%s" %(comparisonOperator))
        action.timeout = 30000
        if name:
                action.name = name
        if not name:
                action.name = 'alarm_01'
        action.comparisonOperator = comparisonOperator
        action.period = period
        action.threshold = threshold
        action.namespace = namespace
        action.metricName = metric_name
        if actions:
                action.actions = actions
        if repeat_interval:
                action.repeatInterval = repeat_interval
        if labels:
                action.labels = labels
        if resource_uuid:
                action.resourceUuid = resource_uuid
        if type_alarm:
                action.type = type_alarm
        test_util.action_logger('Create Alarm: %s ' % name)
        evt = acc_ops.execute_action_with_session(action, session_uuid)
        return evt.inventory

def delete_certificate(uuid, session_uuid = None):
    action = api_actions.DeleteCertificateAction()
    action.uuid = uuid
    action.timeout = 120000
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.test_logger('Delete [Certificate]: %s' % uuid)
    return evt.inventory

def query_vm_install(conditions,session_uuid=None):
	action = api_actions.QueryVmInstanceAction()
	action.conditions = conditions
	action.time = 30000
	test_util.action_logger("query vm instance")
	evt = acc_ops.execute_action_with_session(action, session_uuid)
	return evt

def delete_l3(uuid, session_uuid = None):
    action = api_actions.DeleteL3NetworkAction()
    action.uuid = uuid
    action.timeout = 300000
    evt = acc_ops.execute_action_with_session(action, session_uuid)
    test_util.action_logger("[L3:] %s is deleted" % uuid)
    return evt