Use license key for licensing operations

For an overview of authenticating requests using a license key, see the following sections in the 10Duke Scale documentation:

• Key Concepts: License consumers
• How To Consume Licenses: Example workflow for headless applications (no UI)
• Access the APIs: License keys

You can use a license key to authenticate a device or user. The license key can be embedded in a device or prompted from the user. The following licensing operations can be executed with a license key without a login:

• license checkouts: methods tenduke::se::licensing::LicensingClient::checkoutLicensesWithKey(const std::string &) const and tenduke::se::licensing::LicensingClient::checkoutLicensesWithKey(const std::string &,const tenduke::se::licensing::LicenseCheckoutParameters &) const
• license heartbeat: methods tenduke::se::licensing::LicensingClient::heartbeatLicenses() const and tenduke::se::licensing::LicensingClient::heartbeatLicenses(const tenduke::se::licensing::LicenseHeartbeatParameters &) const
• license release: methods tenduke::se::licensing::LicensingClient::releaseLicenses() const and tenduke::se::licensing::LicensingClient::releaseLicenses(const tenduke::se::licensing::LicenseReleaseParameters &) const
• license key descriptions: methods tenduke::se::licensing::LicensingClient::describeLicenseKey(const std::string &) const and tenduke::se::licensing::LicensingClient::describeLicenseKey(const std::string &,const tenduke::se::Paging &,bool) const

Note that you don't need to provide a license key to heartbeat or release. The client remembers that the lease was checked out with a license key and automatically fills in the license key.

If you only need the above operations, you can use tenduke::se::TendukeClient: This service works with license keys only. To create an instance of the service, use the factory function tenduke::se::createTendukeClientForLicenseKeyUsage(const std::string &,const tenduke::se::BackendConfiguration &,const tenduke::se::ClientProperties &,const std::string &initialStateAsJson,const ::tenduke::ServiceConfiguration &).

See also client concepts.

Examples

The following examples demonstrate how to perform typical operations using a license key.

Create the client:

auto tendukeClient = ::tenduke::se::createTendukeClientForLicenseKeyUsage(
    "licensekey-demo/0.0.1-alpha-1",
    ::tenduke::se::BackendConfiguration(API_BASE_URL),  // you can find the API url from 10Duke Scale console
    tenduke::se::ClientPropertiesBuilder()
                  .hwId("simulated-hardware-id")
                  .version("0.0.1-alpha-1")
                 .build()
);

Check out licenses:

std::string licenseKey = ...; // License key
 
auto checkoutResponse = tendukeClient->licensing->checkoutLicensesWithKey(licenseKey)
    .version("1.0.0")       // Set default version to check out, this applies to all following licenses,
                            // unless overridden at license level. Version is optional.
    .seat("sample-product") // Check out one seat of "sample-product" with default version
.execute();
 
// Check for failures:
if (checkoutResponse.hasErrors) {
    // handle errors
}

Send a heartbeat for a lease (note that you don't need to provide the license key)

auto heartbeatResponse = tendukeClient->licensing->heartbeatLicenses()
    .leases(checkoutResponse.leases)
    .execute();
 
// Check for failures:
if (heartbeatResponse.hasErrors) {
    // handle errors
}

NOTE: A heartbeat generates new IDs for the leases.

To release the licenses after a heartbeat (note that you don't need to provide the license key):

auto releaseResponse = tendukeClient->licensing->releaseLicenses()
    .leases(heartbeatResponse.leases)
    .execute();

The licensing client has a memory cache, which holds leases of checked-out licenses and automatically manages the leases after a heartbeat or release request. To list all leases currently in cache:

auto allLeases = tendukeClient->leases->getAllLeases();

The client allows you to only operate (heartbeat or release) on leases that are present in the cache. If you want to release all checked-out licenses, you can do:

auto releaseResponse = tendukeClient->licenses->releaseLicenses()
    .leases(tendukeClient->leases->getAllLeases()
    .execute();

For all available services, see tenduke::se::TendukeClient.