cisco_smart_license

package
v0.0.0-...-50def94 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 2, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Smart licensing configuration, RPC, notification and operational data.

Copyright (c) 2016-2017 by Cisco Systems, Inc. All rights reserved.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthorizationStateEnum 

type AuthorizationStateEnum string

AuthorizationStateEnum represents The smart licensing authorization state. 

const (
	// No licenses are in use so there is no authorization
	// state to report.
	AuthorizationStateEnum_auth_state_none AuthorizationStateEnum = "auth-state-none"

	// Evaluation period is in use and is counting down.
	AuthorizationStateEnum_auth_state_eval AuthorizationStateEnum = "auth-state-eval"

	// Evaluation period in use but it has expired.
	AuthorizationStateEnum_auth_state_eval_expired AuthorizationStateEnum = "auth-state-eval-expired"

	// All license usage is authorized and within terms
	// of the customer's contract.
	AuthorizationStateEnum_auth_state_authorized AuthorizationStateEnum = "auth-state-authorized"

	// All license usage is authorized because a
	// reservation authorization code is installed.
	AuthorizationStateEnum_auth_state_authorized_reservation AuthorizationStateEnum = "auth-state-authorized-reservation"

	// License usage is out of compliance with the
	// terms of the contract. Either too many licenses are in
	// use or licenses that were not purchased are in use.
	AuthorizationStateEnum_auth_state_out_of_compliance AuthorizationStateEnum = "auth-state-out-of-compliance"

	// The authorization period has expired because this
	// product instance has not communicated with the
	// SSM or satellite in over 90 days.
	AuthorizationStateEnum_auth_state_authorization_expired AuthorizationStateEnum = "auth-state-authorization-expired"
)

type DeRegister 

type DeRegister struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Output DeRegister_Output
}

DeRegister De-register. This will immediately de-register the device.

func (*DeRegister) GetEntityData 

func (deRegister *DeRegister) GetEntityData() *types.CommonEntityData

type DeRegister_Output 

type DeRegister_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The return code for the de-register process. The type is ErrorEnum.
	ReturnCode interface{}
}

DeRegister_Output

func (*DeRegister_Output) GetEntityData 

func (output *DeRegister_Output) GetEntityData() *types.CommonEntityData

type EnforcementModeEnum 

type EnforcementModeEnum string

EnforcementModeEnum represents tells us how the license is being enforced. 

const (
	// The initial state after an entitlement request while we are waiting
	// the Authorization request response. In this mode the device will
	// have established communications with Cisco and successfully
	// registered with the Cisco Licensing cloud.
	EnforcementModeEnum_enforcement_waiting EnforcementModeEnum = "enforcement-waiting"

	// Cisco Smart Software Manager (CSSM) has responded that
	// the entitlement requested is in compliance.
	EnforcementModeEnum_enforcement_in_compliance EnforcementModeEnum = "enforcement-in-compliance"

	// Cisco Smart Software Manager (CSSM) has responded that
	// the entitlement requested is out of compliance.
	// either too many licenses /entitlements are in use or the license
	// has not been purchased
	EnforcementModeEnum_enforcement_out_of_compliance EnforcementModeEnum = "enforcement-out-of-compliance"

	// more licenses are in use than were purchased but the customer
	//  is still within the terms of their contract
	EnforcementModeEnum_enforcement_overage EnforcementModeEnum = "enforcement-overage"

	// The evaluation period is in use.
	// It will remain in use until the following
	// two messages have been received by the product from the
	// Cisco Smart Software Manager (CSSM):
	//  Successful response to a registration request,
	//  successful response to an entitlement authorization request
	EnforcementModeEnum_enforcement_evaluation EnforcementModeEnum = "enforcement-evaluation"

	// The evaluation period has expired
	EnforcementModeEnum_enforcement_evaluation_expired EnforcementModeEnum = "enforcement-evaluation-expired"

	// Authorization period has expired. This will occur if the product
	// has not been able to communicate with Cisco or a satellite
	// for an extended period of time, usually 90 days.
	EnforcementModeEnum_enforcement_authorization_expired EnforcementModeEnum = "enforcement-authorization-expired"

	// The entitlement requested is in compliance because
	// a reservation authorization code is installed and the product
	// is in Permanent License Reservation mode.
	EnforcementModeEnum_enforcement_reservation_in_compliance EnforcementModeEnum = "enforcement-reservation-in-compliance"

	// The entitlement tag is invalid.
	// The CSSM does not recognize the entitlement tag
	// because it is not in the database. This usually only occurs
	// during testing.
	EnforcementModeEnum_enforcement_invalid_tag EnforcementModeEnum = "enforcement-invalid-tag"

	// Smart licensing has been disabled. The feature using this license
	// should be disabled.
	EnforcementModeEnum_enforcement_disabled EnforcementModeEnum = "enforcement-disabled"
)

type ErrorEnum 

type ErrorEnum string

ErrorEnum represents Smart Licensing RPC calls 

