@spec create_disallowed_host(MscmpSystAuthn.Types.host_address()) ::
  {:ok, Msdata.SystDisallowedHosts.t()} | {:error, MscmpSystError.t()}

Adds a host IP address to the global disallowed hosts list.

Disallowed hosts are IP addresses which are prevented from authenticating users with the system, and by extension prevents host access to application functions generally. Hosts are disallowed on a global basis and may be added to the list based on system heuristics which detect suspicious activity.

Successfully adding a host to the list returns a success tuple and a struct representing the record just created. Attempting to add a host which is already part of the list will also result in a success tuple, but no record is returned.

Parameters

• host_address - the IP address of the host to disallow.

Examples

Adding a new host to the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, false} = MssubMcp.host_disallowed(~i"10.123.123.20")
iex> {:ok, %Msdata.SystDisallowedHosts{}} =
...>   MssubMcp.create_disallowed_host(~i"10.123.123.20")copy

Attempting to add a host already on the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, true} = MssubMcp.host_disallowed(~i"10.123.123.3")
iex> {:ok, nil} =
...>   MssubMcp.create_disallowed_host(~i"10.123.123.3")copy

@spec create_global_network_rule(MscmpSystAuthn.Types.global_network_rule_params()) ::
  {:ok, Msdata.SystGlobalNetworkRules.t()} | {:error, MscmpSystError.t()}

Creates a new Global Network Rule using the provided parameters.

Global Network Rules are checked prior to all attempted user authentication events and have precedence over Owner and Instance Network Rules, though they are secondary to the Disallowed Hosts list.

On successful creation, a result tuple in the form {:ok, <new record>} is returned where the <new record> is the fully populated Data struct of the record just created. If an exception is raised this function will return a failure tuple in the form of {:error, <exception data>}.

Parameters

• insert_params - a map representing the values to use when creating the new Global Network Rule. See MscmpSystAuthn.Types.global_network_rule_params/0 for the available attributes.

Example

Adding a new "Allow" Global Network Rule for a CIDR network.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> new_global_rule = %{
...>   ordering: 20,
...>   functional_type: :allow,
...>   ip_host_or_network: ~i"10.100.150.0/24"
...> }
iex> {:ok, %Msdata.SystGlobalNetworkRules{}} =
...>   MssubMcp.create_global_network_rule(new_global_rule)copy

Adding a new "Deny" Global Network Rule for an IP Address range.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> new_global_rule = %{
...>   ordering: 21,
...>   functional_type: :deny,
...>   ip_host_or_network: nil,
...>   ip_host_range_lower: ~i"10.100.151.1",
...>   ip_host_range_upper: ~i"10.100.152.254"
...> }
iex> {:ok, %Msdata.SystGlobalNetworkRules{}} =
...>   MssubMcp.create_global_network_rule(new_global_rule)copy

@spec create_instance_network_rule(
  MscmpSystInstance.Types.instance_id(),
  MscmpSystAuthn.Types.instance_network_rule_params()
) :: {:ok, Msdata.SystInstanceNetworkRules.t()} | {:error, MscmpSystError.t()}

Creates a new Instance Network Rule using the provided parameters.

Instance Network Rules the checked after the Disallowed Hosts list, the Global Network Rules, and the Instance Network Rules and apply to all Instances owned by the specified Instance, unless a higher precedence rule already applies to the host.

On successful creation, a result tuple in the form {:ok, <new record>} is returned where the <new record> is the fully populated Data struct of the record just created. If an exception is raised this function will return a failure tuple in the form of {:error, <exception data>}.

Parameters

• instance_id - the record ID of the Instance for whom the Instance Network Rule is being created.

• insert_params - a map representing the values to use when creating the new Instance Network Rule. See MscmpSystAuthn.Types.instance_network_rule_params/0 for the available attributes.

Example

Adding a new "Allow" Instance Network Rule for a CIDR network.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, instance_id} =
...>   MssubMcp.get_instance_id_by_name("app1_owner8_instance_types_std")
iex> new_instance_rule = %{
...>   ordering: 1,
...>   functional_type: :allow,
...>   ip_host_or_network: ~i"10.100.170.0/24"
...> }
iex> {:ok, %Msdata.SystInstanceNetworkRules{}} =
...>   MssubMcp.create_instance_network_rule(instance_id, new_instance_rule)copy

