def __init__(self, name=None, number=None, sku=None, subscription=None,
quantity=None, virt_limit=None, socket_limit=None,
contract=None, quantity_used=None, warning_period=None,
account=None, provides_management=None, service_level=None,
service_type=None, stacking_id=None, virt_only=None):
self.name = name
self.number = number # order number
self.sku = sku # aka the marketing product
self.subscription = subscription # seems to be unused
# total quantity on the order:
self.quantity = safe_int(quantity, None) # rarely used
# actual quantity used by this entitlement:
self.quantity_used = safe_int(quantity_used, 1)
self.virt_limit = virt_limit # unused
self.stacking_id = stacking_id
self.socket_limit = safe_int(socket_limit, None)
self.warning_period = safe_int(warning_period, 0)
self.contract = contract
self.account = account
self.provides_management = provides_management or False
self.service_level = service_level
self.service_type = service_type
self.virt_only = virt_only or False
def stack_id_valid(self, stack_id, ent_certs, on_date=None):
"""
Returns True if the given stack ID is valid.
Assumes that the certificate is valid on the date we're sorting for.
Future and expired certs are filtered out before this is called.
"""
sockets_covered = 0
log.debug("Checking stack validity: %s" % stack_id)
date_to_check = on_date or self.on_date
for ent in ent_certs:
if ent.order.stacking_id == stack_id and \
ent.valid_range.begin() <= date_to_check and \
ent.valid_range.end() >= date_to_check:
quantity = safe_int(ent.order.quantity_used, 1)
sockets = safe_int(ent.order.socket_limit, 1)
sockets_covered += sockets * quantity
log.debug(" system has %s sockets, %s covered by entitlements" %
(self.socket_count, sockets_covered))
if sockets_covered >= self.socket_count or sockets_covered == 0:
return True
return False
def stack_id_valid(self, stack_id, ent_certs, on_date=None):
"""
Returns True if the given stack ID is valid.
Assumes that the certificate is valid on the date we're sorting for.
Future and expired certs are filtered out before this is called.
"""
sockets_covered = 0
log.debug("Checking stack validity: %s" % stack_id)
date_to_check = on_date or self.on_date
for ent in ent_certs:
if ent.getOrder().getStackingId() == stack_id and \
ent.validRange().begin() <= date_to_check and \
ent.validRange().end() >= date_to_check:
quantity = safe_int(ent.getOrder().getQuantityUsed(), 1)
sockets = safe_int(ent.getOrder().getSocketLimit(), 1)
sockets_covered += sockets * quantity
log.debug(" system has %s sockets, %s covered by entitlements" %
(self.socket_count, sockets_covered))
if sockets_covered >= self.socket_count or sockets_covered == 0:
return True
return False
def compare_text(str1, str2):
# Ensure our text fields are compared properly
# 'Unlimited' is greater than all except 'Unlimited'
# All other strings will be converted to an int or None
if str1 == 'Unlimited':
if str2 == 'Unlimited':
return 0
return 1
elif str2 == 'Unlimited':
return -1
int1 = safe_int(str1)
int2 = safe_int(str2)
return cmp(int1, int2)
def compare_text(str1, str2):
# Ensure our text fields are compared properly
# 'Unlimited' is greater than all except 'Unlimited'
# Strings will be converted to an int if possible
if str1 == 'Unlimited':
if str2 == 'Unlimited':
return 0
return 1
elif str2 == 'Unlimited':
return -1
value1 = safe_int(str1, str1)
value2 = safe_int(str2, str2)
return cmp(value1, value2)
def compare_text(str1, str2):
# Ensure our text fields are compared properly
# 'Unlimited' is greater than all except 'Unlimited'
# Strings will be converted to an int if possible
if str1 == 'Unlimited':
if str2 == 'Unlimited':
return 0
return 1
elif str2 == 'Unlimited':
return -1
value1 = safe_int(str1, str1)
value2 = safe_int(str2, str2)
return cmp(value1, value2)
def compare_text(str1, str2):
# Ensure our text fields are compared properly
# 'Unlimited' is greater than all except 'Unlimited'
# All other strings will be converted to an int or None
if str1 == 'Unlimited':
if str2 == 'Unlimited':
return 0
return 1
elif str2 == 'Unlimited':
return -1
int1 = safe_int(str1)
int2 = safe_int(str2)
return cmp(int1, int2)
def __init__(
self,
name=None,
number=None,
sku=None,
subscription=None,
quantity=None,
virt_limit=None,
socket_limit=None,
contract=None,
quantity_used=None,
warning_period=None,
account=None,
provides_management=None,
service_level=None,
service_type=None,
stacking_id=None,
virt_only=None,
ram_limit=None,
core_limit=None,
roles=None,
usage=None,
addons=None,
):
self.name = name
self.number = number # order number
self.sku = sku # aka the marketing product
self.subscription = subscription # seems to be unused
# total quantity on the order:
self.quantity = safe_int(quantity, None) # rarely used
# actual quantity used by this entitlement:
self.quantity_used = safe_int(quantity_used, 1)
self.virt_limit = virt_limit # unused
self.stacking_id = stacking_id
self.socket_limit = safe_int(socket_limit, None)
self.warning_period = safe_int(warning_period, 0)
self.contract = contract
self.account = account
self.provides_management = provides_management or False
self.service_level = service_level
self.service_type = service_type
self.usage = usage
self.roles = roles
self.addons = addons
self.virt_only = virt_only or False
self.ram_limit = safe_int(ram_limit, None)
self.core_limit = safe_int(core_limit, None)
def build_uep(self, options):
return connection.UEPConnection(
username=options.get('username', None),
password=options.get('password', None),
host=options.get('host', None),
ssl_port=connection.safe_int(options.get('port', None)),
handler=options.get('handler', None),
insecure=options.get('insecure', None),
proxy_hostname=options.get('proxy_hostname', None),
proxy_port=options.get('proxy_port', None),
proxy_user=options.get('proxy_user', None),
proxy_password=options.get('proxy_password', None),
restlib_class=connection.BaseRestLib
)
def ent_cert_sockets_valid(self, ent, on_date=None):
"""
Returns True if the given entitlement covers enough sockets for this
system.
If the entitlement has no socket restriction, True will always be
returned.
"""
if ent.order.socket_limit is None:
return True
# We do not check quantity here, as this is not a stacked
# subscription:
sockets_covered = safe_int(ent.order.socket_limit, 1)
log.debug(" system has %s sockets, %s covered by entitlement" % (self.socket_count, sockets_covered))
if sockets_covered >= self.socket_count or sockets_covered == 0:
return True
return False
def ent_cert_sockets_valid(self, ent, on_date=None):
"""
Returns True if the given entitlement covers enough sockets for this
system.
If the entitlement has no socket restriction, True will always be
returned.
"""
if ent.order.socket_limit is None:
return True
# We do not check quantity here, as this is not a stacked
# subscription:
sockets_covered = safe_int(ent.order.socket_limit, 1)
log.debug(" system has %s sockets, %s covered by entitlement" %
(self.socket_count, sockets_covered))
if sockets_covered >= self.socket_count or sockets_covered == 0:
return True
return False
def __init__(self, product_dir, entitlement_dir, facts_dict, on_date=None):
self.product_dir = product_dir
self.entitlement_dir = entitlement_dir
if not on_date:
on_date = datetime.now(GMT())
self.on_date = on_date
self.expired_entitlement_certs = []
self.valid_entitlement_certs = []
# All products installed on this machine, regardless of status. Maps
# installed product ID to product certificate.
self.installed_products = {}
# Installed products which do not have an entitlement that is valid,
# or expired. They may however have entitlements for the future.
# Maps installed product ID to the product certificate.
self.unentitled_products = {}
# Products which are installed, there are entitlements, but they have
# expired on the date in question. If another valid or partially valid
# entitlement provides the installed product, that product should not
# appear in this dict.
# Maps product ID to the expired entitlement certificate:
self.expired_products = {}
# Products that are only partially entitled (aka, "yellow"). If another
# non-stacked entitlement is valid and provides the installed product,
# it will not appear in this dict.
# Maps installed product ID to the stacked entitlement certificates
# providing it.
self.partially_valid_products = {}
# Products which are installed, and entitled on the given date.
# Maps product ID to a list of all valid entitlement certificates:
self.valid_products = {}
# Products which are installed and entitled sometime in the future.
# Maps product ID to future entitlements.
self.future_products = {}
# Maps stack ID to a list of the entitlement certs composing a
# partially valid stack:
self.partial_stacks = {}
# Maps stack ID to a list of the entitlement certs composing a
# valid stack:
self.valid_stacks = {}
self.facts_dict = facts_dict
# Number of sockets on this system:
self.socket_count = 1
if SOCKET_FACT in self.facts_dict:
self.socket_count = safe_int(self.facts_dict[SOCKET_FACT], 1)
else:
log.warn("System has no socket fact, assuming 1.")
log.debug("Sorting product and entitlement cert status for: %s" %
on_date)
self._populate_installed_products()
self._scan_entitlement_certs()
self._scan_for_unentitled_products()
log.debug("valid entitled products: %s" % self.valid_products.keys())
log.debug("expired entitled products: %s" %
self.expired_products.keys())
log.debug("partially entitled products: %s" %
self.partially_valid_products.keys())
log.debug("unentitled products: %s" % self.unentitled_products.keys())
log.debug("future products: %s" % self.future_products.keys())
log.debug("partial stacks: %s" % self.partial_stacks.keys())
log.debug("valid stacks: %s" % self.valid_stacks.keys())
def __init__(self, product_dir, entitlement_dir, facts_dict, on_date=None):
self.product_dir = product_dir
self.entitlement_dir = entitlement_dir
if not on_date:
on_date = datetime.now(GMT())
self.on_date = on_date
self.expired_entitlement_certs = []
self.valid_entitlement_certs = []
# All products installed on this machine, regardless of status. Maps
# installed product ID to product certificate.
self.installed_products = {}
# Installed products which do not have an entitlement that is valid,
# or expired. They may however have entitlements for the future.
# Maps installed product ID to the product certificate.
self.unentitled_products = {}
# Products which are installed, there are entitlements, but they have
# expired on the date in question. If another valid or partially valid
# entitlement provides the installed product, that product should not
# appear in this dict.
# Maps product ID to the expired entitlement certificate:
self.expired_products = {}
# Products that are only partially entitled (aka, "yellow"). If another
# non-stacked entitlement is valid and provides the installed product,
# it will not appear in this dict.
# Maps installed product ID to the stacked entitlement certificates
# providing it.
self.partially_valid_products = {}
# Products which are installed, and entitled on the given date.
# Maps product ID to a list of all valid entitlement certificates:
self.valid_products = {}
# Products which are installed and entitled sometime in the future.
# Maps product ID to future entitlements.
self.future_products = {}
# Maps stack ID to a list of the entitlement certs composing a
# partially valid stack:
self.partial_stacks = {}
# Maps stack ID to a list of the entitlement certs composing a
# valid stack:
self.valid_stacks = {}
self.facts_dict = facts_dict
# Number of sockets on this system:
self.socket_count = 1
if SOCKET_FACT in self.facts_dict:
self.socket_count = safe_int(self.facts_dict[SOCKET_FACT], 1)
else:
log.warn("System has no socket fact, assuming 1.")
log.debug("Sorting product and entitlement cert status for: %s" %
on_date)
self._populate_installed_products()
self._scan_entitlement_certs()
self._scan_for_unentitled_products()
log.debug("valid entitled products: %s" % self.valid_products.keys())
log.debug("expired entitled products: %s" % self.expired_products.keys())
log.debug("partially entitled products: %s" % self.partially_valid_products.keys())
log.debug("unentitled products: %s" % self.unentitled_products.keys())
log.debug("future products: %s" % self.future_products.keys())
log.debug("partial stacks: %s" % self.partial_stacks.keys())
log.debug("valid stacks: %s" % self.valid_stacks.keys())