const (
	// Success
	ErrorEnum_success ErrorEnum = "success"

	// Malloc Error
	ErrorEnum_malloc ErrorEnum = "malloc"

	// Null pointer Error
	ErrorEnum_nullpointer ErrorEnum = "nullpointer"

	// deprecated DO NOT remove
	ErrorEnum_error3 ErrorEnum = "error3"

	// deprecated DO NOT remove
	ErrorEnum_error4 ErrorEnum = "error4"

	// deprecated DO NOT remove
	ErrorEnum_error5 ErrorEnum = "error5"

	// Bad input parameter
	ErrorEnum_BadInputParams ErrorEnum = "BadInputParams"

	// deprecated DO NOT remove
	ErrorEnum_error7 ErrorEnum = "error7"

	// Bad handle
	ErrorEnum_badhandle ErrorEnum = "badhandle"

	// The requested item was not found
	ErrorEnum_notfound ErrorEnum = "notfound"

	// The requested operation is not supported
	ErrorEnum_notsupported ErrorEnum = "notsupported"

	// Init failed because the agent is already initialized
	ErrorEnum_alreadyinit ErrorEnum = "alreadyinit"

	// API failed because the agent is not initialized
	ErrorEnum_notinit ErrorEnum = "notinit"

	// State machine creation failed
	ErrorEnum_smfailtocreate ErrorEnum = "smfailtocreate"

	// State machine not running
	ErrorEnum_smfailtorun ErrorEnum = "smfailtorun"

	// State machine failed to init
	ErrorEnum_smfailtoinit ErrorEnum = "smfailtoinit"

	// State machine failed to destroy
	ErrorEnum_smfailtodestroy ErrorEnum = "smfailtodestroy"

	// message parsing error
	ErrorEnum_msgparse ErrorEnum = "msgparse"

	// message building error
	ErrorEnum_msgbuild ErrorEnum = "msgbuild"

	// Smart Agent not enabled
	ErrorEnum_notenabled ErrorEnum = "notenabled"

	// Smart Agent request invalid
	ErrorEnum_invalidrequest ErrorEnum = "invalidrequest"

	// General initialization error. We call a number of
	// system routines to
	// initialize system resources and we can't translate their error
	// codes to Smart Agent error codes. The log should have a detailed
	// description of the error.
	ErrorEnum_init ErrorEnum = "init"

	// Smart Agent Fail to set state
	ErrorEnum_failtosetstate ErrorEnum = "failtosetstate"

	// Unsupported response type
	ErrorEnum_unsupportedresponse ErrorEnum = "unsupportedresponse"

	// Invalid response type
	ErrorEnum_invalidresponse ErrorEnum = "invalidresponse"

	// Smart Agent Trusted Storage failed to store*
	ErrorEnum_storagefailtostore ErrorEnum = "storagefailtostore"

	// Smart Agent Trusted Storage failed to retrieve*
	ErrorEnum_storagefailtoretrieve ErrorEnum = "storagefailtoretrieve"

	// Null CCOId and IdToken
	ErrorEnum_nullccoidtoken ErrorEnum = "nullccoidtoken"

	// Product Instance identifier failed to match
	ErrorEnum_matchidentifier ErrorEnum = "matchidentifier"

	// Vendor string failed to match
	ErrorEnum_matchvendor ErrorEnum = "matchvendor"

	// nonce failed to match
	ErrorEnum_matchnonce ErrorEnum = "matchnonce"

	// communication channel error. Comm layer (call home) is disabled
	ErrorEnum_commdisabled ErrorEnum = "commdisabled"

	// Call Home message send error. probably a timeout so we
	// will retry the send. any other error from the comm send should
	// be a permanent failure
	ErrorEnum_commsend ErrorEnum = "commsend"

	// Call Home message send response error
	ErrorEnum_commresponse ErrorEnum = "commresponse"

	// Call Home unknown error
	ErrorEnum_communkown ErrorEnum = "communkown"

	// State machine Operation not permitted
	ErrorEnum_smpostnotallow ErrorEnum = "smpostnotallow"

	// Missing mandatory field in request message
	ErrorEnum_reqmsgmissingmandatoryfield ErrorEnum = "reqmsgmissingmandatoryfield"

	// We received a failure status in a response message.
	// The log will contain a error message
	ErrorEnum_responsefailed ErrorEnum = "responsefailed"

	// PI not initialized
	ErrorEnum_pinotinit ErrorEnum = "pinotinit"

	// The agent cannot be enabled more than once
	ErrorEnum_alreadyenabled ErrorEnum = "alreadyenabled"

	// The agent is already registered
	ErrorEnum_alreadyregistered ErrorEnum = "alreadyregistered"

	// The certificate is invalid
	ErrorEnum_certinvalid ErrorEnum = "certinvalid"

	// The certificate has expired
	ErrorEnum_certexpired ErrorEnum = "certexpired"

	// The agent is not registered
	ErrorEnum_notregistered ErrorEnum = "notregistered"

	// The CSR generation failed
	ErrorEnum_csrgenerationfailed ErrorEnum = "csrgenerationfailed"

	// Signature Verification failed
	ErrorEnum_verifysignaturefailed ErrorEnum = "verifysignaturefailed"

	// Signature Generation failed
	ErrorEnum_generatesignaturefailed ErrorEnum = "generatesignaturefailed"

	// Signing Certificate Verification failed
	ErrorEnum_signcertverificationfailed ErrorEnum = "signcertverificationfailed"

	// Node Certificate Verification failed
	ErrorEnum_nodecertverificationfailed ErrorEnum = "nodecertverificationfailed"

	// Certificate Parsing failed
	ErrorEnum_parsecertificatefailed ErrorEnum = "parsecertificatefailed"

	// Root Certificate Import failed
	ErrorEnum_cryptorootcaimportfailed ErrorEnum = "cryptorootcaimportfailed"

	// The tag is invalid
	ErrorEnum_taginvalid ErrorEnum = "taginvalid"

	// Smart agent is running on a standby RP
	ErrorEnum_standby ErrorEnum = "standby"

	// Smart agent id token registration is in progress
	ErrorEnum_registrationinprogress ErrorEnum = "registrationinprogress"

	// Call Home is not ready because it is in restart ipc
	ErrorEnum_commretry ErrorEnum = "commretry"

	// Smart agent authorization renew is in progress
	ErrorEnum_authrenewinprogress ErrorEnum = "authrenewinprogress"

	// Smart agent id certificate renew is in progress
	ErrorEnum_idcertrenewinprogress ErrorEnum = "idcertrenewinprogress"

	// Udi List Has Not been changed
	ErrorEnum_noudichange ErrorEnum = "noudichange"

	// Call home service cannot be turned on.
	ErrorEnum_callhomeserviceoff ErrorEnum = "callhomeserviceoff"

	// message execution already in progress
	ErrorEnum_msgexecinprogress ErrorEnum = "msgexecinprogress"

	// message execution in progress flag is locked
	ErrorEnum_msgexecinproglocked ErrorEnum = "msgexecinproglocked"

	// The ID cert only matches some of the system Udi's
	ErrorEnum_certmatchessubsetudis ErrorEnum = "certmatchessubsetudis"

	// A Storage group has not all been changed
	ErrorEnum_storagegroupchangeincomplete ErrorEnum = "storagegroupchangeincomplete"

	// Storage Management is not Init
	ErrorEnum_storagemgmtnotinit ErrorEnum = "storagemgmtnotinit"

	// TS System Path list is not changed
	ErrorEnum_tspathnotchanged ErrorEnum = "tspathnotchanged"

	// Crypto Initialization is not completed
	ErrorEnum_cryptoinitnotcompleted ErrorEnum = "cryptoinitnotcompleted"

	// The agent is not in unidentified state
	ErrorEnum_notinunidentified ErrorEnum = "notinunidentified"

	// The platform provided path is invalid
	ErrorEnum_platformpathinvalid ErrorEnum = "platformpathinvalid"

	// The platform provided UDI is invalid
	ErrorEnum_platformudiinvalid ErrorEnum = "platformudiinvalid"

	// failed to create Trusted Store object
	ErrorEnum_storageobjfailtocreate ErrorEnum = "storageobjfailtocreate"

	// failed to erase trusted store object
	ErrorEnum_storageobjfailtoerase ErrorEnum = "storageobjfailtoerase"

	// trusted storage object/file does not exist
	ErrorEnum_storageobjdoesnotexist ErrorEnum = "storageobjdoesnotexist"

	// The message event is beyond the peer
	ErrorEnum_messageeventexceedspeer ErrorEnum = "messageeventexceedspeer"

	// Validation of the authorization key failed.
	// It probably does not match the UDI. The device will go to
	// the unidentified state (not registered)
	ErrorEnum_codevalidationfailed ErrorEnum = "codevalidationfailed"

	// operation not supported because the agent is running in
	// permanent License reservation mode
	ErrorEnum_reserved ErrorEnum = "reserved"

	// No license reservation is in progress
	ErrorEnum_noreservationinprogress ErrorEnum = "noreservationinprogress"

	// No authorization code instaled in device
	ErrorEnum_noauthorizationinstalled ErrorEnum = "noauthorizationinstalled"

	// The reservation authorization code does not match the
	// reservation request code
	ErrorEnum_reservationmismatch ErrorEnum = "reservationmismatch"

	// not in license reservation mode
	ErrorEnum_notreservationmode ErrorEnum = "notreservationmode"

	//  General reservation error. This is used with the API
	// functions that are called by the CLI. the API will return a
	// very specific displayString that describes the error.
	ErrorEnum_reservationerror ErrorEnum = "reservationerror"

	// Sysmgr Init Failed
	ErrorEnum_sysmgrinit ErrorEnum = "sysmgrinit"

	// Generic error for something already existing
	ErrorEnum_alreadyexists ErrorEnum = "alreadyexists"

	// Error in object insert to xos list
	ErrorEnum_listinsertfailed ErrorEnum = "listinsertfailed"

	// Session management not initialized
	ErrorEnum_sessionmgmtnotinit ErrorEnum = "sessionmgmtnotinit"

	// Error Creating Linked List
	ErrorEnum_listinitfailed ErrorEnum = "listinitfailed"

	// List in use
	ErrorEnum_listbusy ErrorEnum = "listbusy"

	// No Connected Clients
	ErrorEnum_noclients ErrorEnum = "noclients"

	// Generic IPC layer error
	ErrorEnum_ipc ErrorEnum = "ipc"

	// The IPC socket open error
	ErrorEnum_ipcopen ErrorEnum = "ipcopen"

	// The IPC Initialization error
	ErrorEnum_ipcinit ErrorEnum = "ipcinit"

	// The IPC Connection error
	ErrorEnum_ipcconnect ErrorEnum = "ipcconnect"

	// The IPC Server Event error
	ErrorEnum_ipcevents ErrorEnum = "ipcevents"

	// The IPC Management error
	ErrorEnum_ipcmgmt ErrorEnum = "ipcmgmt"

	// The IPC Send error
	ErrorEnum_ipcsend ErrorEnum = "ipcsend"

	// The IPC Recevive error
	ErrorEnum_ipcreceive ErrorEnum = "ipcreceive"

	// The IPC Recevive error
	ErrorEnum_ipctimeout ErrorEnum = "ipctimeout"

	// Failed to enqueue a message to the IPC Queue
	ErrorEnum_enqueuefailed ErrorEnum = "enqueuefailed"

	// Failed to dequeue a message from the IPC queue
	ErrorEnum_dequeuefailed ErrorEnum = "dequeuefailed"

	// Fail because we are about to shutdown and we need
	// to stop processing any more messages or responses
	ErrorEnum_shuttingdown ErrorEnum = "shuttingdown"

	// Could not validate Trust Chain
	ErrorEnum_couldnotvalidatetrustchain ErrorEnum = "couldnotvalidatetrustchain"

	// The reservation authorization code is already installed
	ErrorEnum_reservationalreadyinstalled ErrorEnum = "reservationalreadyinstalled"

	// Failed to parse reservation authorization code
	ErrorEnum_reservationinstallparsefail ErrorEnum = "reservationinstallparsefail"

	// Base64 encoding failed
	ErrorEnum_base64encoding ErrorEnum = "base64encoding"

	// Base64 decoding failed
	ErrorEnum_base64decoding ErrorEnum = "base64decoding"

	// Failed to find UUID inside software id tag
	ErrorEnum_invalidsoftwareidtag ErrorEnum = "invalidsoftwareidtag"

	// Development certificates are being used with Production
	// Root certificate
	ErrorEnum_certificatemismatch ErrorEnum = "certificatemismatch"

	// No License Reservation
	ErrorEnum_noreservation ErrorEnum = "noreservation"

	// the agent Daemon is unreachable
	ErrorEnum_agentunreachable ErrorEnum = "agentunreachable"

	// the agent ignores event
	ErrorEnum_ignoreevent ErrorEnum = "ignoreevent"

	// Base58 overflow, number too large.
	ErrorEnum_b58overflow ErrorEnum = "b58overflow"

	// Base58 decode error.
	ErrorEnum_b58decode ErrorEnum = "b58decode"

	// Bad base58 length.
	ErrorEnum_b58badlen ErrorEnum = "b58badlen"

	// Invalid base58 digit.
	ErrorEnum_b58invdigit ErrorEnum = "b58invdigit"

	// Overflow detected during base58 decode.
	ErrorEnum_b58decodeoverflow ErrorEnum = "b58decodeoverflow"

	// Reservation version out of bound
	ErrorEnum_reservationversionoutofbound ErrorEnum = "reservationversionoutofbound"

	// General Base58 encoding error
	ErrorEnum_base58encode ErrorEnum = "base58encode"

	// General error code for adding item that already exists.
	// Used in App HA setup when adding an HA peer device info that
	// is already added
	ErrorEnum_duplicatedentry ErrorEnum = "duplicatedentry"

	// General error code for trying to remove item that do
	// not exist. Used in App HA setup when removing an HA peer device
	// info that does not exist
	ErrorEnum_missingentry ErrorEnum = "missingentry"

	// The given peer info contain incorrect data format
	ErrorEnum_badpeerinfoformat ErrorEnum = "badpeerinfoformat"

	// The given handle attribute list contains incomplete
	// application HA attributes
	ErrorEnum_badapplicationhaattributedataset ErrorEnum = "badapplicationhaattributedataset"

	// license reservation is in progress
	ErrorEnum_reservationinprogress ErrorEnum = "reservationinprogress"

	// The xos_dm_create() failure causes this error code to be return
	ErrorEnum_xdmcreatehandle ErrorEnum = "xdmcreatehandle"

	// Version in entitlement response message does not match
	// with the
	// one already saved from last completed response message. We need
	// to send entitlemeent request again with proper version and data
	ErrorEnum_versionmismatchinentitlementrsp ErrorEnum = "versionmismatchinentitlementrsp"

	// Given valid HA Role is not supported by this operation.
	// For Application HA valid roles are Active or Standby.
	ErrorEnum_harolenotsupported ErrorEnum = "harolenotsupported"

	// Application HA attribute contains invalid character.
	// Character set supported is alphanumeric.
	ErrorEnum_apphainvalidcharacter ErrorEnum = "apphainvalidcharacter"

	// The peer info given is from the same device.
	ErrorEnum_apphaaddpeerfromsamedevice ErrorEnum = "apphaaddpeerfromsamedevice"

	// When setting Application HA Attribute, a different
	// handle with exactly
	// same tag, app ha name, app ha id exists in the agent.
	ErrorEnum_apphaappduplicatedinstance ErrorEnum = "apphaappduplicatedinstance"

	// Backend server does not support AppHA enabled message
	// version. So
	// registration response (from backend) received with status set as
	// FAILED or VERSION_TOO_HIGH.
	ErrorEnum_versionmismatchinregresponse ErrorEnum = "versionmismatchinregresponse"

	// Migration function was called but there are no i
	// call backs registered
	ErrorEnum_conversionnocb ErrorEnum = "conversionnocb"

	// Migration was not enabled with the
	// MIGRATION_ALLOWED property
	ErrorEnum_conversionnotallowed ErrorEnum = "conversionnotallowed"

	// Migration is in progress
	ErrorEnum_conversioninprogress ErrorEnum = "conversioninprogress"

	// Migration has already been started
	ErrorEnum_conversionalreadystarted ErrorEnum = "conversionalreadystarted"

	// Migration is not enabled
	ErrorEnum_conversionnotenabled ErrorEnum = "conversionnotenabled"

	// The backend derver this device is connected to does
	// not support conversion
	ErrorEnum_versionconversionnotsupported ErrorEnum = "versionconversionnotsupported"

	// No conversion in progress
	ErrorEnum_noconversioninprogress ErrorEnum = "noconversioninprogress"

	// Loaded OpenSSL version is not the same as used for
	// development
	ErrorEnum_cryptoversionmismatch ErrorEnum = "cryptoversionmismatch"

	// Some Smart Licensing Conversion jobs stopped successfully
	ErrorEnum_conversionstoppedpartially ErrorEnum = "conversionstoppedpartially"

	// Operation is not supported because Utility management
	// is enabled
	ErrorEnum_utilityenabled ErrorEnum = "utilityenabled"

	// Utility is not enabled
	ErrorEnum_utilitynotenabled ErrorEnum = "utilitynotenabled"

	// Transport layer not abvailable
	ErrorEnum_transportnotavailable ErrorEnum = "transportnotavailable"

	// Unable to get FQDN
	ErrorEnum_fqdn ErrorEnum = "fqdn"

	// The current transport type does not support this feature
	ErrorEnum_thirdparty ErrorEnum = "thirdparty"

	// The transport type needed is not configured
	ErrorEnum_transporttype ErrorEnum = "transporttype"

	// max error code
	ErrorEnum_max ErrorEnum = "max"
)

