def poll_packages(self, release, server_arch, timestamp=0, uuid=None):
log_debug(1, release, server_arch, timestamp, uuid)
# make sure we're dealing with strings here
release = str(release)
server_arch = rhnLib.normalize_server_arch(server_arch)
timestamp = str(timestamp)
uuid = str(uuid)
# get a list of acceptable channels
channel_list = []
channel_list = rhnChannel.applet_channels_for_uuid(uuid)
# it's possible the tie between uuid and rhnServer.id wasn't yet
# made, default to normal behavior
if not channel_list:
channel_list = rhnChannel.get_channel_for_release_arch(
release, server_arch)
channel_list = [channel_list]
# bork if no channels returned
if not channel_list:
log_debug(
8, "No channels for release = '%s', arch = '%s', uuid = '%s'" %
(release, server_arch, uuid))
return {'last_modified': 0, 'contents': []}
last_channel_changed_ts = max(
[a["last_modified"] for a in channel_list])
# make satellite content override a cache caused by hosted
last_channel_changed_ts = str(LongType(last_channel_changed_ts) + 1)
# gotta be careful about channel unsubscriptions...
client_cache_invalidated = None
# we return rhnServer.channels_changed for each row
# in the satellite case, pluck it off the first...
if "server_channels_changed" in channel_list[0]:
sc_ts = channel_list[0]["server_channels_changed"]
if sc_ts and (sc_ts >= last_channel_changed_ts):
client_cache_invalidated = 1
if (last_channel_changed_ts <=
timestamp) and (not client_cache_invalidated):
# XXX: I hate these freaking return codes that return
# different members in the dictinary depending on what
# sort of data you get
log_debug(3, "Client has current data")
return {'use_cached_copy': 1}
# we'll have to return something big - compress
rhnFlags.set("compress_response", 1)
# Mark the response as being already XMLRPC-encoded
rhnFlags.set("XMLRPC-Encoded-Response", 1)
# next, check the cache if we have something with this timestamp
label_list = [str(a["id"]) for a in channel_list]
label_list.sort()
log_debug(4, "label_list", label_list)
cache_key = "applet-poll-%s" % string.join(label_list, "-")
ret = rhnCache.get(cache_key, last_channel_changed_ts)
if ret: # we have a good entry with matching timestamp
log_debug(3, "Cache HIT for", cache_key)
return ret
# damn, need to do some real work from chip's requirements:
# The package list should be an array of hashes with the keys
# nvre, name, version, release, epoch, errata_advisory,
# errata_id, with the errata fields being empty strings if the
# package isn't from an errata.
ret = {'last_modified': last_channel_changed_ts, 'contents': []}
# we search for packages only in the allowed channels - build
# the SQL helper string and dictionary to make the foo IN (
# list ) constructs use bind variables
qlist = []
qdict = {}
for c in channel_list:
v = c["id"]
k = "channel_%s" % v
qlist.append(":%s" % k)
qdict[k] = v
qlist = string.join(qlist, ", ")
# This query is kind of big. One of these days I'm gonna start
# pulling them out and transforming them into views. We can
# also simulate this using several functions exposed out of
# rhnChannel, but there is no difference in speed because we
# need to do more than one query; besides, we cache the hell
# out of it
h = rhnSQL.prepare("""
select distinct
pn.name,
pe.version,
pe.release,
pe.epoch,
e_sq.errata_advisory,
e_sq.errata_synopsis,
e_sq.errata_id
from
rhnPackageName pn,
rhnPackageEVR pe,
rhnChannelNewestPackage cnp
left join
( select sq_e.id as errata_id,
sq_e.synopsis as errata_synopsis,
sq_e.advisory as errata_advisory,
sq_ep.package_id
from
rhnErrata sq_e,
rhnErrataPackage sq_ep,
rhnChannelErrata sq_ce
where sq_ce.errata_id = sq_ep.errata_id
and sq_ce.errata_id = sq_e.id
and sq_ce.channel_id in ( %s )
) e_sq
on cnp.package_id = e_sq.package_id
where
cnp.channel_id in ( %s )
and cnp.name_id = pn.id
and cnp.evr_id = pe.id
""" % (qlist, qlist))
h.execute(**qdict)
plist = h.fetchall_dict()
if not plist:
# We've set XMLRPC-Encoded-Response above
ret = xmlrpclib.dumps((ret, ), methodresponse=1)
return ret
contents = {}
for p in plist:
for k in list(p.keys()):
if p[k] is None:
p[k] = ""
p["nevr"] = "%s-%s-%s:%s" % (p["name"], p["version"], p["release"],
p["epoch"])
p["nvr"] = "%s-%s-%s" % (p["name"], p["version"], p["release"])
pkg_name = p["name"]
if pkg_name in contents:
stored_pkg = contents[pkg_name]
s = [
stored_pkg["name"], stored_pkg["version"],
stored_pkg["release"], stored_pkg["epoch"]
]
n = [p["name"], p["version"], p["release"], p["epoch"]]
log_debug(7, "comparing vres", s, n)
if rhn_rpm.nvre_compare(s, n) < 0:
log_debug(7, "replacing %s with %s" % (pkg_name, p))
contents[pkg_name] = p
else:
# already have a higher vre stored...
pass
else:
log_debug(7, "initial store for %s" % pkg_name)
contents[pkg_name] = p
ret["contents"] = list(contents.values())
# save it in the cache
# We've set XMLRPC-Encoded-Response above
ret = xmlrpclib.dumps((ret, ), methodresponse=1)
rhnCache.set(cache_key, ret, last_channel_changed_ts)
return ret
def new_system_user_pass(self, profile_name, os_release_name,
version, arch, username,
password, other):
""" Registers a new system to an org specified by a username, password, and
optionally an org id.
New for RHEL 5.
All args are strings except other.
other is a dict with:
* org_id - optional. Must be a string that contains the number. If it's
not given, the default org is used.
* reg_num - optional. It should be an EN. It will not be activated. It's
used for automatic subscription to child channels and for deciding which
service level to entitle the machine to (managment, provisioning, etc).
If not given, the machine will only be registered to a base channel and
entitled to the highest level possible.
If a profile is created it will return a dict with:
* system_id - the same xml as was previously returned
* channels - a list of the channels (as strings) the system was
subscribed to
* failed_channels - a list of channels (as strings) that
the system should have been subscribed to but couldn't be because they
don't have the necessary entitlements available. Can contain all the
channels including the base channel.
* system_slots - a list of the system slots used (as strings).
* failed_system_slots - a list of system slots (as strings) that they
should have used but couldn't because there weren't available
entitlements
* universal_activation_key - a list of universal default activation keys
(as strings) that were used while registering.
Allowable slots are 'enterprise_entitled' (management), 'sw_mgr_entitled'
(updates), 'monitoring_entitled' (monitoring add on to management), and
provisioning_entitled (provisioning add on to management).
The call will try to use the highest system slot available. An entry will
be added to failed_system_slots for each one that is tried and fails and
system_slots will contain the one that succeeded if any.
Eg: Calling this on hosted with no reg num and only update entitlements
will result in system_slots containing 'sw_mgr_entitled' and
failed_system_slots containing 'enterprise_entitled'.
If an error occurs which prevents the creation of a profile, a fault will
be raised:
TODO
"""
add_to_seclist(password)
log_debug(4,'in new_system_user_pass')
# release_name wasn't required in the old call, so I'm just going to
# add it to other
other['release_name'] = os_release_name
# Authorize the username and password. Save the returned user object.
user = self.validate_system_user(username, password)
# This creates the rhnServer record and commits it to the db.
# It also assigns the system a base channel.
server_data = self.create_system(user, profile_name,
version,
arch,
other)
# Save the returned Server object
newserv = server_data['server']
# Get the server db id.
server_id = newserv.getid()
# Get the server certificate file
system_certificate = newserv.system_id()
log_debug(4, 'Server id created as %s' % server_id)
failures = []
unknowns = []
# Build our return values.
attempted_channels = []
successful_channels = []
failed_channels = []
actual_channels = rhnChannel.channels_for_server(server_id)
for channel in actual_channels:
successful_channels.append(channel['label'])
# If we don't have any successful channels, we know the base channel
# failed.
if len(successful_channels) == 0:
log_debug(4, 'System %s not subscribed to any channels' % server_id)
# Look up the base channel, and store it as a failure.
try:
base = rhnChannel.get_channel_for_release_arch(
version,
arch, newserv['org_id'])
failed_channels.append(base['label'])
# We want to swallow exceptions here as we are just generating data
# for the review screen in rhn_register.
except:
pass
# Store any of our child channel failures
failed_channels = failed_channels + failures
attempted_system_slots = ['enterprise_entitled', 'sw_mgr_entitled']
successful_system_slots = server_lib.check_entitlement(server_id)
successful_system_slots = successful_system_slots.keys()
failed_system_slots = []
# Check which entitlement level we got, starting with the highest.
i = 0
for slot in attempted_system_slots:
if slot in successful_system_slots:
break
i = i + 1
# Any entitlements we didn't have, we'll store as a failure.
failed_system_slots = attempted_system_slots[0:i]
universal_activation_key = []
if rhnFlags.test("universal_registration_token"):
token = rhnFlags.get("universal_registration_token")
universal_activation_key = token.get_tokens()
return { 'system_id' : system_certificate,
'channels' : successful_channels,
'failed_channels' : failed_channels,
'failed_options' : unknowns,
'system_slots' : successful_system_slots,
'failed_system_slots' : failed_system_slots,
'universal_activation_key' : universal_activation_key
}
def poll_packages(self, release, server_arch, timestamp = 0, uuid = None):
log_debug(1, release, server_arch, timestamp, uuid)
# make sure we're dealing with strings here
release = str(release)
server_arch = rhnLib.normalize_server_arch(server_arch)
timestamp = str(timestamp)
uuid = str(uuid)
# get a list of acceptable channels
channel_list = []
channel_list = rhnChannel.applet_channels_for_uuid(uuid)
# it's possible the tie between uuid and rhnServer.id wasn't yet
# made, default to normal behavior
if not channel_list:
channel_list = rhnChannel.get_channel_for_release_arch(release,
server_arch)
channel_list = [channel_list]
# bork if no channels returned
if not channel_list:
log_debug(8, "No channels for release = '%s', arch = '%s', uuid = '%s'" % (
release, server_arch, uuid))
return { 'last_modified' : 0, 'contents' : [] }
last_channel_changed_ts = max(map(lambda a: a["last_modified"], channel_list))
# make satellite content override a cache caused by hosted
last_channel_changed_ts = str(long(last_channel_changed_ts) + 1)
# gotta be careful about channel unsubscriptions...
client_cache_invalidated = None
# we return rhnServer.channels_changed for each row
# in the satellite case, pluck it off the first...
if channel_list[0].has_key("server_channels_changed"):
sc_ts = channel_list[0]["server_channels_changed"]
if sc_ts and (sc_ts >= last_channel_changed_ts):
client_cache_invalidated = 1
if (last_channel_changed_ts <= timestamp) and (not client_cache_invalidated):
# XXX: I hate these freaking return codes that return
# different members in the dictinary depending on what
# sort of data you get
log_debug(3, "Client has current data")
return { 'use_cached_copy' : 1 }
# we'll have to return something big - compress
rhnFlags.set("compress_response", 1)
# Mark the response as being already XMLRPC-encoded
rhnFlags.set("XMLRPC-Encoded-Response", 1)
# next, check the cache if we have something with this timestamp
label_list = map(lambda a: str(a["id"]), channel_list)
label_list.sort()
log_debug(4, "label_list", label_list)
cache_key = "applet-poll-%s" % string.join(label_list, "-")
ret = rhnCache.get(cache_key, last_channel_changed_ts)
if ret: # we have a good entry with matching timestamp
log_debug(3, "Cache HIT for", cache_key)
return ret
# damn, need to do some real work from chip's requirements:
# The package list should be an array of hashes with the keys
# nvre, name, version, release, epoch, errata_advisory,
# errata_id, with the errata fields being empty strings if the
# package isn't from an errata.
ret = { 'last_modified' : last_channel_changed_ts, 'contents' : [] }
# we search for packages only in the allowed channels - build
# the SQL helper string and dictionary to make the foo IN (
# list ) constructs use bind variables
qlist = []
qdict = {}
for c in channel_list:
v = c["id"]
k = "channel_%s" % v
qlist.append(":%s" % k)
qdict[k] = v
qlist = string.join(qlist, ", ")
# This query is kind of big. One of these days I'm gonna start
# pulling them out and transforming them into views. We can
# also simulate this using several functions exposed out of
# rhnChannel, but there is no difference in speed because we
# need to do more than one query; besides, we cache the hell
# out of it
h = rhnSQL.prepare("""
select distinct
pn.name,
pe.version,
pe.release,
pe.epoch,
e_sq.errata_advisory,
e_sq.errata_synopsis,
e_sq.errata_id
from
rhnPackageName pn,
rhnPackageEVR pe,
rhnChannelNewestPackage cnp
left join
( select sq_e.id as errata_id,
sq_e.synopsis as errata_synopsis,
sq_e.advisory as errata_advisory,
sq_ep.package_id
from
rhnErrata sq_e,
rhnErrataPackage sq_ep,
rhnChannelErrata sq_ce
where sq_ce.errata_id = sq_ep.errata_id
and sq_ce.errata_id = sq_e.id
and sq_ce.channel_id in ( %s )
) e_sq
on cnp.package_id = e_sq.package_id
where
cnp.channel_id in ( %s )
and cnp.name_id = pn.id
and cnp.evr_id = pe.id
""" % (qlist, qlist))
h.execute(**qdict)
plist = h.fetchall_dict()
if not plist:
# We've set XMLRPC-Encoded-Response above
ret = xmlrpclib.dumps((ret, ), methodresponse=1)
return ret
contents = {}
for p in plist:
for k in p.keys():
if p[k] is None:
p[k] = ""
p["nevr"] = "%s-%s-%s:%s" % (
p["name"], p["version"], p["release"], p["epoch"])
p["nvr"] = "%s-%s-%s" % (p["name"], p["version"], p["release"])
pkg_name = p["name"]
if contents.has_key(pkg_name):
stored_pkg = contents[pkg_name]
s = [ stored_pkg["name"],
stored_pkg["version"],
stored_pkg["release"],
stored_pkg["epoch"] ]
n = [ p["name"],
p["version"],
p["release"],
p["epoch"] ]
log_debug(7, "comparing vres", s, n)
if rhn_rpm.nvre_compare(s, n) < 0:
log_debug(7, "replacing %s with %s" % (pkg_name, p))
contents[pkg_name] = p
else:
# already have a higher vre stored...
pass
else:
log_debug(7, "initial store for %s" % pkg_name)
contents[pkg_name] = p
ret["contents"] = contents.values()
# save it in the cache
# We've set XMLRPC-Encoded-Response above
ret = xmlrpclib.dumps((ret, ), methodresponse=1)
rhnCache.set(cache_key, ret, last_channel_changed_ts)
return ret
def new_system_user_pass(self, profile_name, os_release_name,
version, arch, username,
password, other):
""" Registers a new system to an org specified by a username, password, and
optionally an org id.
New for RHEL 5.
All args are strings except other.
other is a dict with:
* org_id - optional. Must be a string that contains the number. If it's
not given, the default org is used.
* reg_num - optional. It should be an EN. It will not be activated. It's
used for automatic subscription to child channels and for deciding which
service level to entitle the machine to (managment, provisioning, etc).
If not given, the machine will only be registered to a base channel and
entitled to the highest level possible.
If a profile is created it will return a dict with:
* system_id - the same xml as was previously returned
* channels - a list of the channels (as strings) the system was
subscribed to
* failed_channels - a list of channels (as strings) that
the system should have been subscribed to but couldn't be because they
don't have the necessary entitlements available. Can contain all the
channels including the base channel.
* system_slots - a list of the system slots used (as strings).
* failed_system_slots - a list of system slots (as strings) that they
should have used but couldn't because there weren't available
entitlements
* universal_activation_key - a list of universal default activation keys
(as strings) that were used while registering.
Allowable slots are 'enterprise_entitled' (management), 'sw_mgr_entitled'
(updates), 'monitoring_entitled' (monitoring add on to management), and
provisioning_entitled (provisioning add on to management).
The call will try to use the highest system slot available. An entry will
be added to failed_system_slots for each one that is tried and fails and
system_slots will contain the one that succeeded if any.
Eg: Calling this on hosted with no reg num and only update entitlements
will result in system_slots containing 'sw_mgr_entitled' and
failed_system_slots containing 'enterprise_entitled'.
If an error occurs which prevents the creation of a profile, a fault will
be raised:
TODO
"""
add_to_seclist(password)
log_debug(4,'in new_system_user_pass')
# release_name wasn't required in the old call, so I'm just going to
# add it to other
other['release_name'] = os_release_name
# Authorize the username and password. Save the returned user object.
user = self.validate_system_user(username, password)
# This creates the rhnServer record and commits it to the db.
# It also assigns the system a base channel.
server_data = self.create_system(user, profile_name,
version,
arch,
other)
# Save the returned Server object
newserv = server_data['server']
# Get the server db id.
server_id = newserv.getid()
# Get the server certificate file
system_certificate = newserv.system_id()
log_debug(4, 'Server id created as %s' % server_id)
failures = []
unknowns = []
# Build our return values.
attempted_channels = []
successful_channels = []
failed_channels = []
actual_channels = rhnChannel.channels_for_server(server_id)
for channel in actual_channels:
successful_channels.append(channel['label'])
# If we don't have any successful channels, we know the base channel
# failed.
if len(successful_channels) == 0:
log_debug(4, 'System %s not subscribed to any channels' % server_id)
# Look up the base channel, and store it as a failure.
try:
base = rhnChannel.get_channel_for_release_arch(
version,
arch, newserv['org_id'])
failed_channels.append(base['label'])
# We want to swallow exceptions here as we are just generating data
# for the review screen in rhn_register.
except:
pass
# Store any of our child channel failures
failed_channels = failed_channels + failures
attempted_system_slots = ['enterprise_entitled', 'sw_mgr_entitled']
successful_system_slots = server_lib.check_entitlement(server_id)
successful_system_slots = successful_system_slots.keys()
failed_system_slots = []
# Check which entitlement level we got, starting with the highest.
i = 0
for slot in attempted_system_slots:
if slot in successful_system_slots:
break
i = i + 1
# Any entitlements we didn't have, we'll store as a failure.
failed_system_slots = attempted_system_slots[0:i]
universal_activation_key = []
if rhnFlags.test("universal_registration_token"):
token = rhnFlags.get("universal_registration_token")
universal_activation_key = token.get_tokens()
return { 'system_id' : system_certificate,
'channels' : successful_channels,
'failed_channels' : failed_channels,
'failed_options' : unknowns,
'system_slots' : successful_system_slots,
'failed_system_slots' : failed_system_slots,
'universal_activation_key' : universal_activation_key
}
