Release Floating Feature

Releases a floating license feature which is currently being borrowed by a license device.

Endpoint

• Method: POST
• Path: /api/v4/floating/feature_release
• Description: Releases a floating license feature currently in use by the device.

Authentication

See License API Authorization.

Required headers

• Date (string)
• Authorization (string)

Optional headers

• licensespring-tpm-signature (string) — TPM licensing signature and algorithm

  • licensespring-tpm-signature: algorithm="ES256",signature=""

Recommended headers

• Accept: application/json
• Content-Type: application/json

Request

Body parameters

Required:

• hardware_id (string)
• product (string)
• feature (string)

One of:

• license_key (string)
• username (string)

Optional:

• license_id (number)

Examples

curl

curl --location --request POST '/api/v4/floating/feature_release' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'Date: string' \
--header 'Authorization: string' \
--data-raw '{
  "hardware_id": "some-unique-id",
  "product": "XY",
  "feature": "FEATURE",
  "license_key": "AAAA-BBBB-CCCC-DDDD"
}'

nodejs

var request = require('request');
var options = {
  method: 'POST',
  url: '/api/v4/floating/feature_release',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Date': 'string',
    'Authorization': 'string'
  },
  body: JSON.stringify({
    hardware_id: 'some-unique-id',
    product: 'XY',
    feature: 'FEATURE',
    license_key: 'AAAA-BBBB-CCCC-DDDD'
  })
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

javascript (fetch)

var myHeaders = new Headers();
myHeaders.append("Accept", "application/json");
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Date", "string");
myHeaders.append("Authorization", "string");

var raw = JSON.stringify({
  hardware_id: "some-unique-id",
  product: "XY",
  feature: "FEATURE",
  license_key: "AAAA-BBBB-CCCC-DDDD"
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("/api/v4/floating/feature_release", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));

python

import requests

url = "/api/v4/floating/feature_release"

payload = {
  "hardware_id": "some-unique-id",
  "product": "XY",
  "feature": "FEATURE",
  "license_key": "AAAA-BBBB-CCCC-DDDD"
}

headers = {
  "Accept": "application/json",
  "Content-Type": "application/json",
  "Date": "string",
  "Authorization": "string"
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

ruby

require "uri"
require "net/http"
require "json"

url = URI("/api/v4/floating/feature_release")

http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url)
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request["Date"] = "string"
request["Authorization"] = "string"
request.body = JSON.dump({
  hardware_id: "some-unique-id",
  product: "XY",
  feature: "FEATURE",
  license_key: "AAAA-BBBB-CCCC-DDDD"
})

response = http.request(request)
puts response.read_body

---

Schema

Request + response schema (TypeScript + JSON Schema)

Request (TypeScript)

type ReleaseFlotingFeatureRequestBody = {
  // required parameters:
  product: string,
  hardware_id: string,
  feature: string,

  // required for key-based products:
  license_key: string,

  // required for user-based products:
  username: string,

  // optional parameters:
  license_id?: string | undefined,
}

Request (JSON Schema)

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "allOf": [
    {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "license_key": { "type": "string" }
          },
          "required": ["license_key"],
          "additionalProperties": false
        },
        {
          "type": "object",
          "properties": {
            "username": { "type": "string" }
          },
          "required": ["username"],
          "additionalProperties": false
        }
      ]
    },
    {
      "type": "object",
      "properties": {
        "hardware_id": { "type": "string" },
        "product": { "type": "string" },
        "feature": { "type": "string" },
        "license_id": { "type": ["number", "null"] }
      },
      "required": ["hardware_id", "product", "feature"],
      "additionalProperties": false
    }
  ]
}

Response (TypeScript)

type ReleaseFlotingFeatureResponseBody = ''

Response (JSON Schema)

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "string"
}

License Authorization Method

There are two types of product licenses based on how the client application authorizes itself to interact with a license:

• Key-based product licenses: client interactions with the license have to be authorized using a license_key.
• User-based product licenses: the license has a corresponding "license user" instead of a license key. Client interactions with the license have to be authorized using a username.

Errors

If an error occurs, the response will have an HTTP status code of 400 or higher, and the response body will contain an error description in the following format:

{
  status: number,
  code: string,
  message: string
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "status": { "type": "number" },
    "code": { "type": "string" },
    "message": { "type": "string" }
  },
  "required": [
    "status",
    "code",
    "message"
  ],
  "additionalProperties": false
}

List of exceptions

unknown_product (400): Provided product was not found

license_not_found (400): License with the provided license user not found

license_not_active (400): The license is not active

license_not_enabled (400): The license is not enabled

device_not_found (400): An active device matching the hardware_id not found

blacklisted (400): This device is blacklisted

floating_feature_device_not_in_use (400): Floating feature device is not in use

invalid_license_feature_code (400): License feature code: ' + param + ' is invalid or not assigned to the license.

feature_not_floating (400): License feature is not floating cloud feature.

tpm_invalid_public_key (400): The TPM public key sent is not valid

tpm_signature_required (400): The TPM signature is missing from the header and TPM usage is enforced

tpm_signature_missmatch (400): The TPM signature/algorithm is not ES256 and the signature can't be verified against the TPM public key