type Licensing 

type Licensing struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Smart licensing configuration.
	Config Licensing_Config

	// Smart licensing state.
	State Licensing_State
}

Licensing Container to hold config and state.

func (*Licensing) GetEntityData 

func (licensing *Licensing) GetEntityData() *types.CommonEntityData

type Licensing_Config 

type Licensing_Config struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Enable/disable smart licensing. If state:always-enabled is true then Smart
	// Licensing is always enabled and config:enable will be  silently ignored.
	// The type is bool.
	Enable interface{}

	// A free form ID set by the customer which will be included in the utility
	// usage (RUM) report and inthe message header. The type is string.
	CustomId interface{}

	// Controls whether or not some information is sent in messages to the   CSSM
	// or satellite.
	Privacy Licensing_Config_Privacy

	// Utility settings.
	Utility Licensing_Config_Utility

	// Transport layer settings.
	Transport Licensing_Config_Transport
}

Licensing_Config Smart licensing configuration.

func (*Licensing_Config) GetEntityData 

func (config *Licensing_Config) GetEntityData() *types.CommonEntityData

type Licensing_Config_Privacy 

type Licensing_Config_Privacy struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If true then the hostname will not be sent in  any messages. The type is
	// bool.
	Hostname interface{}

	// If true then the smart licensing version will not be sent in  any messages.
	// The type is bool.
	Version interface{}
}

