def print_env(fd=sys.stderr):
""" Dump the environment. """
dct = os.environ
fd.write("\nEnvironment for PID=%d on exception:\n" % os.getpid())
el = list(dct.keys())
el.sort()
for k in el:
fd.write("%s = %s\n" % (to_string(k), to_string(dct[k])))
def send(headers, body, sender=None):
(headers, toaddrs) = __check_headers(headers)
if sender is None:
sender = headers["From"]
joined_headers = ''
for h in list(headers.keys()):
joined_headers += "%s: %s\n" % (h, headers[h])
server = smtplib.SMTP('localhost')
msg = "%s\n%s\n" % (to_string(joined_headers), to_string(body))
server.sendmail(sender, toaddrs, msg)
server.quit()
def print_req(req, fd=sys.stderr):
""" get some debugging information about the current exception for sending
out when we raise an exception
"""
fd.write("Request object information:\n")
fd.write("URI: %s\n" % req.unparsed_uri)
fd.write(
"Remote Host: %s\nServer Name: %s:%d\n" %
(req.get_remote_host(), req.server.server_hostname, req.server.port))
fd.write("Headers passed in:\n")
kl = list(req.headers_in.keys())
kl.sort()
for k in kl:
fd.write("\t%s: %s\n" % (to_string(k), to_string(req.headers_in[k])))
return 0
def _execute_(self, args, kwargs):
"""
Oracle specific execution of the query.
"""
# TODO: args appears unused, raise exception if we see any?
# Only copy the arguments we're interested in
_p = UserDictCase(kwargs)
params = {}
# Check that all required parameters were provided:
# NOTE: bindnames() is Oracle specific:
for k in self._real_cursor.bindnames():
if not _p.has_key(k):
# Raise the fault ourselves
raise sql_base.SQLError(1008, 'Not all variables bound', k)
params[k] = to_string(_p[k])
# cx_Oracle expects the first arg to be the statement and no
# positional args:
try:
self._real_cursor.execute(*(None, ), **params)
except cx_Oracle.OperationalError:
e = sys.exc_info()[1]
raise sql_base.SQLError("Cannot execute SQL statement: %s" %
str(e))
self.description = self._real_cursor.description
return self._real_cursor.rowcount
def feed(self, arg):
#sys.stderr.write("arg = %s, type = %s\n" % (arg, type(arg)))
if type(arg) == type(()) or type(arg) == type([]):
for s in arg:
self.sum.update(s.encode())
else:
if type(arg) == type(0):
arg = str(arg)
self.sum.update(to_string(arg).encode())
def _add_result(action_config_revision_id, diff):
log_debug(4, action_config_revision_id, diff)
if diff:
blob_map = {'result': 'result'}
diff = to_string(diff)
else:
blob_map = None
diff = None
h = rhnSQL.prepare(_query_add_result_diff, blob_map=blob_map)
h.execute(action_config_revision_id=action_config_revision_id, result=diff)
def _executemany(self, *args, **kwargs):
# cx_Oracle expects the first arg to be the statement
if not kwargs:
return 0
# Compute number of values
max_array_size = 25
i = iter(list(kwargs.values()))
firstval = next(i)
array_size = len(firstval)
if array_size == 0:
return 0
chunk_size = min(max_array_size, array_size)
pdict = {}
for k in list(kwargs.keys()):
pdict[k] = None
arr = []
for i in range(chunk_size):
arr.append(pdict.copy())
# Now arr is an array of the desired size
rowcount = 0
start = 0
while start < array_size:
item_count = min(array_size - start, chunk_size)
# Trim the array if it is too big
if item_count != chunk_size:
arr = arr[:item_count]
for i in range(item_count):
pdict = arr[i]
for k, v in list(kwargs.items()):
pdict[k] = to_string(v[start + i])
# We clear self->bindVariables so that list of all nulls
# in the previous chunk which caused the type to be set to
# string does not affect our chunk which may have number
# there.
self._real_cursor.setinputsizes(**{})
# arr is now a list of dictionaries. Each dictionary contains the
# data for one execution of the query where the key is the column
# name and the value self explanatory.
self._real_cursor.executemany(None, arr)
self.description = self._real_cursor.description
rowcount = rowcount + self._real_cursor.rowcount
start = start + chunk_size
return rowcount
def print_locals(fd=sys.stderr, tb=None):
""" Dump a listing of all local variables and their value for better debugging
chance.
"""
if tb is None:
tb = sys.exc_info()[2]
stack = []
# walk the traceback to the end
while 1:
if not tb.tb_next:
break
tb = tb.tb_next
# and now start extracting the stack frames
f = tb.tb_frame
while f:
stack.append(f)
f = f.f_back
fd.write("\nLocal variables by frame\n")
for frame in stack:
fd.write(
"Frame %s in %s at line %s\n" %
(frame.f_code.co_name, frame.f_code.co_filename, frame.f_lineno))
for key, value in list(frame.f_locals.items()):
fd.write("\t%20s = " % to_string(key))
# We have to be careful not to cause a new error in our error
# printer! Calling str() on an unknown object could cause an
# error we don't want.
# pylint: disable=W0702
try:
s = str(to_string(value))
except:
s = "<ERROR WHILE PRINTING VALUE>"
if len(s) > 100 * 1024:
s = "<ERROR WHILE PRINTING VALUE: string representation too large>"
fd.write("%s %s\n" % (type(value), s))
fd.write("\n")
def find_or_create_eula(eula):
"""Return the id of the eula inside of the suseEula table.
A new entry inside of the suseEula table is added only when needed.
"""
_query_find = """
SELECT id
FROM suseEula
WHERE checksum = :checksum
"""
checksum = hashlib.new("sha256", eula.encode('utf-8', 'ignore')).hexdigest()
h = rhnSQL.prepare(_query_find)
h.execute(checksum=checksum)
ret = h.fetchone_dict()
if ret:
return ret['id']
else:
_query_create_eula_id = """
SELECT sequence_nextval('suse_eula_id_seq') AS id
FROM dual
"""
h = rhnSQL.prepare(_query_create_eula_id)
h.execute(checksum=checksum)
ret = h.fetchone_dict()
id = None
if ret:
id = ret['id']
else:
raise rhnFault(50, "Unable to add new EULA to the database", explain=0)
blob_map = { 'text': 'text' }
h = rhnSQL.prepare("""
INSERT INTO suseEula (id, text, checksum)
VALUES (:id, :text, :checksum)
""",
blob_map=blob_map)
h.execute(id=id, text=to_string(eula), checksum=checksum)
return id
def reload(self, text):
""" load data from a text certificate passed on by a client """
log_debug(4)
text_id = text.strip()
if not text_id:
return -1
# Now decode this certificate
try:
sysid, junk = xmlrpclib.loads(to_string(text_id))
except:
return -1
else:
s = sysid[0]
del junk
if "system_id" not in s or "fields" not in s:
log_error("Got certificate with missing entries: %s" % s)
return -1
# check the certificate some more
for k in s["fields"]:
if k not in s:
log_error(
"Certificate lists unknown %s as a checksum field" % k,
"cert data: %s" % s)
return -1
# clear out the state
self.__init__()
# at this point we know the certificate is sane enough for the
# following processing
for k in list(s.keys()):
if k == "fields":
self.__fields = s[k]
continue
if k == "checksum":
self.__checksum = s[k]
continue
self.attrs[k] = s[k]
# okay, the certificate is now loaded
return 0
def populate(self,
header,
size,
checksum_type,
checksum,
path=None,
org_id=None,
header_start=None,
header_end=None,
channels=[]):
# XXX is seems to me that this is the place that 'source_rpm' is getting
# set
for f in list(self.keys()):
field = f
if f in self.tagMap:
field = self.tagMap[f]
if not field:
# Unsupported
continue
# get the db field value from the header
val = header[field]
if f == 'build_time':
if type(val) in (IntType, LongType):
# A UNIX timestamp
val = gmtime(val)
if f == 'payload_size':
if val is None:
# use longarchivesize header field for rpms with archive > 4GB
if ('longarchivesize'
in header) and (header['longarchivesize'] > 0):
val = header['longarchivesize']
elif val < 0:
# workaround for older rpms where signed
# attributes go negative for size > 2G
val = LongType(val) + 2**32
elif val:
# Convert to strings
if isinstance(val, UnicodeType):
val = to_string(val)
else:
val = str(val)
elif val == []:
val = None
self[f] = val
self['package_size'] = size
self['checksum_type'] = checksum_type
self['checksum'] = checksum
self['checksums'] = {checksum_type: checksum}
self['path'] = path
self['org_id'] = org_id
self['header_start'] = header_start
self['header_end'] = header_end
self['last_modified'] = localtime(time.time())
if 'sigmd5' in self:
if self['sigmd5']:
self['sigchecksum_type'] = 'md5'
self['sigchecksum'] = self['sigmd5']
del (self['sigmd5'])
# Fix some of the information up
vendor = self['vendor'] or None
payloadFormat = self['payload_format']
if payloadFormat is None:
self['payload_format'] = 'cpio'
if self['payload_size'] is None:
self['payload_size'] = 0
return self
def Traceback(method=None,
req=None,
mail=1,
ostream=sys.stderr,
extra=None,
severity="notification",
with_locals=0):
""" Reports an traceback error and optionally sends mail about it.
NOTE: extra = extra text information.
"""
# pylint: disable=C0103
global QUIET_MAIL
if mail:
# safeguard
if QUIET_MAIL is None:
QUIET_MAIL = CFG.QUIET_MAIL
if QUIET_MAIL < 0:
QUIET_MAIL = 0
if QUIET_MAIL == 0: # make sure we don't mail
mail = 0
e_type = sys.exc_info()[:2][0]
t = time.ctime(time.time())
exc = StringIO()
unicode_hostname = idn_puny_to_unicode(hostname)
exc.write("Exception reported from %s\nTime: %s\n" %
(to_string(unicode_hostname), t))
exc.write("Exception type %s\n" % to_string(e_type))
if method:
exc.write("Exception while handling function %s\n" % to_string(method))
# print information about the request being served
if req:
print_req(req, exc)
if extra:
exc.write("Extra information about this error:\n%s\n" %
to_string(extra))
# Print the traceback
exc.write("\nException Handler Information\n")
traceback.print_exc(None, exc)
if with_locals and not mail:
# The mail case will call print_locals by itself
print_locals(exc)
# we always log it somewhere
if ostream:
ostream.write(to_string(exc.getvalue()))
ostream.write("\n")
if mail:
# print the stack frames for the mail we send out
print_locals(exc)
# dump the environment
print_env(exc)
# and send the mail
# build the headers
to = CFG.TRACEBACK_MAIL
fr = to
if isinstance(to, type([])):
fr = to[0].strip()
to = ', '.join([x.strip() for x in to])
headers = {
"Subject":
"%s TRACEBACK from %s" % (PRODUCT_NAME, unicode_hostname),
"From": "%s <%s>" % (hostname, fr),
"To": to,
"X-RHN-Traceback-Severity": severity,
"Content-Type": 'text/plain; charset="utf-8"',
}
QUIET_MAIL = QUIET_MAIL - 1 # count it no matter what
outstring = to_string(exc.getvalue())
# 5/18/05 wregglej - 151158 Go through every string in the security list
# and censor it out of the debug information.
outstring = censor_string(outstring)
rhnMail.send(headers, outstring)
exc.close()
return
def __init__(self, header, size, checksum_type, checksum, path=None, org_id=None,
channels=[]):
headerSource.rpmBinaryPackage.__init__(self)
self.tagMap = headerSource.rpmBinaryPackage.tagMap.copy()
# Remove already-mapped tags
self._already_mapped = [
'rpm_version', 'payload_size', 'payload_format',
'package_group', 'build_time', 'build_host'
]
for t in self._already_mapped:
if t in self.tagMap:
del self.tagMap[t]
# XXX is seems to me that this is the place that 'source_rpm' is getting
# set
for f in list(self.keys()):
field = f
if f in self.tagMap:
field = self.tagMap[f]
if not field:
# Unsupported
continue
# get the db field value from the header
val = header[field]
if f == 'build_time':
if val is not None and isinstance(val, IntType):
# A UNIX timestamp
val = gmtime(val)
elif val:
# Convert to strings
if isinstance(val, UnicodeType):
val = to_string(val)
else:
val = str(val)
elif val == []:
val = None
self[f] = val
self['package_size'] = size
self['checksum_type'] = checksum_type
self['checksum'] = checksum
self['path'] = path
self['org_id'] = org_id
self['header_start'] = None
self['header_end'] = None
self['last_modified'] = localtime(time.time())
if self['sigmd5']:
self['sigchecksum_type'] = 'md5'
self['sigchecksum'] = self['sigmd5']
del(self['sigmd5'])
# Fix some of the information up
vendor = self['vendor']
if vendor is None:
self['vendor'] = 'Debian'
payloadFormat = self['payload_format']
if payloadFormat is None:
self['payload_format'] = 'ar'
if self['payload_size'] is None:
self['payload_size'] = 0
# Populate file information
self._populateFiles(header)
# Populate dependency information
self._populateDependencyInformation(header)
# Populate changelogs
self._populateChangeLog(header)
# Channels
self._populateChannels(channels)
# populate extraTags from headers not in already mapped fields
self._populateExtraTags(header)
self['source_rpm'] = None
group = self.get('package_group', '')
if group == '' or group is None:
self['package_group'] = 'NoGroup'
