rsd-lib/rsd_lib/resources/v2_3/fabric/endpoint.py

# Copyright 2018 Intel, Inc.
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import jsonschema
import logging

from sushy.resources import base
from sushy import utils

from rsd_lib import base as rsd_lib_base
from rsd_lib import common as rsd_lib_common
from rsd_lib.resources.v2_3.fabric import endpoint_schemas
from rsd_lib import utils as rsd_lib_utils


LOG = logging.getLogger(__name__)


class IdentifiersField(base.ListField):
    name_format = base.Field("DurableNameFormat")
    name = base.Field("DurableName")


class ConnectedEntitiesField(base.ListField):
    entity_type = base.Field("EntityType")
    entity_role = base.Field("EntityRole")
    entity_link = base.Field(
        "EntityLink", adapter=rsd_lib_utils.get_resource_identity
    )


class LinksField(base.CompositeField):
    ports = base.Field("Ports", adapter=utils.get_members_identities)
    endpoints = base.Field("Endpoints", adapter=utils.get_members_identities)
    zones = base.Field(
        ["Oem", "Intel_RackScale", "Zones"],
        adapter=utils.get_members_identities,
    )
    interface = base.Field(
        ["Oem", "Intel_RackScale", "Interface"],
        adapter=rsd_lib_utils.get_resource_identity,
    )


class IPTransportDetailsField(base.ListField):
    transport_protocol = base.Field("TransportProtocol")
    ipv4_address = base.Field(["IPv4Address", "Address"])
    ipv6_address = base.Field(["IPv6Address", "Address"])
    port = base.Field("Port", adapter=rsd_lib_utils.num_or_none)


class AuthenticationField(base.CompositeField):
    username = base.Field("Username")
    password = base.Field("Password")


class OemField(base.CompositeField):
    authentication = AuthenticationField(["Intel_RackScale", "Authentication"])


class Endpoint(rsd_lib_base.ResourceBase):

    connected_entities = ConnectedEntitiesField("ConnectedEntities")
    """Entities connected to endpoint"""

    description = base.Field("Description")
    """The endpoint description"""

    protocol = base.Field("EndpointProtocol")
    """Protocol for endpoint (i.e. PCIe)"""

    identifiers = IdentifiersField("Identifiers")
    """Identifiers for endpoint"""

    identity = base.Field("Id", required=True)
    """The endpoint identity string"""

    name = base.Field("Name")
    """The endpoint name"""

    status = rsd_lib_common.StatusField("Status")
    """The endpoint status"""

    links = LinksField("Links")
    """These links to related components of this endpoint"""

    ip_transport_details = IPTransportDetailsField("IPTransportDetails")
    """IP transport details info of this endpoint"""

    oem = OemField("Oem")
    """The OEM additional info of this endpoint"""

    def update_authentication(self, username=None, password=None):
        """Update endpoint authentication

        :param username: an endpoint username used to authenticate it on the
                         other side of a communication channel
        :param password: an endpoint password
        :raises: BadRequestError if at least one param isn't specified
        """
        if username is None and password is None:
            raise ValueError(
                'At least "username" or "password" parameter has '
                "to be specified"
            )

        data = {
            "Oem": {
                "Intel_RackScale": {
                    "@odata.type": "#Intel.Oem.Endpoint",
                    "Authentication": {},
                }
            }
        }
        if username is not None:
            data["Oem"]["Intel_RackScale"]["Authentication"][
                "Username"
            ] = username
        if password is not None:
            data["Oem"]["Intel_RackScale"]["Authentication"][
                "Password"
            ] = password

        self._conn.patch(self.path, data=data)


class EndpointCollection(rsd_lib_base.ResourceCollectionBase):
    @property
    def _resource_type(self):
        return Endpoint

    def _create_endpoint_request(
        self,
        identifiers,
        connected_entities,
        protocol=None,
        ip_transport_details=None,
        interface=None,
        authentication=None,
    ):

        request = {}

        jsonschema.validate(
            identifiers, endpoint_schemas.identifiers_req_schema
        )
        request["Identifiers"] = identifiers

        jsonschema.validate(
            connected_entities, endpoint_schemas.connected_entities_req_schema
        )
        request["ConnectedEntities"] = connected_entities

        if protocol is not None:
            jsonschema.validate(protocol, endpoint_schemas.protocol_req_schema)
            request["EndpointProtocol"] = protocol

        if ip_transport_details is not None:
            jsonschema.validate(
                ip_transport_details,
                endpoint_schemas.ip_transport_details_req_schema,
            )
            request["IPTransportDetails"] = ip_transport_details

        if interface is not None:
            jsonschema.validate(
                interface, endpoint_schemas.interface_req_schema
            )
            request["Links"] = {
                "Oem": {
                    "Intel_RackScale": {
                        "Interfaces": [{"@odata.id": interface}]
                    }
                }
            }

        if authentication is not None:
            jsonschema.validate(
                authentication, endpoint_schemas.authentication_req_schema
            )
            request["Oem"] = {
                "Intel_RackScale": {"Authentication": authentication}
            }

        return request

    def create_endpoint(
        self,
        identifiers,
        connected_entities,
        protocol=None,
        ip_transport_details=None,
        interface=None,
        authentication=None,
    ):
        """Create a new endpoint

        :param identifiers: provides iQN or NQN of created entity
        :param connected_entities: provides information about entities
                                   connected to the endpoint
        :param protocol: the protocol used by the endpoint
        :param ip_transport_details: the transport used for accessing the
                                     endpoint
        :param interface: the interface that should be used for the endpoint
                          connectivity
        :param authentication: authentication data for target-initiator
                               authentication. Currently supported only for the
                               iSCSI protocol.
        :returns: The uri of the new endpoint
        """
        properties = self._create_endpoint_request(
            identifiers,
            connected_entities,
            protocol,
            ip_transport_details,
            interface,
            authentication,
        )
        resp = self._conn.post(self._path, data=properties)
        LOG.info("Endpoint created at %s", resp.headers["Location"])
        endpoint_url = resp.headers["Location"]
        return endpoint_url[endpoint_url.find(self._path):]