class Job(resource.Resource):
"""Job Resource"""
base_path = "/jobs"
service = lb_service.LoadBalancerService()
# capabilities
allow_get = True
#: Properties
id = resource.Body("job_id")
type = resource.Body("job_type")
begin_time = resource.Body("begin_time")
end_time = resource.Body("end_time")
entities = resource.Body("entities")
status = resource.Body("status")
error_code = resource.Body("error_code")
fail_reason = resource.Body("fail_reason")
class ServerDetail(Servers):
base_path = '/cloudservers/detail'
# capabilities
allow_create = False
allow_get = False
allow_list = True
_query_mapping = resource2.QueryParameters(
'name',
'status',
'limit',
'offset',
'reservation_id',
'enterprise_project_id',
'tags',
not_tags='not-tags',
flavor_id='flavor'
)
# The total number of lists of elastic cloud servers.
count = resource2.Body('count', type=int)
# Elastic cloud server details list.
servers = resource2.Body('servers', type=list)
class AlertConfig(resource.Resource):
base_path = '/warnalert/alertconfig/query'
service = anti_ddos_service.AntiDDosService()
# capabilities
allow_create = False
allow_list = False
allow_get = True
allow_delete = False
allow_update = False
# Properties
#: warn alert config information
#: *Type: dict*
warn_config = resource.Body('warn_config', type=dict)
#: unique topic id
topic_urn = resource.Body('topic_urn')
#: warn alert group name
display_name = resource.Body('display_name')
# This overrides the default behavior of resource get
def get(self, session, requires_id=False):
return super(AlertConfig, self).get(session, requires_id=requires_id)
class Securitytoken(resource2.Resource):
resource_key = 'credential'
resources_key = 'credentials'
base_path = '/OS-CREDENTIAL/securitytokens'
service = iam_service.IamService()
#: The access key of the securitytoken.
access = resource2.Body('access')
#: The secret key of the securitytoken.
secret = resource2.Body('secret')
#: The expire time of the securitytoken.
expires_at = resource2.Body('expires_at')
#: The securitytoken of the securitytoken.
securitytoken = resource2.Body('securitytoken')
def create(self, session, **attrs):
endpoint_override = self.service.get_endpoint_override()
uri = self.base_path
response = session.post(uri,
endpoint_filter=self.service,
endpoint_override=endpoint_override,
json=attrs)
self._translate_response(response)
return self
class Statuses(resource2.Resource):
resource_key = 'statuses'
resources_key = 'statuses'
base_path = '/lbaas/loadbalancers/%(loadbalance_id)s/statuses'
service = network_service.NetworkService()
allow_create = False
allow_get = True
allow_update = False
allow_delete = False
allow_list = False
# loadbalancer
loadbalancer = resource2.Body("loadbalancer", type=dict)
# loadbalancer id
loadbalance_id = resource2.URI("loadbalance_id")
class ServerOS(resource2.Resource):
base_path = "/cloudservers"
allow_create = True
service = compute_service.ComputeService()
# admin password
adminpass = resource2.Body("adminpass")
# key name
keyname = resource2.Body("keyname")
# user id
userid = resource2.Body("userid")
# metadata
metadata = resource2.Body("metadata", type=dict)
def reinstall(self, session, server_id):
url = utils.urljoin(self.base_path, server_id, 'reinstallos')
headers = {'Accept': ''}
endpoint_override = self.service.get_endpoint_override()
service = self.get_service_filter(self, session)
body = {"os-reinstall": self._body.dirty}
return session.post(
url, endpoint_filter=self.service, microversion=service.microversion, json=body, headers=headers,
endpoint_override=endpoint_override).json()
class FlavorExtraSpecs(resource.Resource):
resources_key = 'os-extra_specs'
base_path = '/flavors/%(flavor_id)s/os-extra_specs'
service = compute_service.ComputeService()
#: The ID for the flavor.
flavor_id = resource.URI('flavor_id')
# capabilities
allow_create = True
allow_get = True
allow_delete = True
allow_list = True
extra_specs = resource.Body('extra_specs')
class Quota(KmsResource):
# Properties
# Resource type
type = resource.Body('type')
#: Used resource
#: *Type: int*
used = resource.Body('used', type=int)
#: Quota number for this kind of resource
#: *Type: int*
quota = resource.Body('quota', type=int)
#: Error code
error_code = resource.Body('error_code')
#: Error message
error_msg = resource.Body('error_msg')
@classmethod
def list(cls, session):
url = utils.urljoin(cls.base_path, 'user-quotas')
endpoint_override = cls.service.get_endpoint_override()
headers = {
"Accept": "application/json",
"Content-type": "application/json",
}
resp = session.get(url,
endpoint_filter=cls.service,
endpoint_override=endpoint_override,
headers=headers)
resp = resp.json()
if 'error' in resp:
return
resources = resp['quotas']['resources']
for r in resources:
value = cls.existing(**r)
yield value
class Endpoint(resource.Resource):
resource_key = 'endpoint'
resources_key = 'endpoints'
base_path = '/endpoints'
service = identity_service.IdentityService()
# capabilities
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
patch_update = True
_query_mapping = resource.QueryParameters('interface', 'service_id')
# Properties
#: Describes the interface of the endpoint according to one of the
#: following values:
#:
#: - `public`: intended for consumption by end users, generally on a
#: publicly available network interface
#: - `internal`: not intended for consumption by end users, generally on an
#: unmetered internal network interface
#: - `admin`: intended only for consumption by those needing administrative
#: access to the service, generally on a secure network interface
#:
#: *Type: string*
interface = resource.Body('interface')
#: Setting this value to ``False`` prevents the endpoint from appearing
#: in the service catalog. *Type: bool*
is_enabled = resource.Body('enabled', type=bool)
#: The links for the region resource.
links = resource.Body('links', type=dict)
#: Represents the containing region ID of the service endpoint.
#: *New in v3.2* *Type: string*
region_id = resource.Body('region_id')
#: References the service ID to which the endpoint belongs. *Type: string*
service_id = resource.Body('service_id')
#: Fully qualified URL of the service endpoint. *Type: string*
url = resource.Body('url')
#: The id of the endpoint. *Type: string*
id = resource.Body('id')
#: The region of the endpoint. *Type: string*
region = resource.Body('region')
class PortGroupDetail(PortGroup):
base_path = '/portgroups/detail'
allow_create = False
allow_get = False
allow_update = False
allow_delete = False
allow_list = True
_query_mapping = resource.QueryParameters(
'node', 'address',
)
#: The UUID for the portgroup
id = resource.Body('uuid', alternate_id=True)
class LindedResource(resource.Resource):
base_path = "/backuppolicyresources"
service = volume_backup_service.VolumeBackupService()
# capabilities
allow_create = True
#: Properties
resource_id = resource.Body("resource_id")
resource_type = resource.Body("resource_type")
availability_zone = resource.Body("availability_zone")
os_vol_host_attr = resource.Body("os_vol_host_attr")
message = resource.Body("message")
code = resource.Body("code")
success = resource.Body("success", type=bool)
def link(self, session, backup_policy_id, resources):
"""link resources to backup policy
:param session: openstack session
:param backup_policy_id: backup policy id
:param resources: resources to bound, should be a list of volume id
:return:
"""
_resources = [dict(resource_id=volume_id, resource_type="volume")
for volume_id in resources]
body = {
"backup_policy_id": backup_policy_id,
"resources": _resources
}
endpoint_override = self.service.get_endpoint_override()
response = session.post(self.base_path,
endpoint_filter=self.service,
endpoint_override=endpoint_override,
json=body,
headers={})
result = []
response_json = response.json()
if response_json and response_json["success_resources"]:
for _resource in response_json["success_resources"]:
_resource["success"] = True
result.append(LindedResource.new(**_resource))
if response_json and response_json["fail_resources"]:
for _resource in response_json["fail_resources"]:
_resource["success"] = False
result.append(LindedResource.new(**_resource))
return result
class Resource(resource.Resource):
name_attribute = 'resource_name'
resource_key = 'resource'
resources_key = 'resources'
base_path = '/stacks/%(stack_name)s/%(stack_id)s/resources'
service = orchestration_service.OrchestrationService()
# capabilities
allow_create = False
allow_list = True
allow_retrieve = False
allow_delete = False
allow_update = False
# Properties
#: A list of dictionaries containing links relevant to the resource.
links = resource.Body('links')
#: ID of the logical resource, usually the literal name of the resource
#: as it appears in the stack template.
logical_resource_id = resource.Body('logical_resource_id',
alternate_id=True)
#: Name of the resource.
name = resource.Body('resource_name')
#: ID of the physical resource (if any) that backs up the resource. For
#: example, it contains a nova server ID if the resource is a nova
#: server.
physical_resource_id = resource.Body('physical_resource_id')
#: A list of resource names that depend on this resource. This
#: property facilitates the deduction of resource dependencies.
#: *Type: list*
required_by = resource.Body('required_by', type=list)
#: A string representation of the resource type.
resource_type = resource.Body('resource_type')
#: A string representing the status the resource is currently in.
status = resource.Body('resource_status')
#: A string that explains why the resource is in its current status.
status_reason = resource.Body('resource_status_reason')
#: Timestamp of the last update made to the resource.
updated_at = resource.Body('updated_time')
class ResizeServer(resource2.Resource):
base_path = "/cloudservers/%(server_id)s/resize"
resource_key = "resize"
service = ecs_service.EcsServiceV1_1()
allow_create = True
server_id = resource2.URI('server_id')
# extend server info
extendparam = resource2.Body('extendparam', type=dict)
# optional only support dedicated type host
dedicated_host_id = resource2.Body('dedicated_host_id')
# server size
flavorRef = resource2.Body('flavorRef')
# task id
job_id = resource2.Body('job_id')
# order id
order_id = resource2.Body('order_id')
error = resource2.Body('error')
message = resource2.Body('message')
code = resource2.Body('code')
mode = resource2.Body('mode')
class DeleteServer(resource2.Resource):
base_path = "/cloudservers/delete"
service = ecs_service.EcsService()
allow_create = True
# whether delete server eip
delete_publicip = resource2.Body('delete_publicip')
# whether delete server volume disk
delete_volume = resource2.Body('delete_volume')
# ecs server id list
servers = resource2.Body('servers', type=list)
# ecs server id
id = resource2.Body('id')
# task id
job_id = resource2.Body('job_id')
# order id
order_id = resource2.Body('order_id')
error = resource2.Body('error')
message = resource2.Body('message')
code = resource2.Body('code')
class NetworkIPAvailability(resource.Resource):
resource_key = 'network_ip_availability'
resources_key = None
base_path = '/network-ip-availabilities'
service = vpc_service.VpcService()
# capabilities
allow_get = True
# Properties
#: The network ID.
network_id = resource.Body('network_id')
#: The network name.
network_name = resource.Body('network_name')
#: The project ID.
project_id = resource.Body('tenant_id')
#: The total number of IP addresses on a network.
total_ips = resource.Body('total_ips', type=int)
#: The number of in-use IP addresses on a network.
used_ips = resource.Body('used_ips', type=int)
#: The subnet IP address usage object.
subnet_ip_availability = resource.Body('subnet_ip_availability', type=list)
def get(self, session, requires_id=True):
"""Get a remote resource based on this instance.
:param session: The session to use for making this request.
:type session: :class:`~openstack.session.Session`
:param boolean requires_id: A boolean indicating whether resource ID
should be part of the requested URI.
:return: This :class:`Resource` instance.
:raises: :exc:`~openstack.exceptions.MethodNotSupported` if
:data:`Resource.allow_get` is not set to ``True``.
"""
if not self.allow_get:
raise exceptions.MethodNotSupported(self, "get")
request = self._prepare_request(requires_id=requires_id)
endpoint_override = self.service.get_endpoint_override() if self.service.get_endpoint_override() \
else self.get_endpoint_override(session)
service = self.get_service_filter(self, session)
response = session.get(request.uri,
endpoint_filter=self.service,
microversion=service.microversion,
endpoint_override=endpoint_override)
self._translate_response(response)
return self
def get_endpoint_override(self, session):
endpoint = session.get_endpoint(interface=self.service.interface,
service_type=self.service.service_type)
endpoint_override = endpoint[0:endpoint.rindex('/')]
return endpoint_override
class Snapshot(resource2.Resource):
resource_key = "snapshot"
resources_key = "snapshots"
base_path = "/snapshots"
service = block_store_service.BlockStoreService()
_query_mapping = resource2.QueryParameters('all_tenants', 'name', 'status',
'volume_id')
# capabilities
allow_get = True
allow_create = True
allow_delete = True
allow_update = True
allow_list = True
# Properties
#: A ID representing this snapshot.
id = resource2.Body("id")
#: Name of the snapshot. Default is None.
name = resource2.Body("name")
#: The current status of this snapshot. Potential values are creating,
#: available, deleting, error, and error_deleting.
status = resource2.Body("status")
#: Description of snapshot. Default is None.
description = resource2.Body("description")
#: The timestamp of this snapshot creation.
created_at = resource2.Body("created_at")
#: Metadata associated with this snapshot.
metadata = resource2.Body("metadata", type=dict)
#: The ID of the volume this snapshot was taken of.
volume_id = resource2.Body("volume_id")
#: The size of the volume, in GBs.
size = resource2.Body("size", type=int)
#: Indicate whether to create snapshot, even if the volume is attached.
#: Default is ``False``. *Type: bool*
is_forced = resource2.Body("force", type=format.BoolStr)
class Rule(resource2.Resource):
resource_key = 'rule'
resources_key = 'rules'
base_path = '/lbaas/l7policies/%(policy_id)s/rules'
service = network_service.NetworkService()
_query_mapping = resource2.QueryParameters("id", "tenant_id",
"admin_state_up", "type",
"compare_type", "invert", "key",
"value")
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
# the rule id
id = resource2.Body("id")
# tenant id
tenant_id = resource2.Body("tenant_id")
# Management status: true/false.
# Instructions for use: Fixed to true
admin_state_up = resource2.Body("admin_state_up", type=bool, default=True)
# Matching content: Can be HOST_NAME, PATH
type = resource2.Body("type")
# Matching method:
# EQUAL_TO when type is HOST_NAME.
# REGEX when the type is PATH, STARTS_WITH, EQUAL_TO
compare_type = resource2.Body("compare_type")
# Whether the match is reversed, true/false.
# Instructions for use: Fixed to false. This field can be updated but will not take effect
invert = resource2.Body("invert", type=bool, default=False)
# Match the content key.
# Usage note: When the current match is HOST_NAME and PATH, this field does not take effect.
# This field can be updated but will not take effect
key = resource2.Body("key")
# The value of the matching content. Its value cannot contain spaces.
# Usage note: When the type is HOST_NAME, the value range is String(100).
# The string can only contain English letters, numbers, "-" or ".",
# and must start with a letter or number.
rule_value = resource2.Body("value")
# policy id the rule belongs to
policy_id = resource2.URI("policy_id")
class InstanceHookList(resource.Resource):
resource_key = 'instance_hanging_info'
resources_key = 'instance_hanging_infos'
base_path = '/scaling_instance_hook/%(scaling_group_id)s/list'
allow_list = True
service = auto_scaling_service.AutoScalingService()
_query_mapping = resource.QueryParameters('instance_id')
lifecycle_action_key = resource.Body('lifecycle_action_key')
instance_id = resource.Body('instance_id')
lifecycle_hook_name = resource.Body('lifecycle_hook_name')
scaling_group_id = resource.Body('scaling_group_id')
lifecycle_hook_status = resource.Body('lifecycle_hook_status')
timeout = resource.Body('timeout')
default_result = resource.Body('default_result')
class SchedulePolicy(resource.Resource):
#: whether keep the first backup of current month
remain_first_backup_of_curMonth = resource.Body(
"remain_first_backup_of_curMonth", type=format.YNBool)
#: the max backup amount, min value is 2
rentention_num = resource.Body("rentention_num", type=int)
#: backup period, valid values, 1..14 (days)
frequency = resource.Body("frequency", type=int)
#: backup start time of every day, example: 12:00
start_time = resource.Body("start_time")
#: backup policy status, ``ON``, ``OFF``
status = resource.Body("status")
# week frequency
week_frequency = resource.Body("week_frequency", type=list)
# Backup retention days
rentention_day = resource.Body("rentention_day", type=int)
class QoSRuleType(resource.Resource):
resource_key = 'rule_type'
resources_key = 'rule_types'
base_path = '/qos/rule-types'
service = network_service.NetworkService()
# capabilities
allow_create = False
allow_get = False
allow_update = False
allow_delete = False
allow_list = True
_query_mapping = resource.QueryParameters('type')
# Properties
#: QoS rule type name.
type = resource.Body('type')
class QoSDSCPMarkingRule(resource.Resource):
resource_key = 'dscp_marking_rule'
resources_key = 'dscp_marking_rules'
base_path = '/qos/policies/%(qos_policy_id)s/dscp_marking_rules'
service = network_service.NetworkService()
# capabilities
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
# Properties
#: The ID of the QoS policy who owns rule.
qos_policy_id = resource.URI('qos_policy_id')
#: DSCP mark field.
dscp_mark = resource.Body('dscp_mark')
class Credential(resource2.Resource):
resource_key = 'credential'
resources_key = 'credentials'
base_path = '/OS-CREDENTIAL/credentials'
service = iam_service.IamService()
# capabilities
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
_query_mapping = resource2.QueryParameters('user_id')
# Properties
#: The last_use_time of the credential.
last_use_time = resource2.Body('last_use_time')
#: The accesskey of the credential.
access = resource2.Body('access')
#: The create_time of the credential.
create_time = resource2.Body('create_time')
#: The user_id of the credential.
user_id = resource2.Body('user_id')
#: The description key of the credential.
description = resource2.Body('description')
#: The status key of the credential.
status = resource2.Body('status')
#: The secret key of the credential.
secret = resource2.Body('secret')
def get_credential(self, session, access_key):
endpoint_override = self.service.get_endpoint_override()
url = utils.urljoin(self.base_path, access_key)
response = session.get(url, endpoint_filter=self.service,
endpoint_override=endpoint_override)
self._translate_response(response)
return self
def update_credential(self, session, access_key, **attrs):
endpoint_override = self.service.get_endpoint_override()
url = utils.urljoin(self.base_path, access_key)
response = session.put(url, endpoint_filter=self.service,
endpoint_override=endpoint_override,
json=attrs)
self._translate_response(response)
return self
class Policy(resource.Resource):
resource_key = 'policy'
resources_key = 'policies'
base_path = '/policies'
service = clustering_service.ClusteringService()
# Capabilities
allow_list = True
allow_get = True
allow_create = True
allow_delete = True
allow_update = True
patch_update = True
_query_mapping = resource.QueryParameters('name', 'type', 'sort',
'global_project')
# Properties
#: The name of the policy.
name = resource.Body('name')
#: The type name of the policy.
type = resource.Body('type')
#: The ID of the project this policy belongs to.
project_id = resource.Body('project')
# The domain ID of the policy.
domain_id = resource.Body('domain')
#: The ID of the user who created this policy.
user_id = resource.Body('user')
#: The timestamp when the policy is created.
created_at = resource.Body('created_at')
#: The timestamp when the policy was last updated.
updated_at = resource.Body('updated_at')
#: The specification of the policy.
spec = resource.Body('spec', type=dict)
#: A dictionary containing runtime data of the policy.
data = resource.Body('data', type=dict)
class Member(resource.Resource):
base_path = '/elbaas/listeners/%(listener_id)s/members'
service = lb_service.LoadBalancerService()
# capabilities
allow_create = True
allow_delete = True
allow_list = True
_query_mapping = resource.QueryParameters("address", "server_address",
"server_id", "status",
"health_status")
#: Properties
#: Load balancer listener reference of this member
listener_id = resource.URI("listener_id")
#: EIP address of the member server
address = resource.Body('address')
#: internal IP address of the member server
server_address = resource.Body('server_address')
#: member server ID
server_id = resource.Body('server_id')
#: member server name
server_name = resource.Body('server_name')
#: member server status, valid value includes: ``ACTIVE``, ``PENDING``,
#: ``ERROR``
status = resource.Body('status')
#: Health check status, valid value includes: ``NORMAL``, ``ABNORMAL``,
#: ``UNAVAILABLE``
health_status = resource.Body('health_status')
#: List of listeners associated with this member.
#: *Type: list of dicts which contain the listener IDs*
listeners = resource.Body('listeners', type=list)
#: UTC date and time of the member created time
create_time = resource.Body("create_time")
#: UTC date and time of the member updated time
update_time = resource.Body("update_time")
class Profile(resource.Resource):
resource_key = 'profile'
resources_key = 'profiles'
base_path = '/profiles'
service = cluster_service.ClusterService()
# capabilities
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
patch_update = True
_query_mapping = resource.QueryParameters('sort', 'global_project', 'type',
'name')
# Bodyerties
#: The name of the profile
name = resource.Body('name')
#: The type of the profile.
type = resource.Body('type')
#: The ID of the project this profile belongs to.
project_id = resource.Body('project')
#: The domain ID of the profile.
domain_id = resource.Body('domain')
#: The ID of the user who created this profile.
user_id = resource.Body('user')
#: The spec of the profile.
spec = resource.Body('spec', type=dict)
#: A collection of key-value pairs that are attached to the profile.
metadata = resource.Body('metadata', type=dict)
#: Timestamp of when the profile was created.
created_at = resource.Body('created_at')
#: Timestamp of when the profile was last updated.
updated_at = resource.Body('updated_at')
class Member(resource2.Resource):
resource_key = 'member'
resources_key = 'members'
base_path = '/lbaas/pools/%(pool_id)s/members'
service = network_service.NetworkService()
allow_create = True
allow_get = True
allow_update = True
allow_delete = True
allow_list = True
_query_mapping = resource2.QueryParameters()
# member id
id = resource2.Body("id")
# tenant id
tenant_id = resource2.Body("tenant_id")
# member name
name = resource2.Body("name")
# IP address corresponding to member, for example, 192.168.3.11
# Instructions for use: only the IP address of the main network card
address = resource2.Body("address")
# Back-end protocol number, value range [1,65535]
protocol_port = resource2.Body("protocol_port", type=int)
# Subnet id
subnet_id = resource2.Body("subnet_id")
# Management status, true/false.
# Instructions for use: Fixed to true
admin_state_up = resource2.Body("admin_state_up", type=bool, default=True)
# Weight, ranging from [0,100].
# Usage note: The backend with zero weight no longer accepts new requests
weight = resource2.Body("weight", type=int, default=1)
# The health status of the backend cloud server can be ONLINE or OFFLINE
operating_status = resource2.Body("operating_status")
# The pool id to which this member belongs
pool_id = resource2.URI("pool_id")
class QueryOrderDetail(resource2.Resource):
base_path = "%(domain_id)s/common/order-mgr/orders/%(order_id)s"
service = bss_intl_service.BssIntlService()
allow_get = True
allow_list = True
_query_mapping = resource2.QueryParameters('offset', 'limit')
# request
# User domain ID
domain_id = resource2.URI('domain_id')
order_id = resource2.URI('order_id')
offset = resource2.Body('offset')
limit = resource2.Body('limit')
# response
# Status code.
error_code = resource2.Body('error_code')
# Error description.
error_msg = resource2.Body('error_msg')
# Total number of records.
count = resource2.Body('count')
# Order details.
orderInfo = resource2.Body('orderInfo')
# ID of the primary order item mapping the order item.
orderlineItems = resource2.Body('orderlineItems')
def list(cls, session, **params):
query_params = cls._query_mapping._transpose(params)
uri = cls.get_list_uri(params)
service = cls.get_service_filter(cls, session)
endpoint_override = cls.service.get_endpoint_override()
resp = session.get(uri,
endpoint_filter=cls.service,
microversion=service.microversion,
endpoint_override=endpoint_override,
headers={"Accept": "application/json"},
params=query_params)
response_json = resp.json()
if not response_json:
return
value = cls.existing(**response_json)
return value
class EnterpriseProjectDetail(resource2.Resource):
"""Define a EnterpriseProject class. get detail and update EP"""
base_path = '/enterprise-projects/%(enterprise_project_id)s'
service = eps_service.EpsService()
# Allow operation for this resource.
# capabilities
allow_create = False
allow_list = False
allow_get = True
allow_update = False
allow_delete = False
enterprise_project_id = resource2.URI("enterprise_project_id")
enterprise_project = resource2.Body("enterprise_project")
id = resource2.Body("id")
name = resource2.Body("name")
description = resource2.Body("description")
status = resource2.Body("status", type=int)
created_at = resource2.Body("created_at")
updated_at = resource2.Body("updated_at")
def get(self, session, requires_id=True):
"""Get a remote resource based on this instance.
:param session: The session to use for making this request.
:type session: :class:`~openstack.session.Session`
:param boolean requires_id: A boolean indicating whether resource ID
should be part of the requested URI.
:return: This :class:`Resource` instance.
:raises: :exc:`~openstack.exceptions.MethodNotSupported` if
:data:`Resource.allow_get` is not set to ``True``.
"""
if not self.allow_get:
raise exceptions.MethodNotSupported(self, "get")
request = self._prepare_request(requires_id=False)
endpoint_override = self.service.get_endpoint_override()
service = self.get_service_filter(self, session)
response = session.get(request.uri,
endpoint_filter=self.service,
microversion=service.microversion,
endpoint_override=endpoint_override)
self._translate_response(response)
return self
class UnfreezeCustomer(resource2.Resource):
base_path = "%(domain_id)s/partner/customer-mgr/unfrozens"
service = bss_intl_service.BssIntlService()
allow_create = True
# User domain ID
domain_id = resource2.URI('domain_id')
# request
customerIds = resource2.Body('customerIds', type=list)
reason = resource2.Body('reason')
# response
failNum = resource2.Body('failNum')
successNum = resource2.Body('successNum')
failDetail = resource2.Body('failDetail', type=list)
# Status code.
error_code = resource2.Body('error_code')
# Error description.
error_msg = resource2.Body('error_msg')
class LifecycleHookBase(resource.Resource):
resource_key = 'lifecycle_hook'
resources_key = 'lifecycle_hooks'
base_path = '/scaling_lifecycle_hook/%(scaling_group_id)s'
service = auto_scaling_service.AutoScalingService()
# capabilities
allow_create = True
allow_list = True
allow_get = True
allow_delete = True
allow_update = True
name = resource.Body("lifecycle_hook_name")
scaling_group_id = resource.URI('scaling_group_id')
lifecycle_hook_type = resource.Body('lifecycle_hook_type')
default_result = resource.Body('default_result')
default_timeout = resource.Body('default_timeout')
notification_topic_urn = resource.Body('notification_topic_urn')
notification_topic_name = resource.Body('notification_topic_name')
notification_metadata = resource.Body('notification_metadata')
create_time = resource.Body('create_time')