Licensing_Config_Privacy Controls whether or not some information is sent in messages to the 

CSSM or satellite.

func (*Licensing_Config_Privacy) GetEntityData 

func (privacy *Licensing_Config_Privacy) GetEntityData() *types.CommonEntityData

type Licensing_Config_Transport 

type Licensing_Config_Transport struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The transport type. If transport-type is set to transport-type-callhome
	// then any additional transport settings must be done from the callhome CLI.
	// If the transport-type is set to transport-type-smart additional settings
	// are available below. The type is TransportTypeEnum.
	TransportType interface{}

	// Settings for the smart transport.
	TransportSmart Licensing_Config_Transport_TransportSmart
}

Licensing_Config_Transport Transport layer settings.

func (*Licensing_Config_Transport) GetEntityData 

func (transport *Licensing_Config_Transport) GetEntityData() *types.CommonEntityData

type Licensing_Config_Transport_TransportSmart 

type Licensing_Config_Transport_TransportSmart struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Tell smart licensing to set the default URLs for both url-registration and
	// url-utility that point to  the Cisco SSM. The type is bool.
	UrlDefault interface{}

	// The URLS used for registration and utility reporting. These should be set
	// if the product instance will communicate with a satellite or Third Party
	// Billing Platform.
	Urls Licensing_Config_Transport_TransportSmart_Urls
}

Licensing_Config_Transport_TransportSmart Settings for the smart transport.

func (*Licensing_Config_Transport_TransportSmart) GetEntityData 

func (transportSmart *Licensing_Config_Transport_TransportSmart) GetEntityData() *types.CommonEntityData

type Licensing_Config_Transport_TransportSmart_Urls 

type Licensing_Config_Transport_TransportSmart_Urls struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Set the URL used for registration, authorization and anything else not
	// related to utility usage reporting. The type is string.
	UrlRegistration interface{}

	// Set the URL to be used for sending utility usage  reports. This should be
	// the same as url-registration  if you are using a satellite. The type is
	// string.
	UrlUtility interface{}
}

Licensing_Config_Transport_TransportSmart_Urls The URLS used for registration and utility reporting. These should be set if the product instance will communicate with a satellite or Third Party Billing Platform.

func (*Licensing_Config_Transport_TransportSmart_Urls) GetEntityData 

func (urls *Licensing_Config_Transport_TransportSmart_Urls) GetEntityData() *types.CommonEntityData

type Licensing_Config_Utility 

type Licensing_Config_Utility struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates the customer's intent to start reporting  utility usage
	// information. This alone does not enable  utility reporting. Either
	// subscription information will be  automatically downloaded from the SSM or
	// a utility certificate we be loaded if the system registers with a  Third
	// Party Billing Platform. The type is bool.
	UtilityEnable interface{}

	// Customer address information that will be included in  the utility usage
	// reports.
	CustomerInfo Licensing_Config_Utility_CustomerInfo
}