Adding a new "Deny" Instance Network Rule for an IP Address range.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, instance_id} =
...>   MssubMcp.get_instance_id_by_name("app1_owner8_instance_types_std")
iex> new_instance_rule = %{
...>   ordering: 2,
...>   functional_type: :deny,
...>   ip_host_or_network: nil,
...>   ip_host_range_lower: ~i"10.100.171.1",
...>   ip_host_range_upper: ~i"10.100.172.254"
...> }
iex> {:ok, %Msdata.SystInstanceNetworkRules{}} =
...>   MssubMcp.create_instance_network_rule(instance_id, new_instance_rule)copy

@spec create_owner_network_rule(
  MscmpSystInstance.Types.owner_id(),
  MscmpSystAuthn.Types.owner_network_rule_params()
) :: {:ok, Msdata.SystOwnerNetworkRules.t()} | {:error, MscmpSystError.t()}

Creates a new Owner Network Rule using the provided parameters.

Owner Network Rules the checked after the Disallowed Hosts list, the Global Network Rules, and the Instance Network Rules and apply to all Instances owned by the specified Owner, unless a higher precedence rule already applies to the host.

On successful creation, a result tuple in the form {:ok, <new record>} is returned where the <new record> is the fully populated Data struct of the record just created. If an exception is raised this function will return a failure tuple in the form of {:error, <exception data>}.

Parameters

• owner_id - the record ID of the Owner for whom the Owner Network Rule is being created.

• insert_params - a map representing the values to use when creating the new Owner Network Rule. See MscmpSystAuthn.Types.owner_network_rule_params/0 for the available attributes.

Example

Adding a new "Allow" Owner Network Rule for a CIDR network.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, owner_id} = MssubMcp.get_owner_id_by_name("owner8")
iex> new_owner_rule = %{
...>   ordering: 1,
...>   functional_type: :allow,
...>   ip_host_or_network: ~i"10.100.160.0/24"
...> }
iex> {:ok, %Msdata.SystOwnerNetworkRules{}} =
...>   MssubMcp.create_owner_network_rule(owner_id, new_owner_rule)copy

Adding a new "Deny" Owner Network Rule for an IP Address range.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, owner_id} = MssubMcp.get_owner_id_by_name("owner8")
iex> new_owner_rule = %{
...>   ordering: 2,
...>   functional_type: :deny,
...>   ip_host_or_network: nil,
...>   ip_host_range_lower: ~i"10.100.161.1",
...>   ip_host_range_upper: ~i"10.100.162.254"
...> }
iex> {:ok, %Msdata.SystOwnerNetworkRules{}} =
...>   MssubMcp.create_owner_network_rule(owner_id, new_owner_rule)copy

@spec delete_disallowed_host(
  MscmpSystAuthn.Types.disallowed_host_id()
  | Msdata.SystDisallowedHosts.t()
) ::
  {:ok, :deleted | :not_found} | {:error, MscmpSystError.t()}

Deletes a host IP address from the Disallowed Hosts list based on either a Msdata.SystDisallowedHosts record or the ID of such a record.

If the record is found and deleted a success tuple in the form {:ok, :deleted} is returned. If the record is not found the success tuple {:ok, :not_found} is returned.

Once a host is removed from the Disallowed Hosts list, users are allowed to authenticate from the host, so long as no other effective Network Rule prevents the action.

Parameters

• disallowed_host - either the fully populated Msdata.SystDisallowedHosts data struct for the record to delete or the ID of the record. Note that when the data struct is provided Ecto optimistic locking is applied to the the delete operation.

Examples

Deleting a host by record ID.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, target_host_record} =
...>   MssubMcp.get_disallowed_host_record_by_host(~i"10.10.250.4")
iex> MssubMcp.delete_disallowed_host(target_host_record.id)
{:ok, :deleted}copy

Deleting a host by record struct.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, target_host_record} =
...>   MssubMcp.get_disallowed_host_record_by_host(~i"10.10.250.5")
iex> MssubMcp.delete_disallowed_host(target_host_record)
{:ok, :deleted}copy

Deleting a struct for a no longer existent record.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, target_host_record} =
...>   MssubMcp.get_disallowed_host_record_by_host(~i"10.10.250.6")
iex> MssubMcp.delete_disallowed_host(target_host_record)
{:ok, :deleted}
iex> MssubMcp.delete_disallowed_host(target_host_record)
{:ok, :not_found}copy

