class Stock(resource2.Resource):
resource_key = 'stock'
base_path = '/stock'
service = baremetal_service.BaremetalService()
# Capabilities
allow_get = True
# Properties
#: Flavor UUID of Baremetal server stock search condition.
flavor_id = resource2.Body('flavor_id', alternate_id=True)
#: Availability Zone name of Baremetal server stock search condition.
availability_zone = resource2.Body('availability_zone')
#: Baremetal server stock is available or not.
stock = resource2.Body('stock')
def get(self, session, flavor_id, availability_zone=None):
uri = self.base_path + "?flavor_id=%s" % flavor_id
if availability_zone:
uri += "&availability_zone=%s" % availability_zone
resp = session.get(uri,
endpoint_filter=self.service,
headers={"Accept": "application/json"})
self._translate_response(resp, has_body=True)
return self
def test_service(self):
sot = baremetal_service.BaremetalService()
self.assertEqual('baremetal-server', sot.service_type)
self.assertEqual('public', sot.interface)
self.assertIsNone(sot.region)
self.assertIsNone(sot.service_name)
self.assertEqual(1, len(sot.valid_versions))
self.assertEqual('v2', sot.valid_versions[0].module)
self.assertEqual('v2', sot.valid_versions[0].path)
class AvailabilityZone(resource2.Resource):
resources_key = 'availabilityZoneInfo'
base_path = '/os-availability-zone'
service = baremetal_service.BaremetalService()
# capabilities
allow_list = True
# Properties
#: name of availability zone
zoneName = resource2.Body('zoneName', alternate_id=True)
name = resource2.Body('zoneName', alternate_id=True)
#: state of availability zone
zoneState = resource2.Body('zoneState')
state = resource2.Body('zoneState')
#: hosts of availability zone
hosts = resource2.Body('hosts')
@classmethod
def find(cls, session, name_or_id, ignore_missing=False, **params):
"""Find a resource by its name or id.
:param session: The session to use for making this request.
:type session: :class:`~ecl.session.Session`
:param name_or_id: This resource's identifier, if needed by
the request. The default is ``None``.
:param bool ignore_missing: When set to ``False``
:class:`~ecl.exceptions.ResourceNotFound` will be
raised when the resource does not exist.
When set to ``True``, None will be returned when
attempting to find a nonexistent resource.
:param dict params: Any additional parameters to be passed into
underlying methods, such as to
:meth:`~ecl.resource2.Resource.existing`
in order to pass on URI parameters.
:return: The :class:`Resource` object matching the given name or id
or None if nothing matches.
:raises: :class:`ecl.exceptions.DuplicateResource` if more
than one resource is found for this request.
:raises: :class:`ecl.exceptions.ResourceNotFound` if nothing
is found and ignore_missing is ``False``.
"""
# Try to short-circuit by looking directly for a matching ID.
data = cls.list(session, **params)
result = cls._get_one_match(name_or_id, data)
if result is not None:
return result
if ignore_missing:
return None
raise exceptions.ResourceNotFound("No %s found for %s" %
(cls.__name__, name_or_id))
def __init__(self, plugins=None):
"""User preference for each service.
:param list plugins: List of entry point namespaces to load.
Create a new :class:`~ecl.profile.Profile`
object with no preferences defined, but knowledge of the services.
Services are identified by their service type, e.g.: 'identity',
'compute', etc.
"""
self._services = {}
self._add_service(compute_service.ComputeService(version="v2"))
self._add_service(
connectivity_service.ConnectivityService(version="v1"))
self._add_service(identity_service.IdentityService(version="v3"))
self._add_service(image_service.ImageService(version="v2"))
self._add_service(network_service.NetworkService(version="v2"))
self._add_service(sss_service.SssService(version="v1"))
self._add_service(
orchestration_service.OrchestrationService(version="v1"))
self._add_service(
provider_connectivity_service.ProviderConnectivityService(
version="v2"))
self._add_service(telemetry_service.TelemetryService(version="v2"))
self._add_service(block_store_service.BlockStoreService(version="v2"))
self._add_service(storage_service.StorageService(version="v1"))
self._add_service(
security_order_service.SecurityOrderService(version="v2"))
self._add_service(
security_portal_service.SecurityPortalService(version="v2"))
## This section will be deleted if MSS v1 API is not available
self._add_service(
security_order_service_v1.SecurityOrderService(version="v1"))
self._add_service(
security_portal_service_v1.SecurityPortalService(version="v1"))
## end of the section
self._add_service(rca_service.RcaService(version="v1"))
self._add_service(baremetal_service.BaremetalService(version="v2"))
self._add_service(
dedicated_hypervisor_service.DedicatedHypervisorService(
version="v1"))
self._add_service(dns_service.DnsService(version="v2"))
self._add_service(
virtual_network_appliance_service.VirtualNetworkApplianceService(
version="v1"))
self._add_service(mvna_service.MVNAService(version="v1"))
# NOTE: The Metric service is not added here as it currently
# only retrieves the /capabilities API.
if plugins:
for plugin in plugins:
self._load_plugin(plugin)
self.service_keys = sorted(self._services.keys())
class NicPhysicalPort(resource2.Resource):
resource_key = "nic_physical_port"
resources_key = "nic_physical_ports"
base_path = '/servers/%(server_id)s/nic_physical_ports'
service = baremetal_service.BaremetalService()
# Capabilities
allow_get = True
allow_list = True
# Properties
#: ID for the specified server.
server_id = resource2.Body('server_id')
#: UUID of the NicPhysicalPort.
id = resource2.Body('id')
#: MAC address of the NicPhysicalPort.
mac_addr = resource2.Body('mac_addr')
#: Network controller port id of physical leaf switch.
network_physical_port_id = resource2.Body('network_physical_port_id')
#: Value = 'data'(default) or 'storage'. Assigning preferentially the
#: order to the NIC physical port. data plane: all devices cloud be
#: connected. storage plane: this plane type is only used and optimized
#: for storages between servers.You can assigning each until 2 planes.
plane = resource2.Body('plane')
#: Logical attached ports of host.
attached_ports = resource2.Body('attached_ports')
#: ID of hardware attaching the NicPhysicalPort.
hardware_id = resource2.Body('hardware_id')
def list(self, session, server_id):
uri = self.base_path % {"server_id": server_id}
resp = session.get(uri,
endpoint_filter=self.service,
headers={"Accept": "application/json"})
resp = resp.json()
resp = resp[self.resources_key]
for data in resp:
value = self.existing(**data)
yield value
def get(self, session, server_id, port_id):
uri = self.base_path + '/%(nic_physical_port_id)s'
uri = uri % {"server_id": server_id, "nic_physical_port_id": port_id}
resp = session.get(uri,
endpoint_filter=self.service,
headers={"Accept": "application/json"})
self._translate_response(resp, has_body=True)
return self
class Limits(resource2.Resource):
base_path = "/limits"
resource_key = "limits"
service = baremetal_service.BaremetalService()
allow_get = True
absolute = resource2.Body("absolute", type=AbsoluteLimits)
rate = resource2.Body("rate", type=list)
def get(self, session, requires_id=False):
"""Get the Limits resource.
:param session: The session to use for making this request.
:type session: :class:`~ecl.session.Session`
:returns: A Baremetal Limits instance
:rtype: :class:`~ecl.baremetal.v2.limits.Limits`
"""
request = self._prepare_request(requires_id=False, prepend_key=False)
response = session.get(request.uri, endpoint_filter=self.service)
body = response.json()
body = body[self.resource_key]
absolute_body = self._filter_component(
body["absolute"], AbsoluteLimits._body_mapping())
self.absolute = AbsoluteLimits.existing(**absolute_body)
rates_body = body["rate"]
rates = []
for rate_body in rates_body:
rate_body = self._filter_component(rate_body,
RateLimit._body_mapping())
rates.append(RateLimit(**rate_body))
self.rate = rates
return self
class Chassis(resource2.Resource):
"""Chassis Resource"""
resource_key = 'chassis'
resources_key = 'chassis'
base_path = '/chassis'
service = baremetal_service.BaremetalService()
# Capabilities
allow_get = True
allow_list = True
# Properties
#: The ID for the chassis, which is a unique integer value.
id = resource2.Body('id')
#: The name of availability zone where chassis exists.
availability_zone = resource2.Body('availability_zone')
#: The name of flavor of chassis.
flavor_name = resource2.Body('flavor_name')
#: The object of summarized hardware spec. That has cpus, disks and rams.
hardware_summary = resource2.Body('hardware_summary', type=dict)
#: The status of chassis.
status = resource2.Body('status')
#: The ID of server attached to chassis. If no server is attached to chassis, the value is null.
server_id = resource2.Body('server_id')
#: The name of server attached to chassis. If no server is attached to chassis, the value is null.
server_name = resource2.Body('server_name')
#: The minimum contract period of your chassis.
contract_year = resource2.Body('contract_year', type=int)
#: The date that you start to use the chassis.
start_time = resource2.Body('start_time')
# Properties (for Detail)
#: The spec of all cpus installed in chassis.
cpus = resource2.Body('cpus', type=list)
#: The spec of all disks installed in chassis.
disks = resource2.Body('disks', type=list)
#: The spec of all rams installed in chassis.
rams = resource2.Body('rams', type=list)
class Version(resource2.Resource):
resource_key = 'version'
resources_key = 'versions'
base_path = '/'
service = baremetal_service.BaremetalService(
version=baremetal_service.BaremetalService.UNVERSIONED)
# Capabilities
allow_list = True
allow_get = True
# Properties
#: List of API endpoint link.
links = resource2.Body('links')
#: Version support status. Valid values are CURRENT or SUPPORTED.
#: CURRENT is newest stable version. SUPPORTED is old supported version.
status = resource2.Body('status')
#: Version identifier included in API URL.
id = resource2.Body('id')
updated = resource2.Body('updated')
def get_version(self, session):
uri = self.base_path + 'v2'
resp = session.get(uri,
headers={"Accept": "application/json"},
endpoint_filter=self.service)
self._translate_response(resp, has_body=True)
return self
def list_version(self, session):
uri = self.base_path
resp = session.get(uri,
headers={"Accept": "application/json"},
endpoint_filter=self.service)
resp = resp.json()[self.resources_key]
for data in resp:
version = self.existing(**data)
yield version
class Keypair(resource2.Resource):
resource_key = 'keypair'
resources_key = 'keypairs'
base_path = '/os-keypairs'
service = baremetal_service.BaremetalService()
# capabilities
allow_create = True
allow_get = True
allow_delete = True
allow_list = True
# Properties
#: Fingerprint of public key.
fingerprint = resource2.Body('fingerprint')
#: The name to associate with the KeyPair. It is a unique name in
#: the tenant. Available character is 1-255 character of
#: alphabet(a-zA-Z), number(0-9) and slash(-).
name = resource2.Body('name', alternate_id=True)
#: Generated SSH private key.
#: This parameter is visible only when did not specify public_key
#: This parameter is only included in the response of Create Keypair.
private_key = resource2.Body('private_key')
#: The public RSA or DSA SSH key to import. If not provided,
#: a key is generated 2048bit RSA key.
public_key = resource2.Body('public_key')
def list(self, session, paginated=False):
resp = session.get(self.base_path,
endpoint_filter=self.service,
headers={"Accept": "application/json"})
resp = resp.json()
resp = resp[self.resources_key]
for data in resp:
value = self.existing(**data)
yield value
class UEFI(resource2.Resource):
resource_key = 'uefi'
resources_key = 'uefi'
base_path = '/servers/%(server_id)s/uefi'
service = baremetal_service.BaremetalService()
# capabilities
allow_update = True
allow_get = True
#: Name for the flavor.
flavor_name = resource2.Body('flavor_name')
#: The ID for the flavor.
flavor_id = resource2.Body('flavor_id', alternate_id=True)
#: Updated time for UEFI
updated = resource2.Body('updated')
#: The last result of applying uefi setting.
status = resource2.Body('status')
#: Error messages when updating uefi setting is failed.
message = resource2.Body('message')
#: UEFI setting.
setting = resource2.Body('setting', type=dict)
def get(self, session, server_id):
uri = self.base_path % {"server_id": server_id}
resp = session.get(uri, endpoint_filter=self.service)
self._translate_response(resp, has_body=True)
return self
def update(self, session, server_id, has_body=True, **attrs):
uri = self.base_path % {"server_id": server_id}
body = attrs
args = {'json': body}
resp = session.put(uri, endpoint_filter=self.service, **args)
self._translate_response(resp, has_body=False)
return self
class Flavor(resource2.Resource):
resource_key = 'flavor'
resources_key = 'flavors'
base_path = '/flavors'
service = baremetal_service.BaremetalService()
# Capabilities
allow_get = True
allow_list = True
# Properties
#: The ID for the flavor, which is a unique integer value.
id = resource2.Body('id')
#: List of flavor resource links.
links = resource2.Body('links')
#: The amount of RAM, in MBs, for this flavor.
ram = resource2.Body('ram', type=int)
#: Name for the flavor.
name = resource2.Body('name')
#: The amount of disk space, in GBs.
disk = resource2.Body('disk', type=int)
#: The CPUs, in whole integer amount, for the flavor.
#: In order to maintain compatibility with Nova API,
#: we put the size of the physical cpu to vcpu.
vcpus = resource2.Body('vcpus', type=int)
@classmethod
def find(cls, session, name_or_id, ignore_missing=False, **params):
"""Find a resource by its name or id.
:param session: The session to use for making this request.
:type session: :class:`~ecl.session.Session`
:param name_or_id: This resource's identifier, if needed by
the request. The default is ``None``.
:param bool ignore_missing: When set to ``False``
:class:`~ecl.exceptions.ResourceNotFound` will be
raised when the resource does not exist.
When set to ``True``, None will be returned when
attempting to find a nonexistent resource.
:param dict params: Any additional parameters to be passed into
underlying methods, such as to
:meth:`~ecl.resource2.Resource.existing`
in order to pass on URI parameters.
:return: The :class:`Resource` object matching the given name or id
or None if nothing matches.
:raises: :class:`ecl.exceptions.DuplicateResource` if more
than one resource is found for this request.
:raises: :class:`ecl.exceptions.ResourceNotFound` if nothing
is found and ignore_missing is ``False``.
"""
# Try to short-circuit by looking directly for a matching ID.
data = cls.list(session, **params)
result = cls._get_one_match(name_or_id, data)
if result is not None:
return result
if ignore_missing:
return None
raise exceptions.ResourceNotFound("No %s found for %s" %
(cls.__name__, name_or_id))
class Server(resource2.Resource):
resources_key = "servers"
resource_key = "server"
base_path = '/servers'
service = baremetal_service.BaremetalService()
# Capabilities
allow_get = True
allow_list = True
allow_create = True
allow_delete = True
allow_update = True
# Properties
#: UUID of the Baremetal server.
id = resource2.Body('id')
#: Link of the Baremetal server.
links = resource2.Body('links')
#: Name of the Baremetal server.
name = resource2.Body('name')
#: Password for the administrator.
#: This parameter is shown only once, so you have to memo.
#: Please refer OS specific limitations adminPass raw to know the
#: required administrator name for each OS.
adminPass = resource2.Body('adminPass')
admin_pass = resource2.Body('adminPass')
#: SSH Keypair name you created on KeyPairs API.
key_name = resource2.Body('key_name')
#: Power state: {"RUNNING":"The server is running.",
#: "SHUTDOWN":"The server was shut down.",
#: "CRASHED":"The server lost powor controll information temporary.
#: Status transfer RUNNING/SHUTDOWN Automatically."}
OS_EXT_STS_power_state = resource2.Body('OS-EXT-STS:power_state')
power_state = resource2.Body('OS-EXT-STS:power_state')
#: Task state: {None:"There are no tasks. Only this status can be
#: received API requests.", "BUILDING":"The task is building the
#: Baremetal Server. This status is transfered by Create Server.",
#: "DELETING":"The task is deleting the Baremetal Server. This status
#: is transfered by Delete Server.", "STOPPING":"The task is stopping
#: the Baremetal Server. This status is transfered by Stop Server.",
#: "STARTING":"The task is starting the Baremetal Server. This status
#: is transfered by Start Server.", "REBOOTING":"The task is rebooting
#: the Baremetal Server. This status is transfered by Reboot Server."}
OS_EXT_STS_task_state = resource2.Body('OS-EXT-STS:task_state')
task_state = resource2.Body('OS-EXT-STS:task_state')
#: VM state: {"ACTIVE":"The Baremetal server is active.
#: This status is target of billing.", "BUILD":"The Baremetal server
#: is built.", "ERROR": "The Baremetal server is outputing a error.
#: There is necessity to report to our support.", "DELETED":"The
#: Baremetal server is deleted."}
OS_EXT_STS_vm_state = resource2.Body('OS-EXT-STS:vm_state')
vm_state = resource2.Body('OS-EXT-STS:vm_state')
#: Server's availability zone.
OS_EXT_AZ_availability_zone = resource2.Body('OS-EXT-AZ:availability_zone')
availability_zone = resource2.Body('OS-EXT-AZ:availability_zone')
#: Sever's created time.
created = resource2.Body('created')
#: Server's flavor information.
flavor = resource2.Body('flavor')
#: Server's host ID.
hostId = resource2.Body('hostId')
#: Server's ID.
image = resource2.Body('image')
#: Server's image information.
metadata = resource2.Body('metadata')
#: Server's links information.
progress = resource2.Body('progress')
#: Server's metadata information.
status = resource2.Body('status')
#: Server's tenant id.
tenant_id = resource2.Body('tenant_id')
#: Server's updated time.
updated = resource2.Body('updated')
#: Server's user id.
user_id = resource2.Body('user_id')
#: Server's raid arrays information.
raid_arrays = resource2.Body('raid_arrays')
#: Server's lvm volume groups information.
lvm_volume_groups = resource2.Body('lvm_volume_groups')
#: Server's file system information.
filesystems = resource2.Body('filesystems')
#: Server's nic physical ports information.
nic_physical_ports = resource2.Body('nic_physical_ports')
#: Server's chassis status information.
chassis_status = resource2.Body('chassis-status')
#: managed_by_service
managed_by_service = resource2.Body('managed_by_service')
media_attachments = resource2.Body('media_attachments')
#: key_pair name
key_name = resource2.Body('key_name')
def create(self, session, **attrs):
body = {"server": attrs}
resp = session.post(
self.base_path, endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"}
)
self._translate_response(resp, has_body=True)
return self
def update(self, session, server_id, **attrs):
url = "%s/%s" % (self.base_path, server_id)
body = {"server": attrs}
resp = session.put(url,
endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"})
self._translate_response(resp, has_body=True)
return self
class ServerAction(resource2.Resource):
resource_key = "console"
resources_key = None
base_path = '/servers/%s/action'
service = baremetal_service.BaremetalService()
# Properties
#: Type of the remote console. Valid values are IPMI or IMM.
type = resource2.Body('type')
#: URL to access the remote console.
url = resource2.Body('url')
#: User ID for sign in to the remote console.
user_id = resource2.Body('user_id')
#: Password for sign in to the remote console.
password = resource2.Body('password')
def start(self, session, server_id):
uri = self.base_path % server_id
body = {"os-start": None}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def stop(self, session, server_id, shutdown_type):
uri = self.base_path % server_id
if shutdown_type is None:
body = {"os-stop": None}
else:
body = {"os-stop": {"type": shutdown_type}}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def reboot(self, session, server_id, shutdown_type):
uri = self.base_path % server_id
body = {
"reboot": {
"type": shutdown_type,
}
}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def change_boot_mode(self, session, server_id, shutdown_type, boot_mode):
uri = self.base_path % server_id
body = {
"boot_mode": {
"type": shutdown_type,
"boot_mode": boot_mode
}
}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def media_attach(self, session, server_id, image):
uri = self.base_path % server_id
body = {
"media-attach": {
"imageRef": image
}
}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def media_detach(self, session, server_id, image):
uri = self.base_path % server_id
body = {
"media-detach": {
"imageRef": image
}
}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body
)
self._translate_response(resp, has_body=False)
return self
def get_management_console(self, session, server_id):
uri = self.base_path % server_id
body = {
"os-getManagementConsole": None
}
resp = session.post(
uri,
endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"}
)
self._translate_response(resp, has_body=True)
return self
@classmethod
def find(cls, session, name_or_id, ignore_missing=False, **params):
"""Find a resource by its name or id.
:param session: The session to use for making this request.
:type session: :class:`~ecl.session.Session`
:param name_or_id: This resource's identifier, if needed by
the request. The default is ``None``.
:param bool ignore_missing: When set to ``False``
:class:`~ecl.exceptions.ResourceNotFound` will be
raised when the resource does not exist.
When set to ``True``, None will be returned when
attempting to find a nonexistent resource.
:param dict params: Any additional parameters to be passed into
underlying methods, such as to
:meth:`~ecl.resource2.Resource.existing`
in order to pass on URI parameters.
:return: The :class:`Resource` object matching the given name or id
or None if nothing matches.
:raises: :class:`ecl.exceptions.DuplicateResource` if more
than one resource is found for this request.
:raises: :class:`ecl.exceptions.ResourceNotFound` if nothing
is found and ignore_missing is ``False``.
"""
# Try to short-circuit by looking directly for a matching ID.
data = cls.list(session, **params)
result = cls._get_one_match(name_or_id, data)
if result is not None:
return result
if ignore_missing:
return None
raise exceptions.ResourceNotFound(
"No %s found for %s" % (cls.__name__, name_or_id))
class Metadata(resource2.Resource):
resource_key = None
resources_key = None
base_path = '/servers/%(server_id)s/metadata'
service = baremetal_service.BaremetalService()
# Capabilities
allow_list = True
allow_show = True
allow_create = True
allow_delete = True
# Properties
#: Metadata of the server.
metadata = resource2.Body("metadata")
def list(self, session, server_id):
uri = self.base_path % {"server_id" : server_id}
resp = session.get(uri, endpoint_filter=self.service,
headers={"Accept": "application/json"})
self._translate_response(resp, has_body=True)
return self
def get(self, session, server_id, key):
uri = self.base_path + '/%(key)s'
uri = uri % {"server_id":server_id, "key":key}
resp = session.get(uri, endpoint_filter=self.service,
headers={"Accept": "application/json"})
self._translate_response(resp, has_body=True)
return self
def delete(self, session, server_id, key):
uri = self.base_path + '/%(key)s'
uri = uri % {"server_id": server_id, "key": key}
resp = session.delete(uri, endpoint_filter=self.service,
headers={"Accept": ""})
self._translate_response(resp, has_body=False)
return self
def merge(self, session, server_id, **attrs):
uri = self.base_path % {"server_id" : server_id}
body = {"metadata": attrs}
resp = session.post(
uri, endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"}
)
self._translate_response(resp, has_body=True)
return self
def replace(self, session, server_id, **attrs):
uri = self.base_path % {"server_id" : server_id}
body = attrs
resp = session.put(
uri, endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"}
)
self._translate_response(resp, has_body=True)
return self
def update(self, session, server_id, key, **attrs):
uri = self.base_path + '/%(key)s'
uri = uri % {"server_id": server_id, "key": key}
body = attrs
resp = session.put(
uri, endpoint_filter=self.service,
json=body,
headers={"Accept": "application/json"}
)
self._translate_response(resp, has_body=True)
return self