Licensing_Config_Utility Utility settings.

func (*Licensing_Config_Utility) GetEntityData 

func (utility *Licensing_Config_Utility) GetEntityData() *types.CommonEntityData

type Licensing_Config_Utility_CustomerInfo 

type Licensing_Config_Utility_CustomerInfo struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The cisco issued customer id which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	Id interface{}

	// The customer company name which will be included in the utility usage (RUM)
	// report. The type is string with length: 1..250.
	Name interface{}

	// The customer company street address which will be included in the utility
	// usage (RUM) report. The type is string with length: 1..250.
	Street interface{}

	// The customer company city which will be included in the utility usage (RUM)
	// report. The type is string with length: 1..250.
	City interface{}

	// The customer company state which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	State interface{}

	// The customer company country which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	Country interface{}

	// The customer location specific postal code which will be included in the
	// utility usage (RUM) report. The type is string with length: 1..250.
	PostalCode interface{}
}

Licensing_Config_Utility_CustomerInfo Customer address information that will be included in the utility usage reports.

func (*Licensing_Config_Utility_CustomerInfo) GetEntityData 

func (customerInfo *Licensing_Config_Utility_CustomerInfo) GetEntityData() *types.CommonEntityData

type Licensing_State 

type Licensing_State struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Smart Licensing is always enabled. the smart-enabled leaf below  will
	// always be true. The config:enable setting above will be silently  ignored
	// by Smart licensing. The type is bool.
	AlwaysEnabled interface{}

	// Is smart licensing enabled. If always-enabled above is true then  smart
	// licensing is always enabled and can not be disabled. The type is bool.
	SmartEnabled interface{}

	// The smart licensing version in use. The type is string with length: 1..255.
	Version interface{}

	// Smart licensing state information.     This is only valid if smart-enabled
	// = true.
	StateInfo Licensing_State_StateInfo
}

Licensing_State Smart licensing state.

func (*Licensing_State) GetEntityData 

func (state *Licensing_State) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo 

type Licensing_State_StateInfo struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The custom ID set by the customer that will be included in the utility
	// usage (RUM) report and in th emessage header. The type is string.
	CustomId interface{}

	// State of license registration.
	Registration Licensing_State_StateInfo_Registration

	// State of license authorization.
	Authorization Licensing_State_StateInfo_Authorization

	// State of utility reporting.
	Utility Licensing_State_StateInfo_Utility

	// State of the transport.
	Transport Licensing_State_StateInfo_Transport

	// State of the privacy settings.
	Privacy Licensing_State_StateInfo_Privacy

	// State of the evaluation period.
	Evaluation Licensing_State_StateInfo_Evaluation

	// UDI of the system.
	Udi Licensing_State_StateInfo_Udi

	// List of license (entitlement tag) usage information.  This only contains
	// the information for licenses that are in use. The type is slice of
	// Licensing_State_StateInfo_Usage.
	Usage []*Licensing_State_StateInfo_Usage
}

Licensing_State_StateInfo Smart licensing state information. 

This is only valid if smart-enabled = true.

func (*Licensing_State_StateInfo) GetEntityData 

func (stateInfo *Licensing_State_StateInfo) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization 

type Licensing_State_StateInfo_Authorization struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The current authorization state. The type is AuthorizationStateEnum.
	AuthorizationState interface{}

	// No licenses in use. This empty container is not needed but is  a place
	// holder to show there is no data for this state.
	AuthorizationNone Licensing_State_StateInfo_Authorization_AuthorizationNone

	// Evaluation period is in use and counting down. The evaluation period only
	// counts down when licenses are in use.
	AuthorizationEval Licensing_State_StateInfo_Authorization_AuthorizationEval

	// Evaluation period is in use but has expired.
	AuthorizationEvalExpired Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired

	// All license usage is authorized and within terms of the contract.
	AuthorizationAuthorized Licensing_State_StateInfo_Authorization_AuthorizationAuthorized

	// All license usage is authorized because a   reservation authorization code
	// is installed.
	AuthorizationAuthorizedReservation Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation

	// License usage is out of compliance with the terms of the  contract because
	// more licenses are in use than were purchased.
	AuthorizationOutOfCompliance Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance

	// The authorization period has expired because the product  instance ahs not
	// communicated with the SSM or satellite in  over 90 days.
	AuthorizationAuthorizationExpired Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired
}

Licensing_State_StateInfo_Authorization State of license authorization.

func (*Licensing_State_StateInfo_Authorization) GetEntityData 

func (authorization *Licensing_State_StateInfo_Authorization) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired 

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Last communication was successful or failed. The type is bool.
	LastCommStatusSuccess interface{}

	// Failure message if the last communications attempt failed. This can be
	// displayed for the user. It is not a parsable string. The type is string
	// with length: 0..255.
	FailMessage interface{}

	// Time the last communication attempt happened. The type is string with
	// pattern: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	LastCommTime interface{}

	// The next time communications will be attempted to the back end. This will
	// be zero if the initial communication has not completed. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	NextCommTime interface{}

	// If there are no communications between now and this time smart licensing
	// will enter the authorization expired state.  This may be zero indicating
	// there is no deadline. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	CommDeadlineTime interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired The authorization period has expired because the product instance ahs not communicated with the SSM or satellite in over 90 days.

func (*Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired) GetEntityData 

func (authorizationAuthorizationExpired *Licensing_State_StateInfo_Authorization_AuthorizationAuthorizationExpired) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorized 

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorized struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Last communication was successful or failed. The type is bool.
	LastCommStatusSuccess interface{}

	// Failure message if the last communications attempt failed. This can be
	// displayed for the user. It is not a parsable string. The type is string
	// with length: 0..255.
	FailMessage interface{}

	// Time the last communication attempt happened. The type is string with
	// pattern: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	LastCommTime interface{}

	// The next time communications will be attempted to the back end. This will
	// be zero if the initial communication has not completed. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	NextCommTime interface{}

	// If there are no communications between now and this time smart licensing
	// will enter the authorization expired state.  This may be zero indicating
	// there is no deadline. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	CommDeadlineTime interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationAuthorized All license usage is authorized and within terms of the contract.

func (*Licensing_State_StateInfo_Authorization_AuthorizationAuthorized) GetEntityData 

func (authorizationAuthorized *Licensing_State_StateInfo_Authorization_AuthorizationAuthorized) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation 

type Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the reservation occurred. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	ReservationTime interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation All license usage is authorized because a reservation authorization code is installed.

func (*Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation) GetEntityData 

func (authorizationAuthorizedReservation *Licensing_State_StateInfo_Authorization_AuthorizationAuthorizedReservation) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationEval 