@spec delete_disallowed_host_addr(MscmpSystAuthn.Types.host_address()) ::
  {:ok, :deleted | :not_found} | {:error, MscmpSystError.t()}

Deletes a host IP address from the Disallowed Hosts list as looked up by the host IP address.

If the record is found and deleted a success tuple in the form {:ok, :deleted} is returned. If the record is not found the success tuple {:ok, :not_found} is returned. Any other condition would cause an error tuple to be returned.

Once a host is removed from the Disallowed Hosts list, users are allowed to authenticate from the host, so long as no other effective Network Rule prevents the action.

Parameters

• host_addr - the IP address of the host that is no longer to be disallowed.

Examples

Deleting a host that does exist in the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, true} = MssubMcp.host_disallowed(~i"10.10.251.1")
iex> {:ok, :deleted} =
...>   MssubMcp.delete_disallowed_host_addr(~i"10.10.251.1")
iex> {:ok, false} = MssubMcp.host_disallowed(~i"10.10.251.1")copy

Attempting to delete a host not already on the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, false} = MssubMcp.host_disallowed(~i"10.10.251.10")
iex> {:ok, :not_found} =
...>   MssubMcp.delete_disallowed_host_addr(~i"10.10.251.10")copy

@spec delete_global_network_rule(Ecto.UUID.t()) ::
  :ok | {:error, MscmpSystError.t() | Exception.t()}

Deletes an existing Global Network Rule record as referenced by the record ID.

On successful deletion, a simple result of :ok is returned. On error, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• global_network_rule_id - The record ID of the Global Network Rule record to delete.

@spec delete_instance_network_rule(Ecto.UUID.t()) ::
  :ok | {:error, MscmpSystError.t() | Exception.t()}

Deletes an existing Instance Network Rule record as referenced by the record ID.

On successful deletion, a simple result of :ok is returned. On error, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• instance_network_rule_id - The record ID of the Instance Network Rule record to delete.

@spec delete_owner_network_rule(Ecto.UUID.t()) ::
  :ok | {:error, MscmpSystError.t() | Exception.t()}

Deletes an existing Owner Network Rule record as referenced by the record ID.

On successful deletion, a simple result of :ok is returned. On error, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• owner_network_rule_id - The record ID of the Owner Network Rule record to delete.

@spec get_applied_network_rule(
  MscmpSystAuthn.Types.host_address(),
  MscmpSystInstance.Types.instance_id() | nil,
  MscmpSystInstance.Types.owner_id() | nil
) ::
  {:ok, MscmpSystAuthn.Types.AppliedNetworkRule.t()}
  | {:error, MscmpSystError.t() | Exception.t()}

Returns the Network Rule which should be applied for the given Host IP Address.

This function compares the provided Host IP Address against the applicable Network Rules which apply to it and return the specific rule which should be applied during the authentication process.

Network Rule Precedence

The specific rules to check for applicability depends on the other provided parameters. The available Network Rule sets in order of precedence are:

1. Disallowed Hosts: Globally disallowed hosts are always checked first and no later rule can override the denial. Only removing the host from the Disallowed Hosts List can reverse this denial.

2. Global Network Rules: These are rules applied to all presented Host IP Addresses.

3. Instance Network Rules: Rules defined by Instance Owners and are the most granular rule level available. These Network Rules are only evaluated if the instance_id parameter is provided.

4. Owner Network Rules: Network Rules which are applicable to all Instances of a given Owner, provided no superseding Instance Network Rule was found. This rule set is included if either the instance_id or owner_id parameter is provided.

5. Default Network Rule: When no explicitly defined Network Rule has been found for a host, this rule will apply implicitly. The current rule grants access from any host.

Return Value

This function returns a result tuple. The value element of the result tuple is a map of type MscmpSystAuthn.Types.AppliedNetworkRule.t/0. The map indicates which precedence group the rule came from, the ID of the Network Rule record if the rule was derived from the various Network Rule data tables, and the Functional Type of the rule: :allow meaning the rule explicitly allows the host to attempt an authentication, or :deny indicating that the host is not allowed to attempt authentication.

Parameters

• host_address - the Host IP Address which the user wishes to authenticate from.

• instance_id - the record ID of an Instance to which the user wants to gain access. This parameter is optional, though excluding this parameter will leave the Instance Network Rules might properly apply unevaluated. If this parameter is provided, the Owner of the Instance is implied and there is no need to also supply the owner_id parameter.

