def update(self, mac_address, vlan_id=None):
"""Update attributes of static MAC
:param mac_address: MAC address that should be forwarded to this port
:param vlan_id: If specified, defines which packets tagged with
specific VLANId should be forwarded to this port
"""
if not isinstance(mac_address, type("")):
raise exceptions.InvalidParameterValueError(
parameter="mac_address",
value=mac_address,
valid_values="string",
)
data = {"MACAddress": mac_address}
if vlan_id is not None:
if not isinstance(vlan_id, int):
raise exceptions.InvalidParameterValueError(
parameter="vlan_id",
value=vlan_id,
valid_values="int",
)
data["VLANId"] = vlan_id
self._conn.patch(self.path, data=data)
def update(self, bootable=None, erased=None):
"""Update volume properties
:param bootable: Change bootable ability of the volume
:param erased: Provide information if the drive was erased
:raises: BadRequestError if at least one param isn't specified
"""
if bootable is None and erased is None:
raise ValueError('At least "bootable" or "erased" parameter has '
'to be specified')
if bootable and not isinstance(bootable, bool):
raise exceptions.InvalidParameterValueError(
parameter='bootable',
value=bootable,
valid_values=[True, False])
if erased and not isinstance(erased, bool):
raise exceptions.InvalidParameterValueError(
parameter='erased', value=erased, valid_values=[True, False])
data = {'Oem': {'Intel_RackScale': {}}}
if bootable is not None:
data['Oem']['Intel_RackScale']['Bootable'] = bootable
if erased is not None:
data['Oem']['Intel_RackScale']['Erased'] = erased
self._conn.patch(self.path, data=data)
def set_system_boot_options(self, target=None, enabled=None, mode=None):
"""Set boot source and/or boot frequency and/or boot mode.
Set the boot source and/or boot frequency and/or boot mode to use
on next reboot of the System.
:param target: The target boot source, optional.
:param enabled: The frequency, whether to set it for the next
reboot only (BOOT_SOURCE_ENABLED_ONCE) or persistent to all
future reboots (BOOT_SOURCE_ENABLED_CONTINUOUS) or disabled
(BOOT_SOURCE_ENABLED_DISABLED), optional.
:param mode: The boot mode (UEFI: BOOT_SOURCE_MODE_UEFI or
BIOS: BOOT_SOURCE_MODE_BIOS), optional.
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
data = collections.defaultdict(dict)
if target is not None:
valid_targets = self.get_allowed_system_boot_source_values()
if target not in valid_targets:
raise exceptions.InvalidParameterValueError(
parameter='target',
value=target,
valid_values=valid_targets)
fishy_target = sys_maps.BOOT_SOURCE_TARGET_MAP_REV[target]
data['Boot']['BootSourceOverrideTarget'] = fishy_target
if enabled is not None:
if enabled not in sys_maps.BOOT_SOURCE_ENABLED_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='enabled',
value=enabled,
valid_values=list(sys_maps.BOOT_SOURCE_ENABLED_MAP_REV))
fishy_freq = sys_maps.BOOT_SOURCE_ENABLED_MAP_REV[enabled]
data['Boot']['BootSourceOverrideEnabled'] = fishy_freq
if mode is not None:
if mode not in sys_maps.BOOT_SOURCE_MODE_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='mode',
value=mode,
valid_values=list(sys_maps.BOOT_SOURCE_MODE_MAP_REV))
fishy_mode = sys_maps.BOOT_SOURCE_MODE_MAP_REV[mode]
data['Boot']['BootSourceOverrideMode'] = fishy_mode
# TODO(lucasagomes): Check the return code and response body ?
# Probably we should call refresh() as well.
self._conn.patch(self.path, data=data)
def set_system_boot_source(self,
target,
enabled=sys_cons.BOOT_SOURCE_ENABLED_ONCE,
mode=None):
"""Set the boot source.
Set the boot source to use on next reboot of the System.
:param target: The target boot source.
:param enabled: The frequency, whether to set it for the next
reboot only (BOOT_SOURCE_ENABLED_ONCE) or persistent to all
future reboots (BOOT_SOURCE_ENABLED_CONTINUOUS) or disabled
(BOOT_SOURCE_ENABLED_DISABLED).
:param mode: The boot mode, UEFI (BOOT_SOURCE_MODE_UEFI) or
BIOS (BOOT_SOURCE_MODE_BIOS).
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
valid_targets = self.get_allowed_system_boot_source_values()
if target not in valid_targets:
raise exceptions.InvalidParameterValueError(
parameter='target', value=target, valid_values=valid_targets)
if enabled not in sys_maps.BOOT_SOURCE_ENABLED_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='enabled',
value=enabled,
valid_values=list(sys_maps.BOOT_SOURCE_ENABLED_MAP_REV))
data = {
'Boot': {
'BootSourceOverrideTarget':
sys_maps.BOOT_SOURCE_TARGET_MAP_REV[target],
'BootSourceOverrideEnabled':
sys_maps.BOOT_SOURCE_ENABLED_MAP_REV[enabled]
}
}
if mode is not None:
if mode not in sys_maps.BOOT_SOURCE_MODE_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='mode',
value=mode,
valid_values=list(sys_maps.BOOT_SOURCE_MODE_MAP_REV))
data['Boot']['BootSourceOverrideMode'] = (
sys_maps.BOOT_SOURCE_MODE_MAP_REV[mode])
# TODO(lucasagomes): Check the return code and response body ?
# Probably we should call refresh() as well.
self._conn.patch(self.path, data=data)
def set_node_boot_source(self,
target,
enabled=node_cons.BOOT_SOURCE_ENABLED_ONCE,
mode=None):
"""Set the boot source.
Set the boot source to use on next reboot of the Node.
:param target: The target boot source.
:param enabled: The frequency, whether to set it for the next
reboot only (BOOT_SOURCE_ENABLED_ONCE) or persistent to all
future reboots (BOOT_SOURCE_ENABLED_CONTINUOUS) or disabled
(BOOT_SOURCE_ENABLED_DISABLED).
:param mode: The boot mode, UEFI (BOOT_SOURCE_MODE_UEFI) or
Legacy (BOOT_SOURCE_MODE_LEGACY).
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
valid_targets = self.get_allowed_node_boot_source_values()
if target not in valid_targets:
raise exceptions.InvalidParameterValueError(
parameter='target', value=target, valid_values=valid_targets)
if enabled not in node_maps.BOOT_SOURCE_ENABLED_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='enabled',
value=enabled,
valid_values=list(node_maps.BOOT_SOURCE_ENABLED_MAP_REV))
data = {
'Boot': {
'BootSourceOverrideTarget':
node_maps.BOOT_SOURCE_TARGET_MAP_REV[target],
'BootSourceOverrideEnabled':
node_maps.BOOT_SOURCE_ENABLED_MAP_REV[enabled]
}
}
if mode is not None:
if mode not in node_maps.BOOT_SOURCE_MODE_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='mode',
value=mode,
valid_values=list(node_maps.BOOT_SOURCE_MODE_MAP_REV))
data['Boot']['BootSourceOverrideMode'] = (
node_maps.BOOT_SOURCE_MODE_MAP_REV[mode])
self._conn.patch(self.path, data=data)
def attach_endpoint(self, endpoint=None, capacity=None):
"""Attach endpoint from available pool to composed node
:param endpoint: Link to endpoint to attach.
:param capacity: Requested capacity of the drive in GiB.
:raises: InvalidParameterValueError
:raises: BadRequestError if at least one param isn't specified
"""
attach_action = self._get_attach_endpoint_action_element()
valid_endpoints = attach_action.allowed_values
target_uri = attach_action.target_uri
if endpoint and endpoint not in valid_endpoints:
raise exceptions.InvalidParameterValueError(
parameter="endpoint",
value=endpoint,
valid_values=valid_endpoints,
)
data = {}
if endpoint is not None:
data["Resource"] = {"@odata.id": endpoint}
if capacity is not None:
data["CapacityGiB"] = capacity
self._conn.post(target_uri, data=data)
def simple_update(self,
image_uri,
targets=None,
transfer_protocol=up_cons.UPDATE_PROTOCOL_HTTP):
"""Simple Update is used to update software components"""
valid_transfer_protocols = self.get_allowed_transfer_protocols()
if transfer_protocol in valid_transfer_protocols:
transfer_protocol = up_maps.TRANSFER_PROTOCOL_TYPE_VALUE_MAP_REV[
transfer_protocol]
else:
legacy_transfer_protocols = self._get_legacy_transfer_protocols()
if transfer_protocol not in legacy_transfer_protocols:
raise exceptions.InvalidParameterValueError(
parameter='transfer_protocol',
value=transfer_protocol,
valid_values=valid_transfer_protocols)
LOG.warning(
'Legacy transfer protocol constant %s is being used. '
'Consider migrating to any of: %s', transfer_protocol,
', '.join(up_maps.TRANSFER_PROTOCOL_TYPE_VALUE_MAP_REV))
target_uri = self._get_simple_update_element().target_uri
LOG.debug('Updating software component %s via '
'%s ...', image_uri, target_uri)
data = {'ImageURI': image_uri, 'TransferProtocol': transfer_protocol}
if targets:
data['Targets'] = targets
self._conn.post(target_uri, data=data)
def resize(self, num_bytes):
"""Update volume properties
:param num_bytes: size in bytes of new resized volume
"""
if not isinstance(num_bytes, int):
raise exceptions.InvalidParameterValueError(parameter='num_bytes',
value=num_bytes,
valid_values='integer')
if self.capacity_bytes and num_bytes <= self.capacity_bytes:
raise exceptions.InvalidParameterValueError(
parameter='num_bytes',
value=num_bytes,
valid_values='> {0}'.format(self.capacity_bytes))
data = {"Capacity": {"Data": {'AllocatedBytes': num_bytes}}}
self._conn.patch(self.path, data=data)
def set_enabled(self, enabled):
"""Enable/disable secure boot.
:param enabled: True, if secure boot is enabled for next boot.
"""
if not isinstance(enabled, bool):
raise exceptions.InvalidParameterValueError(
"Expected a boolean for 'enabled', got %r" % enabled)
self._conn.patch(self.path, data={'SecureBootEnable': enabled})
def set_system_boot_source(self, target, enabled="Once", mode=None):
"""Set the boot source.
Set the boot source to use on next reboot of the System.
:param target: The target boot source.
:param enabled: The frequency, whether to set it for the next
reboot only ("Once") or persistent to all future reboots
("Continuous") or disabled ("Disabled").
:param mode: The boot mode, UEFI ("UEFI") or BIOS ("Legacy").
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
valid_targets = self.get_allowed_system_boot_source_values()
if target not in valid_targets:
raise exceptions.InvalidParameterValueError(
parameter="target", value=target, valid_values=valid_targets
)
if enabled not in constants.BOOT_SOURCE_ENABLED_VALUE:
raise exceptions.InvalidParameterValueError(
parameter="enabled",
value=enabled,
valid_values=constants.BOOT_SOURCE_ENABLED_VALUE,
)
data = {
"Boot": {
"BootSourceOverrideTarget": target,
"BootSourceOverrideEnabled": enabled,
}
}
if mode is not None:
valid_modes = self.get_allowed_system_boot_mode_values()
if mode not in valid_modes:
raise exceptions.InvalidParameterValueError(
parameter="mode", value=mode, valid_values=valid_modes
)
data["Boot"]["BootSourceOverrideMode"] = mode
self._conn.patch(self.path, data=data)
def update(self, asset_tag=None, erase_on_detach=None, erased=None):
"""Update drive properties
:param asset_tag: The user assigned asset tag for this drive
:param erase_on_detach: Indicates if drive should be erased when
detached from Composed Node.
:param erased: Indicate whether drive was cleared after assignment to
composed node
:raises: InvalidParameterValueError if one param is incorrect
"""
data = {}
if asset_tag is not None:
data["AssetTag"] = asset_tag
if erase_on_detach is not None or erased is not None:
data["Oem"] = {"Intel_RackScale": {}}
if erase_on_detach is not None:
if not isinstance(erase_on_detach, bool):
raise exceptions.InvalidParameterValueError(
parameter="erase_on_detach",
value=erase_on_detach,
valid_values=[True, False],
)
else:
data["Oem"]["Intel_RackScale"][
"EraseOnDetach"] = erase_on_detach
if erased is not None:
if not isinstance(erased, bool):
raise exceptions.InvalidParameterValueError(
parameter="erased",
value=erased,
valid_values=[True, False],
)
else:
data["Oem"]["Intel_RackScale"]["DriveErased"] = erased
self._conn.patch(self.path, data=data)
def simple_update(self,
image_uri,
targets=None,
transfer_protocol=up_cons.UPDATE_PROTOCOL_HTTP):
"""Simple Update is used to update software components.
:returns: A task monitor.
"""
valid_transfer_protocols = self.get_allowed_transfer_protocols()
if transfer_protocol in valid_transfer_protocols:
transfer_protocol = up_maps.TRANSFER_PROTOCOL_TYPE_VALUE_MAP_REV[
transfer_protocol]
else:
legacy_transfer_protocols = self._get_legacy_transfer_protocols()
if transfer_protocol not in legacy_transfer_protocols:
raise exceptions.InvalidParameterValueError(
parameter='transfer_protocol',
value=transfer_protocol,
valid_values=valid_transfer_protocols)
LOG.warning(
'Legacy transfer protocol constant %s is being used. '
'Consider migrating to any of: %s', transfer_protocol,
', '.join(up_maps.TRANSFER_PROTOCOL_TYPE_VALUE_MAP_REV))
target_uri = self._get_simple_update_element().target_uri
LOG.debug('Updating software component %s via '
'%s ...', image_uri, target_uri)
data = {'ImageURI': image_uri, 'TransferProtocol': transfer_protocol}
if targets:
data['Targets'] = targets
rsp = self._conn.post(target_uri, data=data)
json_data = rsp.json() if rsp.content else {}
field_data = base.FieldData(rsp.status_code, rsp.headers, json_data)
header = 'Location'
task_monitor = rsp.headers.get(header)
if not task_monitor:
raise exceptions.MissingHeaderError(target_uri=target_uri,
header=header)
return taskmonitor.TaskMonitor(self._conn,
task_monitor,
redfish_version=self.redfish_version,
registries=self.registries,
field_data=field_data)
def initialize_volume(self, value):
"""Initialize the volume.
:param value: The InitializeType value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_values = self.get_allowed_initialize_volume_values()
if value not in valid_values:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_values)
value = store_maps.VOLUME_INIT_TYPE_MAP_REV[value]
target_uri = self._get_initialize_action_element().target_uri
self._conn.post(target_uri, data={'InitializeType': value})
def update(self, clear_tpm_on_delete=None, pm_on_delete=None):
"""Update properties of this composed node
:param clear_tpm_on_delete: This is used to specify if TPM module
should be cleared on composed node DELETE request.
:param pm_on_delete: This is used to specify what operation should be
performed on Intel OptaneTM DC Persistent Memory on ComposedNode
DELETE Request:
- PreserveConfiguration
- SecureErase
- OverwritePCD
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
if clear_tpm_on_delete is None and pm_on_delete is None:
raise ValueError('At least "clear_tpm_on_delete" or "pm_on_delete"'
' parameter has to be specified')
data = {}
if clear_tpm_on_delete is not None:
if not isinstance(clear_tpm_on_delete, bool):
raise exceptions.InvalidParameterValueError(
parameter='clear_tpm_on_delete',
value=clear_tpm_on_delete,
valid_values=[True, False])
data['ClearTPMOnDelete'] = clear_tpm_on_delete
if pm_on_delete is not None:
if pm_on_delete not in PM_OPENATION_ON_DELETE_VALUES:
raise exceptions.InvalidParameterValueError(
parameter='pm_on_delete',
value=pm_on_delete,
valid_values=PM_OPENATION_ON_DELETE_VALUES)
data['PersistentMemoryOperationOnDelete'] = pm_on_delete
self._conn.patch(self.path, data=data)
def reset_keys(self, reset_type):
"""Reset secure boot keys.
:param reset_type: Reset type, one of `SECORE_BOOT_RESET_KEYS_*`
constants.
"""
valid_resets = self.get_allowed_reset_keys_values()
if reset_type not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='reset_type',
value=reset_type,
valid_values=valid_resets)
target_uri = self._get_reset_action_element().target_uri
self._conn.post(target_uri, data={'ResetKeysType': reset_type})
def reset_port(self, value):
"""Reset the port.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_port_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter="value", value=value, valid_values=valid_resets)
target_uri = self._get_reset_action_element().target_uri
self._conn.post(target_uri, data={"ResetType": value})
def initialize(self, init_type):
"""Change initialize type of this volume
:param type: volume initialize type
:raises: InvalidParameterValueError if invalid "type" parameter
"""
allowed_init_type_values = ['Fast', 'Slow']
if init_type not in allowed_init_type_values:
raise exceptions.InvalidParameterValueError(
parameter='init_type', value=init_type,
valid_values=allowed_init_type_values)
data = {"InitializeType": init_type}
target_uri = self._get_initialize_action_element().target_uri
self._conn.post(target_uri, data=data)
def reset_node(self, value):
"""Reset the node.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_node_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_resets)
value = node_maps.RESET_NODE_VALUE_MAP_REV[value]
target_uri = self._get_reset_action_element().target_uri
self._conn.post(target_uri, data={'ResetType': value})
def simple_update(self, image_uri, targets, transfer_protocol='HTTP'):
"""Simple Update is used to update software components"""
transfer_protocol = transfer_protocol
valid_transfer_protocols = self.get_allowed_transfer_protocol_values()
if transfer_protocol not in valid_transfer_protocols:
raise exceptions.InvalidParameterValueError(
parameter='transfer_protocol',
value=transfer_protocol,
valid_values=valid_transfer_protocols)
self._conn.post(
data={
'ImageURI': image_uri,
'Targets': targets,
'TransferProtocol': transfer_protocol
})
def update(self, clear_tpm_on_delete):
"""Update properties of this composed node
:param clear_tpm_on_delete: This is used to specify if TPM module
should be cleared on composed node DELETE request.
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
if not isinstance(clear_tpm_on_delete, bool):
raise exceptions.InvalidParameterValueError(
parameter='clear_tpm_on_delete',
value=clear_tpm_on_delete,
valid_values=[True, False])
data = {'ClearTPMOnDelete': clear_tpm_on_delete}
self._conn.patch(self.path, data=data)
def bind_port(self, port):
"""Bind port from this switch ACL
:param port: Link to port to bind.
:raises: InvalidParameterValueError
"""
bind_action = self._get_bind_action_element()
valid_ports = bind_action.allowed_values
target_uri = bind_action.target_uri
if port and port not in valid_ports:
raise exceptions.InvalidParameterValueError(
parameter="port", value=port, valid_values=valid_ports)
data = {"Port": {"@odata.id": port}}
self._conn.post(target_uri, data=data)
def reset_manager(self, value):
"""Reset the manager.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_manager_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_resets)
value = mgr_maps.RESET_MANAGER_VALUE_MAP_REV[value]
target_uri = self._get_reset_action_element().target_uri
LOG.debug('Resetting the Manager %s ...', self.identity)
self._conn.post(target_uri, data={'ResetType': value})
LOG.info('The Manager %s is being reset', self.identity)
def set_indicator_led(self, state):
"""Set IndicatorLED to the given state.
:param state: Desired LED state, lit (INDICATOR_LED_LIT), blinking
(INDICATOR_LED_BLINKING), off (INDICATOR_LED_OFF)
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
if state not in res_maps.INDICATOR_LED_VALUE_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='state',
value=state,
valid_values=list(res_maps.INDICATOR_LED_VALUE_MAP_REV))
data = {'IndicatorLED': res_maps.INDICATOR_LED_VALUE_MAP_REV[state]}
self._conn.patch(self.path, data=data)
self.invalidate()
def reset_system(self, value):
"""Reset the system.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_system_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_resets)
value = sys_maps.RESET_SYSTEM_VALUE_MAP_REV[value]
target_uri = self._get_reset_action_element().target_uri
# TODO(lucasagomes): Check the return code and response body ?
# Probably we should call refresh() as well.
self._conn.post(target_uri, data={'ResetType': value})
def detach_endpoint(self, endpoint):
"""Detach already attached endpoint from composed node
:param endpoint: Link to endpoint to detach
:raises: InvalidParameterValueError
:raises: BadRequestError
"""
detach_action = self._get_detach_endpoint_action_element()
valid_endpoints = detach_action.allowed_values
target_uri = detach_action.target_uri
if endpoint not in valid_endpoints:
raise exceptions.InvalidParameterValueError(
parameter='endpoint',
value=endpoint,
valid_values=valid_endpoints)
data = {'Resource': endpoint}
self._conn.post(target_uri, data=data)
def detach_endpoint(self, resource):
"""Detach endpoint from available pool to composed node
:param resource: Link to endpoint to detach.
:raises: InvalidParameterValueError
"""
detach_action = self._get_detach_endpoint_action_element()
valid_endpoints = self.get_allowed_detach_endpoints()
target_uri = detach_action.target_uri
if resource not in valid_endpoints:
raise exceptions.InvalidParameterValueError(
parameter='resource',
value=resource,
valid_values=valid_endpoints)
data = {}
if resource is not None:
data['Resource'] = {'@odata.id': resource}
self._conn.post(target_uri, data=data)
def _initialize(self,
value=store_cons.VOLUME_INIT_TYPE_FAST,
apply_time=None,
timeout=500):
valid_values = self.get_allowed_initialize_volume_values()
if value not in valid_values:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_values)
value = store_maps.VOLUME_INIT_TYPE_MAP_REV[value]
payload = {'InitializeType': value}
blocking = False
oat_prop = '@Redfish.OperationApplyTime'
if apply_time:
payload[oat_prop] = res_maps.APPLY_TIME_VALUE_MAP_REV[apply_time]
if (payload
and payload.get(oat_prop) == res_maps.APPLY_TIME_VALUE_MAP_REV[
res_cons.APPLY_TIME_IMMEDIATE]):
blocking = True
target_uri = self._get_initialize_action_element().target_uri
r = self._conn.post(target_uri,
data=payload,
blocking=blocking,
timeout=timeout)
return r, target_uri
def attach_endpoint(self, endpoint, protocol=None):
"""Attach endpoint from available pool to composed node
:param endpoint: Link to endpoint to attach.
:param protocol: Protocol of the remote drive.
:raises: InvalidParameterValueError
"""
attach_action = self._get_attach_endpoint_action_element()
valid_endpoints = attach_action.allowed_values
target_uri = attach_action.target_uri
if endpoint and endpoint not in valid_endpoints:
raise exceptions.InvalidParameterValueError(
parameter='endpoint',
value=endpoint,
valid_values=valid_endpoints)
data = {}
if endpoint is not None:
data['Resource'] = {'@odata.id': endpoint}
if protocol is not None:
data['Protocol'] = protocol
self._conn.post(target_uri, data=data)