def __init__(self):
super(LicenseBase, self).__init__()
self.licenseManager = LicenseManager()
self.licenseFactory = XenServerLicenseFactory()
self.licenseFeatureFactory = LicensedFeatureFactory()
self.skus = []
self.hosts = []
self.newLicenseServerName = 'LicenseServer'
self.oldLicenseEdition = None
self.oldLicenseServerName = None
self.graceExpected = False
self.systemObj = None
self.v6 = None
self.addLicenseFile = False
self.skipVerify = False
class DotNetAgentAdapter(object):
def __init__(self,licenseServer):
self.__licenseManager = LicenseManager()
self.__licenseFactory = XenServerLicenseFactory()
self.__v6 = licenseServer.getV6LicenseServer()
self.__licensedEdition = xenrt.TEC().lookup("LICENSED_EDITION")
self.__unlicensedEdition = xenrt.TEC().lookup("UNLICENSED_EDITION")
def applyLicense(self, hostOrPool, sku = None):
if sku == None:
sku = self.__licensedEdition
if issubclass(type(hostOrPool),Pool):
license = self.__licenseFactory.licenseForPool(hostOrPool, sku)
else:
license = self.__licenseFactory.licenseForHost(hostOrPool, sku)
try:
self.__licenseManager.addLicensesToServer(self.__v6,license, getLicenseInUse=False)
except xenrt.XRTError, e:
pass
hostOrPool.licenseApply(self.__v6, license)
class DotNetAgentAdapter(object):
def __init__(self, licenseServer):
self.__licenseManager = LicenseManager()
self.__licenseFactory = XenServerLicenseFactory()
self.__v6 = licenseServer.getV6LicenseServer()
self.__licensedEdition = xenrt.TEC().lookup("LICENSED_EDITION")
self.__unlicensedEdition = xenrt.TEC().lookup("UNLICENSED_EDITION")
def applyLicense(self, hostOrPool, sku=None):
if sku == None:
sku = self.__licensedEdition
if issubclass(type(hostOrPool), Pool):
license = self.__licenseFactory.licenseForPool(hostOrPool, sku)
else:
license = self.__licenseFactory.licenseForHost(hostOrPool, sku)
try:
self.__licenseManager.addLicensesToServer(self.__v6,
license,
getLicenseInUse=False)
except xenrt.XRTError, e:
pass
hostOrPool.licenseApply(self.__v6, license)
def __init__(self,licenseServer):
self.__licenseManager = LicenseManager()
self.__licenseFactory = XenServerLicenseFactory()
self.__v6 = licenseServer.getV6LicenseServer()
self.__licensedEdition = xenrt.TEC().lookup("LICENSED_EDITION")
self.__unlicensedEdition = xenrt.TEC().lookup("UNLICENSED_EDITION")
def _applyMaxLicense(self):
host = self.getDefaultHost()
license = LF().maxLicenseSkuHost(host)
step("Applying license: %s" % license.getEdition())
host.licenseApply(None, license)
def _releaseLicense(self):
host = self.getDefaultHost()
license = LF().licenseForHost(host, XenServerLicenseSKU.Free)
step("Applying license: %s" % license.getEdition())
host.licenseApply(None, license)
class LicenseBase(xenrt.TestCase, object):
def __init__(self):
super(LicenseBase, self).__init__()
self.licenseManager = LicenseManager()
self.licenseFactory = XenServerLicenseFactory()
self.licenseFeatureFactory = LicensedFeatureFactory()
self.skus = []
self.hosts = []
self.newLicenseServerName = 'LicenseServer'
self.oldLicenseEdition = None
self.oldLicenseServerName = None
self.graceExpected = False
self.systemObj = None
self.v6 = None
self.addLicenseFile = False
self.skipVerify = False
def prepare(self, arglist):
if self.getDefaultPool():
self.systemObj = self.getDefaultPool()
else:
self.systemObj = self.getHost("RESOURCE_HOST_1").getPool()
self.parseArgs(arglist)
self.v6 = self.licenseServer(self.newLicenseServerName)
def upgradePool(self):
# Update our internal pool object before starting the upgrade
newP = xenrt.lib.xenserver.poolFactory(xenrt.TEC().lookup(
"PRODUCT_VERSION", None))(self.systemObj.master)
self.systemObj.populateSubclass(newP)
#Perform Rolling Pool Upgrade
xenrt.TEC().logverbose("Performing rolling pool upgrade of %s" %
(self.systemObj.getName()))
self.systemObj = newP.upgrade(rolling=True)
def licenseServer(self, name):
v6 = self.getGuest(name).getV6LicenseServer()
v6.removeAllLicenses()
return v6
def parseArgs(self, arglist):
for arg in arglist:
if arg.startswith('sku'):
self.skus = arg.split('=')[1].split(',')
if arg.startswith('newlicenseserver'):
self.newLicenseServerName = arg.split('=')[1]
if arg.startswith('oldlicenseserver'):
self.oldLicenseServerName = arg.split('=')[1]
if arg.startswith('oldlicensesku'):
self.oldLicenseSku = arg.split('=')[1]
if arg.startswith('expectedsku'):
self.expectedSku = arg.split('=')[1]
if arg.startswith('grace'):
self.graceExpected = True
if arg.startswith('addlicfiles'):
self.addLicenseFile = True
if arg.startswith('skipVerify'):
self.skipVerify = True
def checkGrace(self, host):
licenseInfo = host.getLicenseDetails()
if not 'grace' in licenseInfo['grace']:
xenrt.TEC().logverbose('Host has not got grace license')
return False
expiry = xenrt.util.parseXapiTime(licenseInfo['expiry'])
if (expiry > (xenrt.timenow() + 30 * 25 * 3600 + 1)):
raise xenrt.TEC().logverbose(
"Host has got license expiry date more than 30 days from current time, it has got expiry date: %s "
% expiry)
return True
def checkLicenseExpired(self, host):
licenseInfo = host.getLicenseDetails()
if '19700101T00:00:00Z' != licenseInfo['expiry']:
return False
return True
def featureFlagValidation(self, license=None):
#No license if license has expired or host/pool is not licensed
err = []
if not license:
license = self.licenseFactory.licenseForPool(
self.systemObj, XenServerLicenseSKU.Free)
features = self.licenseFeatureFactory.allFeatureObj(
self.systemObj.master)
hosts = self.systemObj.getHosts()
for feature in features:
if not feature.poolFeatureFlagValue(
self.systemObj
) == self.licenseFeatureFactory.getFeatureState(
self.systemObj.master.productVersion, license.sku,
feature):
err.append(
"Pool level feature flag for feature %s is not same as expected"
% (feature.name))
for host in hosts:
if not feature.hostFeatureFlagValue(
host) == self.licenseFeatureFactory.getFeatureState(
host.productVersion, license.sku, feature):
err.append(
"Host level feature flag for feature %s is not same as expected"
% (feature.name))
if err:
raise xenrt.XRTFailure(err)
def run(self, arglist=None):
for sku in self.skus:
license = self.licenseFactory.licenseForPool(self.systemObj, sku)
licenseinUse = self.licenseManager.addLicensesToServer(
self.v6, license)
self.licenseManager.applyLicense(self.v6, self.systemObj, license,
licenseinUse)
self.featureFlagValidation(license)
self.licenseManager.releaseLicense(self.systemObj)
self.featureFlagValidation()
self.licenseManager.verifyLicenseServer(license,
self.v6,
licenseinUse,
self.systemObj,
reset=True)
def postRun(self):
self.licenseManager.releaseLicense(self.systemObj)
def __init__(self, licenseServer):
self.__licenseManager = LicenseManager()
self.__licenseFactory = XenServerLicenseFactory()
self.__v6 = licenseServer.getV6LicenseServer()
self.__licensedEdition = xenrt.TEC().lookup("LICENSED_EDITION")
self.__unlicensedEdition = xenrt.TEC().lookup("UNLICENSED_EDITION")
def _applyMaxLicense(self):
host = self.getDefaultHost()
license = LF().maxLicenseSkuHost(host)
step("Applying license: %s" % license.getEdition())
host.licenseApply(None, license)
def _releaseLicense(self):
host = self.getDefaultHost()
license = LF().licenseForHost(host, XenServerLicenseSKU.Free)
step("Applying license: %s" % license.getEdition())
host.licenseApply(None, license)