• owner_id - the record ID of an Owner which owns the candidate Instances to which the user wishes to authenticate. This parameter is not required if the instance_id parameter has been provided. Otherwise, this parameter is optional, though if the Owner has not been resolved through this parameter or via the instance_id, the Owner Network Rules that might apply to the authentication attempt will not be applied.

Examples

When the host is a member of the Disallowed Hosts lists.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok,
...>   %MscmpSystAuthn.Types.AppliedNetworkRule{
...>     functional_type: :deny, network_rule_id: id, precedence: :disallowed
...>   }
...>  } = MssubMcp.get_applied_network_rule(~i"10.123.123.3")
iex> is_binary(id)
truecopy

When the Host IP Address does not match any explicitly defined rule and the implicit rule applies.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.get_applied_network_rule(~i"10.124.124.3")
{:ok,
  %MscmpSystAuthn.Types.AppliedNetworkRule{
    functional_type: :allow, network_rule_id: nil, precedence: :implied
  }
}copy

When a Global Network Rule explicitly allows the Host IP Address to attempt authentication.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok,
...>   %MscmpSystAuthn.Types.AppliedNetworkRule{
...>     functional_type: :allow, network_rule_id: id, precedence: :global
...>   }
...> } = MssubMcp.get_applied_network_rule(~i"10.125.125.3")
iex> is_binary(id)
truecopy

Note that while the examples did not include Instance or Owner IDs, the examples are none-the-less representative of cases where they are included.

@spec get_applied_network_rule!(
  MscmpSystAuthn.Types.host_address(),
  MscmpSystInstance.Types.instance_id() | nil,
  MscmpSystInstance.Types.owner_id() | nil
) :: MscmpSystAuthn.Types.AppliedNetworkRule.t()

Returns the Network Rule which should be applied for the given Host IP Address, raising on error.

This function works the same as get_applied_network_rule/3 except this function returns its result without wrapping it in a result tuple. If an error is encountered an exception is raised.

Parameters

• host_address - the Host IP Address which the user wishes to authenticate from.

• instance_id - the record ID of an Instance to which the user wants to gain access. This parameter is optional, though excluding this parameter will leave the Instance Network Rules might properly apply unevaluated. If this parameter is provided, the Owner of the Instance is implied and there is no need to also supply the owner_id parameter.

• owner_id - the record ID of an Owner which owns the candidate Instances to which the user wishes to authenticate. This parameter is not required if the instance_id parameter has been provided. Otherwise, this parameter is optional, though if the Owner has not been resolved through this parameter or via the instance_id, the Owner Network Rules that might apply to the authentication attempt will not be applied.

Examples

When the host is a member of the Disallowed Hosts lists.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> %MscmpSystAuthn.Types.AppliedNetworkRule{
...>   functional_type: :deny, network_rule_id: id, precedence: :disallowed
...> } = MssubMcp.get_applied_network_rule!(~i"10.123.123.3")
iex> is_binary(id)
truecopy

When the Host IP Address does not match any explicitly defined rule and the implicit rule applies.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.get_applied_network_rule!(~i"10.124.124.3")
%MscmpSystAuthn.Types.AppliedNetworkRule{
  functional_type: :allow, network_rule_id: nil, precedence: :implied
}copy

When a Global Network Rule explicitly allows the Host IP Address to attempt authentication.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> %MscmpSystAuthn.Types.AppliedNetworkRule{
...>   functional_type: :allow, network_rule_id: id, precedence: :global
...> } = MssubMcp.get_applied_network_rule!(~i"10.125.125.3")
iex> is_binary(id)
truecopy

Note that while the examples did not include Instance or Owner IDs, the examples are none-the-less representative of cases where they are included.

@spec get_disallowed_host_record_by_host(MscmpSystAuthn.Types.host_address()) ::
  {:ok, Msdata.SystDisallowedHosts.t() | nil} | {:error, MscmpSystError.t()}

Retrieves a Disallowed Host record from the database as identified by its host address.

Parameters

• host_address - the IP address of the disallowed host record to retrieve.

Example

Retrieving a Disallowed Host record by IP address.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> {:ok, %Msdata.SystDisallowedHosts{}} =
...>   MssubMcp.get_disallowed_host_record_by_host(~i"10.123.123.4")copy

Attempting to retrieve a record for a host not on the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.get_disallowed_host_record_by_host(~i"10.125.120.20")
{:ok, nil}copy