type Licensing_State_StateInfo_Authorization_AuthorizationEval struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Number of seconds of license usage until the evaluation  period expires.
	// Note that this not a hard date and time because if no licenses are in use
	// the evaluation period stops  counting down. The type is interface{} with
	// range: 0..18446744073709551615.
	SecondsLeft interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationEval Evaluation period is in use and counting down. The evaluation period only counts down when licenses are in use.

func (*Licensing_State_StateInfo_Authorization_AuthorizationEval) GetEntityData 

func (authorizationEval *Licensing_State_StateInfo_Authorization_AuthorizationEval) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired 

type Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the evaluation period expired. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	ExpireTime interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired Evaluation period is in use but has expired.

func (*Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired) GetEntityData 

func (authorizationEvalExpired *Licensing_State_StateInfo_Authorization_AuthorizationEvalExpired) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationNone 

type Licensing_State_StateInfo_Authorization_AuthorizationNone struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
}

Licensing_State_StateInfo_Authorization_AuthorizationNone No licenses in use. This empty container is not needed but is a place holder to show there is no data for this state.

func (*Licensing_State_StateInfo_Authorization_AuthorizationNone) GetEntityData 

func (authorizationNone *Licensing_State_StateInfo_Authorization_AuthorizationNone) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance 

type Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Last communication was successful or failed. The type is bool.
	LastCommStatusSuccess interface{}

	// Failure message if the last communications attempt failed. This can be
	// displayed for the user. It is not a parsable string. The type is string
	// with length: 0..255.
	FailMessage interface{}

	// Time the last communication attempt happened. The type is string with
	// pattern: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	LastCommTime interface{}

	// The next time communications will be attempted to the back end. This will
	// be zero if the initial communication has not completed. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	NextCommTime interface{}

	// If there are no communications between now and this time smart licensing
	// will enter the authorization expired state.  This may be zero indicating
	// there is no deadline. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	CommDeadlineTime interface{}

	// Time the product instance entered the out of compliance state. The type is
	// string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	OocTime interface{}
}

Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance License usage is out of compliance with the terms of the contract because more licenses are in use than were purchased.

func (*Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance) GetEntityData 

func (authorizationOutOfCompliance *Licensing_State_StateInfo_Authorization_AuthorizationOutOfCompliance) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Evaluation 

type Licensing_State_StateInfo_Evaluation struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Is the evaluation period currently in use and counting down. The type is
	// bool.
	EvalInUse interface{}

	// Has the evaluation period expired. The type is bool.
	EvalExpired interface{}

	// If the evaluation period is not expired this is the number  of seconds left
	// in the period.
	EvalPeriodLeft Licensing_State_StateInfo_Evaluation_EvalPeriodLeft

	// If the evaluation period has expired then this is the  time of the
	// expiration.
	EvalExpireTime Licensing_State_StateInfo_Evaluation_EvalExpireTime
}

Licensing_State_StateInfo_Evaluation State of the evaluation period.

func (*Licensing_State_StateInfo_Evaluation) GetEntityData 

func (evaluation *Licensing_State_StateInfo_Evaluation) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Evaluation_EvalExpireTime 

type Licensing_State_StateInfo_Evaluation_EvalExpireTime struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Date and time the evaluation period expired. The type is string with
	// pattern: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	ExpireTime interface{}
}

Licensing_State_StateInfo_Evaluation_EvalExpireTime If the evaluation period has expired then this is the time of the expiration.

func (*Licensing_State_StateInfo_Evaluation_EvalExpireTime) GetEntityData 

func (evalExpireTime *Licensing_State_StateInfo_Evaluation_EvalExpireTime) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Evaluation_EvalPeriodLeft 

type Licensing_State_StateInfo_Evaluation_EvalPeriodLeft struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Number of seconds of license usage until the evaluation  period expires.
	// The type is interface{} with range: 0..4294967295.
	TimeLeft interface{}
}

Licensing_State_StateInfo_Evaluation_EvalPeriodLeft If the evaluation period is not expired this is the number of seconds left in the period.

func (*Licensing_State_StateInfo_Evaluation_EvalPeriodLeft) GetEntityData 

func (evalPeriodLeft *Licensing_State_StateInfo_Evaluation_EvalPeriodLeft) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Privacy 

type Licensing_State_StateInfo_Privacy struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If true then the hostname will not be sent in  any messages. The type is
	// bool.
	Hostname interface{}

	// If true then the smart licensing version will not be sent in  any messages.
	// The type is bool.
	Version interface{}
}

Licensing_State_StateInfo_Privacy State of the privacy settings.

func (*Licensing_State_StateInfo_Privacy) GetEntityData 

func (privacy *Licensing_State_StateInfo_Privacy) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Registration 

type Licensing_State_StateInfo_Registration struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The current registration state. The type is RegistrationStateEnum.
	RegistrationState interface{}

	// Is the device allowed to enable export controlled features. The type is
	// bool.
	ExportControlAllowed interface{}

	// Registration is in progress.
	RegistrationInProgress Licensing_State_StateInfo_Registration_RegistrationInProgress

	// Registration failed.
	RegistrationFailed Licensing_State_StateInfo_Registration_RegistrationFailed

	// Registration failed and doing a retry.
	RegistrationRetry Licensing_State_StateInfo_Registration_RegistrationRetry

	// Registration success.
	RegistrationComplete Licensing_State_StateInfo_Registration_RegistrationComplete
}

Licensing_State_StateInfo_Registration State of license registration.

func (*Licensing_State_StateInfo_Registration) GetEntityData 

func (registration *Licensing_State_StateInfo_Registration) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Registration_RegistrationComplete 

type Licensing_State_StateInfo_Registration_RegistrationComplete struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the registration was successful. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	CompleteTime interface{}

	// Time the last registration renewal occurred.  If empty then no renewal has
	// occurred. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	LastRenewTime interface{}

	// Time the registration will be automatically renewed. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	NextRenewTime interface{}

	// Time the registration will expire if it is not renewed. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	ExpireTime interface{}

	// Was the last renewal attempt successful. The type is bool.
	LastRenewSuccess interface{}

	// If the last renewal failed then this is a failure message that can be
	// displayed for the user.  This is not a parsable string. Only present if the
	// last renewal failed. The type is string with length: 0..255.
	FailMessage interface{}

	// The smart account name for this registration. The type is string with
	// length: 1..255.
	SmartAccount interface{}

	// The virtual account name for this registration. The type is string with
	// length: 1..255.
	VirtualAccount interface{}
}

Licensing_State_StateInfo_Registration_RegistrationComplete Registration success.

func (*Licensing_State_StateInfo_Registration_RegistrationComplete) GetEntityData 

func (registrationComplete *Licensing_State_StateInfo_Registration_RegistrationComplete) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Registration_RegistrationFailed 

