Go License Client

LicenseSpring’s new Go SDK V2 is now available! This version is a complete rewrite with breaking changes and will receive all future updates and support.

The legacy Go SDK (v1) is deprecated and maintained for backward compatibility only. New users should use v2.

Note: Read Common before this.

Importing the License Client

import (
	"gitlab.com/l3178/sdk-go/license_client"
	"gitlab.com/l3178/sdk-go/core/auth"
	core_request "gitlab.com/l3178/sdk-go/core/models/request"
)

Create LicenseClient

The following function uses the default CryptoProvider and DataLocation to encrypt, store, and decrypt the license file. You can implement your custom CryptoProvider and DataLocation the interface structure.

config := license_client.NewLicenseClientConfiguration("apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)

Create Custom LicenseClient

Implement the CryptoProvider and DataLocation interfaces to create custom implementations for these components, and use them to configure the license client.

// implement the interface:
//type CryptoProvider interface {
//	Encrypt(core_models.LicenseFile, string) (interface{}, error)
//	Decrypt(interface{}, string) (interface{}, error)
//}
type CustomCryptoProvider struct{}
func (d CustomCryptoProvider) Encrypt(license_file core_models.LicenseFile, password string) (interface{}, error) {
	// your custom implementation
}
func (d CustomCryptoProvider) Decrypt(data interface{}, password string) (interface{}, error) {
	// your custom implementation
}

// implement the interface:
//type DataLocation interface {
//	DataDirectory() (string, error)
//	LicenseFileName(string) string
//}
type CustomDataLocation struct{}
func (d CustomDataLocation) DataDirectory() (string, error) {
	// your custom implementation
}
func (d CustomDataLocation) LicenseFileName(productCode string) string {
	// your custom implementation
}

config := license_client.NewLicenseClientConfigurationCustom(CustomCryptoProvider, CustomDataLocation, "apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)

Activate Key-Based License

After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.

resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Hostname:   "hostname",
	AppVersion: "1.1.1",
	...
})

Activate User-Based License

After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.

resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	Hostname:   "hostname",
	AppVersion: "1.1.1",
	...
})

Deactivate Key-Based License

err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

Deactivate User-Based License

err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromUsername("username", "password"),
})

Check Key-Based License

resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	...
})

Check User-Based License

resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	...
})

Activate Offline License

After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.

// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineActivationRequest)

// Write to request file if you want to activate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("activate_offline.req", []byte(encoded), os.ModePerm)

// Activate offline license using API
client.ActivateOffline(offlineLicenseRequest)

Deactivate Offline License

// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineDeactivationRequest)

// Write to request file if you want to deactivate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("deactivate_offline.req", []byte(encoded), os.ModePerm)

// Deactivate offline license using API
client.DeactivateOffline(offlineLicenseRequest)

Local License Check

This function reads the license file from local memory, validates it by performing checks such as expiration and hardware ID matching, and returns the license object along with the results of these checks.

clientConfig := license_client.NewLicenseClientConfiguration(
	config.ApiKey,
	config.SharedKey,
	productCode,
)
clientConfig.Verbose = config.Verbose
clientConfig.VerifySignature = config.VerifySignature

client := license_client.NewLicenseClient(clientConfig)

resp := client.ActivateLicense(context.Background(), license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Product: productCode,
		Auth:    auth.FromKey(productAuth.LicenseKey),
	},
})

resp2 := client.LocalLicenseCheck(context.Background(),
	license_client.LocalLicenseCheckRequest{Product: productCode})

Local license check returns an object of the following type:

local_check_response.go

type LocalCheckResponse struct {
	LicenseResponse

	LicenseActive  bool `json:"license_active"`
	LicenseEnabled bool `json:"license_enabled"`
	IsExpired      bool `json:"is_expired"`

	DeviceLicensed bool `json:"is_device_licensed"`
	IsClockTampered  bool `json:"is_clock_tampered"`
	ProductMismatch bool `json:"product_mismatch"`
	FloatingExpired bool `json:"floating_expired"`
}

Add Consumption

// Add 1 consumption
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Consumptions: 1,
})

// Add 1 consumption, allow overages and define max overages
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Consumptions:  1,
	MaxOverages:   5,
	AllowOverages: true,
})

Add Feature Consumption

resp := client.AddFeatureConsumption(license_client.FeatureConsumptionRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: core_request.Auth{}.FromKey("licenseKey"),
	},
	Feature:      "featureCode",
	Consumptions: 1,
})

Trial Key

resp := client.TrialKey(license_client.TrialLicenseRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Email:         "",
	LicensePolicy: "",
	FirstName:     "",
	LastName:      "",
	Phone:         "",
	Address:       "",
	PostCode:      "",
	State:         "",
	Country:       "",
	City:          "",
	Reference:     "",
})

Product Details

// takes product code from configuration
resp := client.ProductDetails()

Track Device Variables

err := client.TrackDeviceVariables(license_client.DeviceVariablesRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Variables: map[string]string{
		"key": "var",
	},
})

Get Device Variables

resp := client.GetDeviceVariables(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

Floating Borrow

resp := client.FloatingBorrow(license_client.FloatingBorrowRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	BorrowedUntil: time.Now().UTC().Add(time.Hour * 24 * 5),
})

Floating Release

client.FloatingRelease(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

Change Password

client.ChangePassword(license_client.ChangePasswordRequest{
	PasswordAuth: core_request.PasswordAuth{
		Username: "username",
		Password: "password",
	},
	NewPassword: "abcd",
})

Versions

resp := client.Versions(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

Installation File

resp := client.InstallationFile(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

Customer License Users

resp := client.CustomerLicenseUsers(license_client.CustomerLicenseUsersRequest{
	Customer: "customer",
})

SSO URL

resp := client.SSOUrl(license_client.SSOUrlRequest{
	CustomerAccountCode: "code",
})

Air-Gap Initialization

airgapClient := license_client.NewAirgapClient(config, "publicKey")
activationCode, err := airgapClient.AirgapInitialization("licenseKey", "signingKey")
return activationCode, cfg.HardwareId

Air-Gap Activation

airgapClient := license_client.NewAirgapClient(config, "publicKey")
license, err := airgapClient.AirgapActivation("licensePolicy", "confirmationCode", 1234)