@spec get_disallowed_host_record_by_host!(MscmpSystAuthn.Types.host_address()) ::
  Msdata.SystDisallowedHosts.t() | nil

Retrieves a Disallowed Host record from the database as identified by its host address, raising on error.

This function works the same as get_disallowed_host_record_by_host/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered an exception is raised.

Parameters

• host_address - the IP address of the disallowed host record to retrieve.

Example

Retrieving a Disallowed Host record by IP address.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> %Msdata.SystDisallowedHosts{} =
...>   MssubMcp.get_disallowed_host_record_by_host!(~i"10.123.123.4")copy

Attempting to retrieve a record for a host not on the list.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.get_disallowed_host_record_by_host!(~i"10.125.120.20")
nilcopy

@spec get_disallowed_host_record_by_id(MscmpSystAuthn.Types.disallowed_host_id()) ::
  {:ok, Msdata.SystDisallowedHosts.t()}
  | {:error, MscmpSystError.t() | Exception.t()}

Retrieves a Disallowed Host record by the record ID.

This function assumes the record exists. If the record does not exist an error tuple will be returned.

Parameters

• disallowed_host_id - the record ID of the Disallowed Host record to retrieve.

Example

Retrieving a Disallowed Host record by record ID.

  {:ok, %Msdata.SystDisallowedHosts{}} =
    MssubMcp.get_disallowed_host_record_by_id(
      "ad7f2030-5895-11ed-a888-0f8a20e745a9")copy

@spec get_disallowed_host_record_by_id!(MscmpSystAuthn.Types.disallowed_host_id()) ::
  Msdata.SystDisallowedHosts.t()

Retrieves a Disallowed Host record by the record ID, raising on error.

This function works the same as get_disallowed_host_record_by_id/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered, including if the record does not exist, an exception is raised.

Parameters

• disallowed_host_id - the record ID of the Disallowed Host record to retrieve.

Example

Retrieving a Disallowed Host record by record ID.

  %Msdata.SystDisallowedHosts{} =
    MssubMcp.get_disallowed_host_record_by_id!(
      "ad7f2030-5895-11ed-a888-0f8a20e745a9")copy

@spec get_global_network_rule(Ecto.UUID.t()) ::
  {:ok, Msdata.SystGlobalNetworkRules.t()}
  | {:ok, :not_found}
  | {:error, MscmpSystError.t() | Exception.t()}

Retrieves a Global Network Rule record based on its record ID.

For a given Global Network Rule record ID this function will return a result tuple in the form of {:ok, <record>} where <record> is the fully populated Msdata.SystGlobalNetworkRules. If the record does not exist, then {:ok, :not_found} is returned. Otherwise, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• global_network_rule_id - the record ID of the desired Global Network Rule record.

@spec get_global_network_rule!(Ecto.UUID.t()) ::
  Msdata.SystGlobalNetworkRules.t() | :not_found

Retrieves a Global Network Rule record based on its record ID, raising on error.

This function works the same as get_global_network_rule/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered, including if the record does not exist, an exception is raised.

Parameters

• global_network_rule_id - the record ID of the desired Global Network Rule record.

@spec get_instance_network_rule(Ecto.UUID.t()) ::
  {:ok, Msdata.SystInstanceNetworkRules.t()}
  | {:ok, :not_found}
  | {:error, MscmpSystError.t() | Exception.t()}

Retrieves a Instance Network Rule record based on its record ID.

For a given Instance Network Rule record ID this function will return a result tuple in the form of {:ok, <record>} where <record> is the fully populated Msdata.SystInstanceNetworkRules. If the record does not exist, then {:ok, :not_found} is returned. Otherwise, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• instance_network_rule_id - the record ID of the desired Instance Network Rule record.

@spec get_instance_network_rule!(Ecto.UUID.t()) ::
  Msdata.SystInstanceNetworkRules.t() | :not_found

Retrieves a Instance Network Rule record based on its record ID, raising on error.

This function works the same as get_instance_network_rule/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered, including if the record does not exist, an exception is raised.

Parameters

• instance_network_rule_id - the record ID of the desired Instance Network Rule record.

@spec get_owner_network_rule(Ecto.UUID.t()) ::
  {:ok, Msdata.SystOwnerNetworkRules.t()}
  | {:ok, :not_found}
  | {:error, MscmpSystError.t() | Exception.t()}

Retrieves a Owner Network Rule record based on its record ID.