type Licensing_State_StateInfo_Registration_RegistrationFailed struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the registration failed. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	FailTime interface{}

	// Failure message that can be displayed for the user.  This is not a parsable
	// message. The type is string with length: 0..255.
	FailMessage interface{}
}

Licensing_State_StateInfo_Registration_RegistrationFailed Registration failed.

func (*Licensing_State_StateInfo_Registration_RegistrationFailed) GetEntityData 

func (registrationFailed *Licensing_State_StateInfo_Registration_RegistrationFailed) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Registration_RegistrationInProgress 

type Licensing_State_StateInfo_Registration_RegistrationInProgress struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the registration started. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}
}

Licensing_State_StateInfo_Registration_RegistrationInProgress Registration is in progress.

func (*Licensing_State_StateInfo_Registration_RegistrationInProgress) GetEntityData 

func (registrationInProgress *Licensing_State_StateInfo_Registration_RegistrationInProgress) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Registration_RegistrationRetry 

type Licensing_State_StateInfo_Registration_RegistrationRetry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the registration will be retried. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	RetryNextTime interface{}

	// Time the registration failed. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	FailTime interface{}

	// Failure message that can be displayed for the user.  This is not a parsable
	// message. The type is string with length: 0..255.
	FailMessage interface{}
}

Licensing_State_StateInfo_Registration_RegistrationRetry Registration failed and doing a retry.

func (*Licensing_State_StateInfo_Registration_RegistrationRetry) GetEntityData 

func (registrationRetry *Licensing_State_StateInfo_Registration_RegistrationRetry) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Transport 

type Licensing_State_StateInfo_Transport struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Type of communications transport smart licensing is using. The type is
	// TransportTypeEnum.
	TransportType interface{}

	// URLs in use if the transport type is smart.
	UrlSettings Licensing_State_StateInfo_Transport_UrlSettings
}

Licensing_State_StateInfo_Transport State of the transport.

func (*Licensing_State_StateInfo_Transport) GetEntityData 

func (transport *Licensing_State_StateInfo_Transport) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Transport_UrlSettings 

type Licensing_State_StateInfo_Transport_UrlSettings struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The URL used for registration, authorization and any  other messages not
	// related to utility. The type is string.
	UrlRegistration interface{}

	// The URL used for utility reporting. url-utility and  url-registration may
	// be the same or different. If a satellite is in use then they will probably
	// be the same. The type is string.
	UrlUtility interface{}
}

Licensing_State_StateInfo_Transport_UrlSettings URLs in use if the transport type is smart.

func (*Licensing_State_StateInfo_Transport_UrlSettings) GetEntityData 

func (urlSettings *Licensing_State_StateInfo_Transport_UrlSettings) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Udi 

type Licensing_State_StateInfo_Udi struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The Product Identifier. Always combined with sn. The type is string with
	// length: 1..255.
	Pid interface{}

	// The system serial number. Always combined with pid. The type is string with
	// length: 1..255.
	Sn interface{}

	// The version identifier. Usually combined with pid & sn. The type is string
	// with length: 1..255.
	Vid interface{}

	// A 32 byte hex value generated by the system.  This will be in proper UUID
	// format 8-4-4-4-12. Often used by VMs or other systems that do not have a
	// hardware identifier. The type is string with pattern:
	// [0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}.
	Uuid interface{}

	// Free form virtual identifier often used by software  only devices like
	// software routers or VMs. The type is string with length: 1..255.
	Suvi interface{}

	// Host identifier available on some systems.  Typically 8 hex digits. The
	// type is string with length: 1..255.
	HostIdentifier interface{}

	// The MAC address of the system. This is usually only used if there  is
	// nothing else available to be used as an identifier. The type is string with
	// pattern: [0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}.
	MacAddress interface{}
}

Licensing_State_StateInfo_Udi UDI of the system.

func (*Licensing_State_StateInfo_Udi) GetEntityData 

func (udi *Licensing_State_StateInfo_Udi) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Usage 

type Licensing_State_StateInfo_Usage struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The ISO 19770 entitlement tag used to define this
	// license. The type is string.
	EntitlementTag interface{}

	// The human readable license name from the entitlement tag. The type is
	// string.
	ShortName interface{}

	// The license name that can be seen in the CSSM portal or on  the satellite.
	// This is only available after the product has registered. The type is
	// string.
	LicenseName interface{}

	// The long description of this license. This is only available after the
	// product has registered. The type is string.
	Description interface{}

	// The in-use count of this license. Note that licensing only reports  usage
	// for licenses that are in use (count of 1 or greater). The type is
	// interface{} with range: 0..4294967295.
	Count interface{}

	// The current enforcement mode of this license. The type is
	// EnforcementModeEnum.
	EnforcementMode interface{}

	// If true then this entitlement is being reported in a post paid mode with
	// utility usage reports. Otherwise it will be reported in  the regular
	// prepaid mode. The type is bool.
	PostPaid interface{}

	// If this entitlement tag is being reported in the post paid utility usage
	// mode and there is a subscription id in the customer's  virtual account this
	// will be that subscription id. The type is string.
	SubscriptionId interface{}
}

Licensing_State_StateInfo_Usage List of license (entitlement tag) usage information. This only contains the information for licenses that are in use.

func (*Licensing_State_StateInfo_Usage) GetEntityData 

func (usage *Licensing_State_StateInfo_Usage) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Utility 

type Licensing_State_StateInfo_Utility struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Utility reporting is enabled. The system still  needs a utility certificate
	// registration or a subscription  to begin reporting actual utility data. The
	// type is bool.
	Enabled interface{}

	// Is the system reporting utility data. If so then what triggered  it to
	// start reporting. If this is utility-reporting-none then all of the times
	// below will be zero. The type is UtilityReportingTypeEnum.
	Reporting interface{}

	// If the product instance is reporting utility data this will contain various
	// timing information about that reporting.
	ReportingTimes Licensing_State_StateInfo_Utility_ReportingTimes

	// Customer address information that will be sent  in the utility usage
	// reports.
	CustomerInfo Licensing_State_StateInfo_Utility_CustomerInfo
}

Licensing_State_StateInfo_Utility State of utility reporting.

func (*Licensing_State_StateInfo_Utility) GetEntityData 

func (utility *Licensing_State_StateInfo_Utility) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Utility_CustomerInfo 

type Licensing_State_StateInfo_Utility_CustomerInfo struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The cisco issued customer id which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	Id interface{}

	// The customer company name which will be included in the utility usage (RUM)
	// report. The type is string with length: 1..250.
	Name interface{}

	// The customer company street address which will be included in the utility
	// usage (RUM) report. The type is string with length: 1..250.
	Street interface{}

	// The customer company city which will be included in the utility usage (RUM)
	// report. The type is string with length: 1..250.
	City interface{}

	// The customer company state which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	State interface{}

	// The customer company country which will be included in the utility usage
	// (RUM) report. The type is string with length: 1..250.
	Country interface{}

	// The customer location specific postal code which will be included in the
	// utility usage (RUM) report. The type is string with length: 1..250.
	PostalCode interface{}
}

Licensing_State_StateInfo_Utility_CustomerInfo Customer address information that will be sent in the utility usage reports.

func (*Licensing_State_StateInfo_Utility_CustomerInfo) GetEntityData 

func (customerInfo *Licensing_State_StateInfo_Utility_CustomerInfo) GetEntityData() *types.CommonEntityData

type Licensing_State_StateInfo_Utility_ReportingTimes 

type Licensing_State_StateInfo_Utility_ReportingTimes struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Time the last report was sent. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	LastReportTime interface{}

	// Was the last report successfully sent?. The type is bool.
	LastReportSuccess interface{}

	// Failure message if the last report send failed. The type is string with
	// length: 0..255.
	FailMessage interface{}

	// Time the next report is scheduled to be sent. The type is string with
	// pattern: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	NextReportTime interface{}
}

Licensing_State_StateInfo_Utility_ReportingTimes If the product instance is reporting utility data this will contain various timing information about that reporting.

func (*Licensing_State_StateInfo_Utility_ReportingTimes) GetEntityData 

func (reportingTimes *Licensing_State_StateInfo_Utility_ReportingTimes) GetEntityData() *types.CommonEntityData

type NotifRegisterFailureEnum 

type NotifRegisterFailureEnum string

NotifRegisterFailureEnum represents detailed failure message. 

const (
	// General failure.
	NotifRegisterFailureEnum_general_failure NotifRegisterFailureEnum = "general-failure"

	// This smart licensing instance is already registered.
	NotifRegisterFailureEnum_already_registered_failure NotifRegisterFailureEnum = "already-registered-failure"

	// The de-register failed because this instance is not registered.
	NotifRegisterFailureEnum_de_register_failure NotifRegisterFailureEnum = "de-register-failure"
)

type RegisterIdToken 

type RegisterIdToken struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Input RegisterIdToken_Input

	Output RegisterIdToken_Output
}

RegisterIdToken Register with an ID token. This will begin the registration process. Since the registration process will take somewhere between seconds and hours you must get the registration-success or registration-fail notifications or check the registration status in smart-license:state to know the status of the registration.

func (*RegisterIdToken) GetEntityData 

func (registerIdToken *RegisterIdToken) GetEntityData() *types.CommonEntityData

type RegisterIdToken_Input 

type RegisterIdToken_Input struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The ID token used to register. The type is string with length: 1..255.
	IdToken interface{}

	// Force the registration if set. The type is bool. The default value is
	// false.
	Force interface{}
}

RegisterIdToken_Input

func (*RegisterIdToken_Input) GetEntityData 

func (input *RegisterIdToken_Input) GetEntityData() *types.CommonEntityData

type RegisterIdToken_Output 

type RegisterIdToken_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The return code.  If smart licensing is not enabled (status:enabled) then
	// the error will be error-enum:notenabled. On success the return code will be
	// error-enum:registrationinprogress. The type is ErrorEnum.
	ReturnCode interface{}
}

RegisterIdToken_Output

func (*RegisterIdToken_Output) GetEntityData 

func (output *RegisterIdToken_Output) GetEntityData() *types.CommonEntityData

type RegistrationStateEnum 

type RegistrationStateEnum string

RegistrationStateEnum represents The smart licensing registration state. 

const (
	// This smart licensing instance is not registered.
	RegistrationStateEnum_reg_state_not_registered RegistrationStateEnum = "reg-state-not-registered"

	// Registration was successful and this smart licensing
	// instance is registered.
	RegistrationStateEnum_reg_state_complete RegistrationStateEnum = "reg-state-complete"

	// Registration is in progress.
	RegistrationStateEnum_reg_state_in_progress RegistrationStateEnum = "reg-state-in-progress"

	// The initial registration attempt failed but
	// a retry is in progress.
	RegistrationStateEnum_reg_state_retry RegistrationStateEnum = "reg-state-retry"

	// Registration failed.
	RegistrationStateEnum_reg_state_failed RegistrationStateEnum = "reg-state-failed"
)

type RenewAuth 

type RenewAuth struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Output RenewAuth_Output
}

RenewAuth Under normal operations smart licensing will automatically renew the license authorization every 30 days. This command can be used if he customer wants to iinitiate a manual renewal.

func (*RenewAuth) GetEntityData 

func (renewAuth *RenewAuth) GetEntityData() *types.CommonEntityData

type RenewAuth_Output 

type RenewAuth_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The return code. The type is ErrorEnum.
	ReturnCode interface{}
}

RenewAuth_Output

func (*RenewAuth_Output) GetEntityData 

func (output *RenewAuth_Output) GetEntityData() *types.CommonEntityData

type RenewId 

type RenewId struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Output RenewId_Output
}

RenewId Under normal operations smart licensing will automatically renew the ID certificates used for regsitration. This command can be used if he customer wants to initiate a manual registration renewal.

func (*RenewId) GetEntityData 

func (renewId *RenewId) GetEntityData() *types.CommonEntityData

type RenewId_Output 

type RenewId_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The return code. The type is ErrorEnum.
	ReturnCode interface{}
}

RenewId_Output

func (*RenewId_Output) GetEntityData 

func (output *RenewId_Output) GetEntityData() *types.CommonEntityData

type TransportTypeEnum 

type TransportTypeEnum string

TransportTypeEnum represents The type of transport in use by smart licensing. 

const (
	// Smart Licensing is using callhome for communications.
	TransportTypeEnum_transport_type_callhome TransportTypeEnum = "transport-type-callhome"

	// Smart licensing is using the smart transport for
	// communications.
	TransportTypeEnum_transport_type_smart TransportTypeEnum = "transport-type-smart"
)

type UtilityReportingTypeEnum 

type UtilityReportingTypeEnum string

UtilityReportingTypeEnum represents What has triggered the system to start reporting utility usage. 

const (
	// The system is not reporting utility usage data.
	UtilityReportingTypeEnum_utility_reporting_type_none UtilityReportingTypeEnum = "utility-reporting-type-none"

	// The system is reporting utility usage data because it has
	// received subscription information from either the SSM or
	// satellite.
	UtilityReportingTypeEnum_utility_reporting_type_subscription UtilityReportingTypeEnum = "utility-reporting-type-subscription"

	// The system is reporting utility usage data because it has
	// received a utility certificate from a Third Party
	// Billing Platform.
	UtilityReportingTypeEnum_utility_reporting_type_certificate UtilityReportingTypeEnum = "utility-reporting-type-certificate"
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.