For a given Owner Network Rule record ID this function will return a result tuple in the form of {:ok, <record>} where <record> is the fully populated Msdata.SystOwnerNetworkRules. If the record does not exist, then {:ok, :not_found} is returned. Otherwise, an error tuple in the form of {:error, <exception>} is returned.

Parameters

• owner_network_rule_id - the record ID of the desired Owner Network Rule record.

@spec get_owner_network_rule!(Ecto.UUID.t()) ::
  Msdata.SystOwnerNetworkRules.t() | :not_found

Retrieves a Owner Network Rule record based on its record ID, raising on error.

This function works the same as get_owner_network_rule/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered, including if the record does not exist, an exception is raised.

Parameters

• owner_network_rule_id - the record ID of the desired Owner Network Rule record.

@spec host_disallowed(MscmpSystAuthn.Types.host_address()) ::
  {:ok, boolean()} | {:error, MscmpSystError.t()}

Indicates whether the provided host IP address is to be denied access to the system.

This function returns a tuple in the form of {:ok, <disallowed>} where the disallowed value is either true meaning that the requested host is disallowed from authenticating with the system or false if the host is permitted to attempt an authentication.

Parameters

• host_address - the host IP address to test. Typically this will be the host address of a user wishing to authenticate with the system.

Examples

An allowed host will return a false result tuple.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.host_disallowed(~i"10.150.150.10")
{:ok, false}copy

A disallowed host returns a true result tuple.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.host_disallowed(~i"10.123.123.5")
{:ok, true}copy

@spec host_disallowed?(MscmpSystAuthn.Types.host_address()) :: boolean()

Indicates whether the provided host IP address is to be denied access to the system, raising on error.

This function works the same as host_disallowed/1 except this function returns its result without wrapping it in a result tuple. If an error is encountered an exception is raised.

Parameters

• host_address - the host IP address to test. Typically this will be the host address of a user wishing to authenticate with the system.

Examples

An allowed host will return a false value.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.host_disallowed?(~i"10.150.150.10")
falsecopy

A disallowed host returns a true value.

iex> import MscmpSystNetwork, only: [sigil_i: 2]
iex> MssubMcp.host_disallowed?(~i"10.123.123.5")
truecopy

@spec update_global_network_rule(
  Ecto.UUID.t() | Msdata.SystGlobalNetworkRules.t(),
  MscmpSystAuthn.Types.global_network_rule_params()
) ::
  {:ok, Msdata.SystGlobalNetworkRules.t()}
  | {:error, MscmpSystError.t() | Exception.t()}

Updates an existing Global Network Rule with new values.

This function works similar to create_global_network_rule/1 but updates an existing Global Network Rule record rather than creating a new one.

On successful update, a result tuple in the form {:ok, <record>} is returned where the <record> is the fully populated Data struct of the record just updated. If an exception is raised this function will return a failure tuple in the form of {:error, <exception data>}.

Parameters

• global_network_rule - this value is either a fully populated Msdata.SystGlobalNetworkRules struct of an existing Global Network Rule record or the ID of such a record. If the data struct is provided, Ecto optimistic locking is applied to the update operation.

• update_params - a map representing the values to use when updating the Global Network Rule. All parameters are optional, with omission meaning that the existing value should retain its current value. See MscmpSystAuthn.Types.global_network_rule_params/0 for the available attributes.

@spec update_instance_network_rule(
  Ecto.UUID.t() | Msdata.SystInstanceNetworkRules.t(),
  MscmpSystAuthn.Types.instance_network_rule_params()
) ::
  {:ok, Msdata.SystInstanceNetworkRules.t()}
  | {:error, MscmpSystError.t() | Exception.t()}

Updates an existing Instance Network Rule with new values.

This function works similar to create_instance_network_rule/2 but updates an existing Instance Network Rule record rather than creating a new one.

On successful update, a result tuple in the form {:ok, <record>} is returned where the <record> is the fully populated Data struct of the record just updated. If an exception is raised this function will return a failure tuple in the form of {:error, <exception data>}.

Parameters

• instance_network_rule - this value is either a fully populated Msdata.SystInstanceNetworkRules struct of an existing Instance Network Rule record or the ID of such a record. If the data struct is provided, Ecto optimistic locking is applied to the update operation.

• update_params - a map representing the values to use when updating the Instance Network Rule. All parameters are optional, with omission meaning that the existing value should retain its current value. See MscmpSystAuthn.Types.instance_network_rule_params/0 for the available attributes.