def delete_profiles(profs, dbo, table):
''' deletes all database entries matching user's command line options
Args:
profs - list of profiles to delete by name
dbo - database object
table - database table name
Returns: True if any errors encountered, False otherwise
Exceptions: none
'''
# if any serious errors encountered, set exit status
has_errors = False
queue = dbo.getQueue()
# Build a list of criteria for WHERE clause
db_cols = [u'rowid'] + [u'file']
# loop through all profiles from command line and delete them
for profile_name in profs:
query_str = "SELECT " + ", ".join(db_cols) + " FROM " + table + \
" WHERE name=" + AIdb.format_value('name', profile_name)
logging.debug("query=" + query_str)
query = AIdb.DBrequest(query_str, commit=True)
queue.put(query)
query.waitAns()
# check response, if failure, getResponse prints error
rsp = query.getResponse()
if rsp is None:
has_errors = True
continue
if len(rsp) == 0:
print >> sys.stderr, _("\tProfile %s not found.") % profile_name
has_errors = True
continue
# delete database record and any accompanying internal profile file
for response in rsp:
deldict = dict()
iresponse = iter(response)
for crit in db_cols:
deldict[crit] = next(iresponse)
query_str = "DELETE FROM %s WHERE rowid=%d" % \
(table, deldict['rowid'])
delquery = AIdb.DBrequest(query_str, commit=True)
queue.put(delquery)
delquery.waitAns()
# check response, if failure, getResponse prints error
if delquery.getResponse() is None:
has_errors = True
continue
print >> sys.stderr, _("\tDeleted profile %s.") % profile_name
# delete static (internal) files only
if deldict['file'] is None or \
not deldict['file'].startswith(sc.INTERNAL_PROFILE_DIRECTORY):
continue
try:
os.unlink(deldict['file'])
except OSError, (errno, errmsg):
if errno != ENOENT: # does not exist
print >> sys.stderr, _(
"Error (%s): Problem deleting %s (%s): %s") \
% (errno, profile_name, deldict['file'], errmsg)
has_errors = True
continue
def validate_internal(profile_list, database, table, image_dir):
''' given a list of profile files and the profile database and table,
validate the list of profiles
Args:
profile_list - list of profile path names
database - name of database
table - name of database table
image_dir - path of service image, used to locate service_bundle
Returns True if all profiles are valid, return False if any are invalid
'''
# Open the database
dbn = AIdb.DB(database, commit=True)
dbn.verifyDBStructure()
isvalid = True
queue = dbn.getQueue()
if not profile_list:
profile_list = [None]
for profile in profile_list:
qstr = "SELECT name, file FROM %s WHERE name = %s" % \
(table, AIdb.format_value('name', profile))
query = AIdb.DBrequest(qstr, commit=True)
queue.put(query)
query.waitAns()
# check response, if failure, getResponse prints error
if query.getResponse() is None: # database error
return False # give up
if len(query.getResponse()) == 0:
print >> sys.stderr, \
_('No profiles in database with basename ') + profile
isvalid = False
continue # to the next profile
for response in query.getResponse():
if not df.validate_file(response[0], response[1], image_dir):
isvalid = False
return isvalid
def add_profile(criteria, profile_name, profile_file, queue, table):
"""
Set a profile record in the database with the criteria provided.
Args:
criteria - criteria object
profile_name - name of profile to add
profile_file - path of profile to add
queue - database request queue
table - profile table in database
Returns: True if successful, false otherwise
Effects:
database record added
stored resulting profile in internal profile directory
"""
# get lists prepared for SQLite WHERE, INSERT VALUES from command line
(wherel, insertl, valuesl) = \
sc.sql_values_from_criteria(criteria, queue, table)
# clear any profiles exactly matching the criteria
wherel += ["name=" + AIdb.format_value('name', profile_name)]
q_str = "DELETE FROM " + table + " WHERE " + " AND ".join(wherel)
query = AIdb.DBrequest(q_str, commit=True)
queue.put(query)
query.waitAns()
if query.getResponse() is None:
return False
# add profile to database
insertl += ["name"]
valuesl += [AIdb.format_value('name', profile_name)]
insertl += ["file"]
valuesl += [AIdb.format_value('name', profile_file)]
q_str = "INSERT INTO " + table + "(" + ", ".join(insertl) + \
") VALUES (" + ", ".join(valuesl) + ")"
query = AIdb.DBrequest(q_str, commit=True)
queue.put(query)
query.waitAns()
if query.getResponse() is None:
return False
print >> sys.stderr, _('Profile %s added to database.') % profile_name
return True
def is_name_in_table(name, queue, table):
''' Determine if profile already registered for service and same basename
Args:
name - profile name
queue - database queue for profiles
table - profile table name
Returns True if any records are found, False if no records found
'''
query_str = "SELECT * FROM %s WHERE name='%s'" % \
(table, AIdb.sanitizeSQL(name))
query = AIdb.DBrequest(query_str)
queue.put(query)
query.waitAns()
return len(query.getResponse()) > 0
def do_export_profile(options):
'''
Export a profile.
'''
save_errno = 0
# Open the database
aisql = AIdb.DB(options.service.database_path, commit=True)
aisql.verifyDBStructure()
queue = aisql.getQueue()
for pname in options.pnames:
# sanitize and format for SELECT
fmtname = AIdb.format_value('name', pname)
q_str = "SELECT file FROM " + AIdb.PROFILES_TABLE + \
" WHERE name=" + fmtname
query = AIdb.DBrequest(q_str)
queue.put(query)
query.waitAns()
# check response, if failure, getResponse prints error
if query.getResponse() is None:
continue
if len(query.getResponse()) == 0:
print >> sys.stderr, _("Profile %s not found.") % fmtname
continue
for row in query.getResponse():
profpath = row['file']
if options.output_isdir:
output_name = "/".join([options.output_name, pname])
else:
output_name = options.output_name
if output_name == SCREEN and options.file_count > 1:
display_file_header(_("profile: ") + pname)
try:
shutil.copyfile(profpath, output_name)
except IOError as err:
print >> sys.stderr, _(
"Error exporting profile: "
"%(error)s: %(file)s") % ({
"error": err.strerror,
"file": err.filename
})
save_errno = err.errno
print
return save_errno
def get_columns(queue, table):
''' From database queue and table, get database columns
Returns database columns as list
Args:
queue - database queue object
table - database table name
'''
query = AIdb.DBrequest("PRAGMA table_info(" + table + ")")
queue.put(query)
query.waitAns()
columns = list()
# build a query so we can determine which columns (criteria) are in use
# using the output from the PRAGMA statement
for col in iter(query.getResponse()):
columns += [col['name']]
return columns
def delete_manifest_from_db(db, manifest_instance, service_name, data_loc):
"""
Remove manifest from DB
"""
instance = manifest_instance[1]
# check to see that the manifest is found in the database (as entered)
if manifest_instance[0] not in AIdb.getManNames(db.getQueue()):
# since all manifest names have to have .xml appended try adding that
if manifest_instance[0] + '.xml' in AIdb.getManNames(db.getQueue()):
man_name = manifest_instance[0] + '.xml'
else:
raise SystemExit(_("Error:\tManifest %s not found in database!" %
manifest_instance[0]))
else:
man_name = manifest_instance[0]
service = AIService(service_name)
# Do not delete if this manifest is set up as the default.
if man_name == service.get_default_manifest():
raise ValueError(_("Error:\tCannot delete default manifest %s.") %
man_name)
# if we do not have an instance remove the entire manifest
if instance is None:
# remove manifest from database
query = AIdb.DBrequest("DELETE FROM manifests WHERE name = '%s'" %
AIdb.sanitizeSQL(man_name), commit=True)
db.getQueue().put(query)
query.waitAns()
# run getResponse to handle and errors
query.getResponse()
# clean up file on file system
try:
os.remove(os.path.join(service.manifest_dir, man_name))
except OSError:
print >> sys.stderr, _("Warning:\tUnable to find file %s for " +
"removal!") % man_name
# we are removing a specific instance
else:
# check that the instance number is within bounds for that manifest
# (0..numInstances)
if instance > AIdb.numInstances(man_name, db.getQueue()) or \
instance < 0:
raise SystemExit(_("Error:\tManifest %(name)s has %(num)i "
"instances" % {'name': man_name, 'num':
AIdb.numInstances(man_name, db.getQueue())}))
# remove instance from database
query = ("DELETE FROM manifests WHERE name = '%s' AND "
"instance = '%i'") % (AIdb.sanitizeSQL(man_name), instance)
query = AIdb.DBrequest(query, commit=True)
db.getQueue().put(query)
query.waitAns()
# run getResponse to handle and errors
query.getResponse()
# We may need to reshuffle manifests to prevent gaps in instance
# numbering as the DB routines expect instances to be contiguous and
# increasing. We may have removed an instance with instances numbered
# above thus leaving a gap.
# get the number of instances with a larger instance
for num in range(instance, AIdb.numInstances(man_name,
db.getQueue()) + 1):
# now decrement the instance number
query = ("UPDATE manifests SET instance = '%i' WHERE "
"name = '%s' ") % (num - 1, AIdb.sanitizeSQL(man_name))
query += "AND instance = '%i'" % num
query = AIdb.DBrequest(query, commit=True)
db.getQueue().put(query)
query.waitAns()
# run getResponse to handle and errors
query.getResponse()
# remove file if manifest is no longer in database
if man_name not in AIdb.getManNames(db.getQueue()):
try:
os.remove(os.path.join(service.manifest_dir, man_name))
except OSError:
print >> sys.stderr, _("Warning: Unable to find file %s for " +
"removal!") % man_name
def send_manifest(form_data,
port=0,
servicename=None,
protocolversion=COMPATIBILITY_VERSION,
no_default=False):
'''Replies to the client with matching service for a service.
Args
form_data - the postData passed in from the client request
port - the port of the old client
servicename - the name of the service being used
protocolversion - the version of the AI service RE: handshake
no_default - boolean flag to signify whether or not we should hand
back the default manifest and profiles if one cannot
be matched based on the client criteria.
Returns
None
Raises
None
'''
# figure out the appropriate path for the AI database,
# and get service name if necessary.
# currently service information is stored in a port directory.
# When the cherrypy webserver new service directories should be
# separated via service-name only. Old services will still use
# port numbers as the separation mechanism.
path = None
found_servicename = None
service = None
port = str(port)
if servicename:
service = AIService(servicename)
path = service.database_path
else:
for name in config.get_all_service_names():
if config.get_service_port(name) == port:
found_servicename = name
service = AIService(name)
path = service.database_path
break
# Check to insure that a valid path was found
if not path or not os.path.exists(path):
print 'Content-Type: text/html' # HTML is following
print # blank line, end of headers
if servicename:
print '<pre><b>Error</b>:unable to find<i>', servicename + '</i>.'
else:
print '<pre><b>Error</b>:unable to find<i>', port + '</i>.'
print 'Available services are:<p><ol><i>'
hostname = socket.gethostname()
for name in config.get_all_service_names():
port = config.get_service_port(name)
sys.stdout.write(
'<a href="http://%s:%d/cgi-bin/'
'cgi_get_manifest.py?version=%s&service=%s">%s</a><br>\n' %
(hostname, port, VERSION, name, name))
print '</i></ol>Please select a service from the above list.'
return
if found_servicename:
servicename = found_servicename
# load to the AI database
aisql = AIdb.DB(path)
aisql.verifyDBStructure()
# convert the form data into a criteria dictionary
criteria = dict()
orig_data = form_data
while form_data:
try:
[key_value, form_data] = form_data.split(';', 1)
except (ValueError, NameError, TypeError, KeyError):
key_value = form_data
form_data = ''
try:
[key, value] = key_value.split('=')
criteria[key] = value
except (ValueError, NameError, TypeError, KeyError):
criteria = dict()
# Generate templating dictionary from criteria
template_dict = dict()
for crit in criteria:
template_dict["AI_" + crit.upper()] = \
AIdb.formatValue(crit, criteria[crit], units=False)
# find the appropriate manifest
try:
manifest = AIdb.findManifest(criteria, aisql)
except StandardError as err:
print 'Content-Type: text/html' # HTML is following
print # blank line, end of headers
print '<pre><b>Error</b>:findManifest criteria<br>'
print err, '<br>'
print '<ol>servicename =', servicename
print 'port =', port
print 'path =', path
print 'form_data =', orig_data
print 'criteria =', criteria
print 'servicename found by port =', found_servicename, '</ol>'
print '</pre>'
return
# check if findManifest() returned a number equal to 0
# (means we got no manifests back -- thus we serve the default if desired)
if manifest is None and not no_default:
manifest = service.get_default_manifest()
# if we have a manifest to return, prepare its return
if manifest is not None:
try:
# construct the fully qualified filename
filename = os.path.abspath(
os.path.join(service.manifest_dir, manifest))
# open and read the manifest
with open(filename, 'rb') as mfp:
manifest_str = mfp.read()
# maintain compability with older AI client
if servicename is None or \
float(protocolversion) < float(PROFILES_VERSION):
content_type = mimetypes.types_map.get('.xml', 'text/plain')
print 'Content-Length:', len(
manifest_str) # Length of the file
print 'Content-Type:', content_type # XML is following
print # blank line, end of headers
print manifest_str
logging.info('Manifest sent from %s.' % filename)
return
except OSError as err:
print 'Content-Type: text/html' # HTML is following
print # blank line, end of headers
print '<pre>'
# report the internal error to error_log and requesting client
sys.stderr.write(_('error:manifest (%s) %s\n') % \
(str(manifest), err))
sys.stdout.write(_('error:manifest (%s) %s\n') % \
(str(manifest), err))
print '</pre>'
return
# get AI service image path
service = AIService(servicename)
image_dir = service.image.path
# construct object to contain MIME multipart message
outermime = MIMEMultipart()
client_msg = list() # accumulate message output for AI client
# If we have a manifest, attach it to the return message
if manifest is not None:
# add manifest as attachment
msg = MIMEText(manifest_str, 'xml')
# indicate manifest using special name
msg.add_header('Content-Disposition',
'attachment',
filename=sc.AI_MANIFEST_ATTACHMENT_NAME)
outermime.attach(msg) # add manifest as an attachment
# search for any profiles matching client criteria
# formulate database query to profiles table
q_str = "SELECT DISTINCT name, file FROM " + \
AIdb.PROFILES_TABLE + " WHERE "
nvpairs = list() # accumulate criteria values from post-data
# for all AI client criteria
for crit in AIdb.getCriteria(aisql.getQueue(),
table=AIdb.PROFILES_TABLE,
onlyUsed=False):
if crit not in criteria:
msgtxt = _("Warning: client criteria \"%s\" not provided in "
"request. Setting value to NULL for profile lookup.") \
% crit
client_msg += [msgtxt]
logging.warn(msgtxt)
# fetch only global profiles destined for all clients
if AIdb.isRangeCriteria(aisql.getQueue(), crit,
AIdb.PROFILES_TABLE):
nvpairs += ["MIN" + crit + " IS NULL"]
nvpairs += ["MAX" + crit + " IS NULL"]
else:
nvpairs += [crit + " IS NULL"]
continue
# prepare criteria value to add to query
envval = AIdb.sanitizeSQL(criteria[crit])
if AIdb.isRangeCriteria(aisql.getQueue(), crit, AIdb.PROFILES_TABLE):
# If no default profiles are requested, then we mustn't allow
# this criteria to be NULL. It must match the client's given
# value for this criteria.
if no_default:
if crit == "mac":
nvpairs += ["(HEX(MIN" + crit + ")<=HEX(X'" + envval + \
"'))"]
nvpairs += ["(HEX(MAX" + crit + ")>=HEX(X'" + envval + \
"'))"]
else:
nvpairs += ["(MIN" + crit + "<='" + envval + "')"]
nvpairs += ["(MAX" + crit + ">='" + envval + "')"]
else:
if crit == "mac":
nvpairs += [
"(MIN" + crit + " IS NULL OR "
"HEX(MIN" + crit + ")<=HEX(X'" + envval + "'))"
]
nvpairs += [
"(MAX" + crit + " IS NULL OR HEX(MAX" + crit +
")>=HEX(X'" + envval + "'))"
]
else:
nvpairs += [
"(MIN" + crit + " IS NULL OR MIN" + crit + "<='" +
envval + "')"
]
nvpairs += [
"(MAX" + crit + " IS NULL OR MAX" + crit + ">='" +
envval + "')"
]
else:
# If no default profiles are requested, then we mustn't allow
# this criteria to be NULL. It must match the client's given
# value for this criteria.
#
# Also, since this is a non-range criteria, the value stored
# in the DB may be a whitespace separated list of single
# values. We use a special user-defined function in the
# determine if the given criteria is in that textual list.
if no_default:
nvpairs += ["(is_in_list('" + crit + "', '" + envval + \
"', " + crit + ", 'None') == 1)"]
else:
nvpairs += ["(" + crit + " IS NULL OR is_in_list('" + crit + \
"', '" + envval + "', " + crit + ", 'None') == 1)"]
if len(nvpairs) > 0:
q_str += " AND ".join(nvpairs)
# issue database query
logging.info("Profile query: " + q_str)
query = AIdb.DBrequest(q_str)
aisql.getQueue().put(query)
query.waitAns()
if query.getResponse() is None or len(query.getResponse()) == 0:
msgtxt = _("No profiles found.")
client_msg += [msgtxt]
logging.info(msgtxt)
else:
for row in query.getResponse():
profpath = row['file']
profname = row['name']
if profname is None: # should not happen
profname = 'unnamed'
try:
if profpath is None:
msgtxt = "Database record error - profile path is " \
"empty."
client_msg += [msgtxt]
logging.error(msgtxt)
continue
msgtxt = _('Processing profile %s') % profname
client_msg += [msgtxt]
logging.info(msgtxt)
with open(profpath, 'r') as pfp:
raw_profile = pfp.read()
# do any template variable replacement {{AI_xxx}}
tmpl_profile = sc.perform_templating(
raw_profile, template_dict)
# precautionary validation of profile, logging only
sc.validate_profile_string(tmpl_profile,
image_dir,
dtd_validation=True,
warn_if_dtd_missing=True)
except IOError as err:
msgtxt = _("Error: I/O error: ") + str(err)
client_msg += [msgtxt]
logging.error(msgtxt)
continue
except OSError:
msgtxt = _("Error: OS error on profile ") + profpath
client_msg += [msgtxt]
logging.error(msgtxt)
continue
except KeyError:
msgtxt = _('Error: could not find criteria to substitute '
'in template: ') + profpath
client_msg += [msgtxt]
logging.error(msgtxt)
logging.error('Profile with template substitution error:' +
raw_profile)
continue
except lxml.etree.XMLSyntaxError as err:
# log validation error and proceed
msgtxt = _(
'Warning: syntax error found in profile: ') \
+ profpath
client_msg += [msgtxt]
logging.error(msgtxt)
for error in err.error_log:
msgtxt = _('Error: ') + error.message
client_msg += [msgtxt]
logging.error(msgtxt)
logging.info([
_('Profile failing validation: ') +
lxml.etree.tostring(root)
])
# build MIME message and attach to outer MIME message
msg = MIMEText(tmpl_profile, 'xml')
# indicate in header that this is an attachment
msg.add_header('Content-Disposition',
'attachment',
filename=profname)
# attach this profile to the manifest and any other profiles
outermime.attach(msg)
msgtxt = _('Parsed and loaded profile: ') + profname
client_msg += [msgtxt]
logging.info(msgtxt)
# any profiles and AI manifest have been attached to MIME message
# specially format list of messages for display on AI client console
if client_msg:
outtxt = ''
for msgtxt in client_msg:
msgtxt = _('SC profile locator:') + msgtxt
outtxt += str(msgtxt) + '\n'
# add AI client console messages as single plain text attachment
msg = MIMEText(outtxt, 'plain') # create MIME message
outermime.attach(msg) # attach MIME message to response
print outermime.as_string() # send MIME-formatted message
def do_update_profile(cmd_options=None):
''' Updates exisiting profile
Arg: cmd_options - command line options
Effect: update existing profile
Raises SystemExit if condition cannot be handled
'''
# check for authorization and euid
try:
check_auth_and_euid(PROFILE_AUTH)
except UnauthorizedUserError as err:
raise SystemExit(err)
options = parse_options(DO_UPDATE, cmd_options)
# verify the file
profile_file = options.profile_file[0]
if not os.path.exists(profile_file):
raise SystemExit(_("Error:\tFile does not exist: %s\n") % profile_file)
# get profile name
if not options.profile_name:
profile_name = os.path.basename(profile_file)
else:
profile_name = options.profile_name
# get AI service image path and database name
service = AIService(options.service_name)
dbname = service.database_path
image_dir = service.image.path
# open database
dbn = AIdb.DB(dbname, commit=True)
dbn.verifyDBStructure()
queue = dbn.getQueue()
# Handle old DB versions which did not store a profile.
if not AIdb.tableExists(queue, AIdb.PROFILES_TABLE):
raise SystemExit(
_("Error:\tService %s does not support profiles") %
options.service_name)
# check for the existence of profile
missing_profile_error = _("Error:\tService {service} has no profile "
"named {profile}.")
if not sc.is_name_in_table(profile_name, queue, AIdb.PROFILES_TABLE):
raise SystemExit(
missing_profile_error.format(service=options.service_name,
profile=profile_name))
# validates the profile and report the errors if found
raw_profile = df.validate_file(profile_name,
profile_file,
image_dir,
verbose=False)
if not raw_profile:
raise SystemExit(1)
# create file from string and report failures
tmp_profile_path = copy_profile_internally(raw_profile)
if not tmp_profile_path:
raise SystemExit(1)
# get the path of profile in db
q_str = "SELECT file FROM " + AIdb.PROFILES_TABLE + " WHERE name=" \
+ AIdb.format_value('name', profile_name)
query = AIdb.DBrequest(q_str)
queue.put(query)
query.waitAns()
response = query.getResponse()
# database error
if response is None:
raise SystemExit(
missing_profile_error.format(service=options.service_name,
profile=profile_name))
db_profile_path = response[0][0]
# replace the file
try:
shutil.copyfile(tmp_profile_path, db_profile_path)
except IOError as err:
raise SystemExit(
_("Error writing profile %(profile)s: %(err)s") % {
'profile': profile_name,
'err': err
})
finally:
os.unlink(tmp_profile_path)
print >> sys.stderr, _("Profile updated successfully.")
def set_criteria(criteria, iname, dbn, table, append=False):
"""
Set a manifest's record in the criteria database with the
criteria provided.
If append is True -- append ones that aren't already set for
the manifest, and replace ones that are.
if append is False -- completely remove all criteria already
set for the manifest, and use only the criteria specified.
"""
# Build a list of criteria nvpairs to update
nvpairs = list()
# we need to fill in the criteria or NULLs for each criteria the database
# supports (so iterate over each criteria)
for crit in AIdb.getCriteria(dbn.getQueue(),
table=table,
onlyUsed=False,
strip=True):
# Determine if this crit is a range criteria or not.
is_range_crit = AIdb.isRangeCriteria(dbn.getQueue(), crit)
# Get the value from the manifest
values = criteria[crit]
# the criteria manifest didn't specify this criteria
if values is None:
# If we not appending criteria, then we must write in NULLs
# for this criteria since we're removing all criteria not
# specified.
if not append:
# if the criteria we're processing is a range criteria, fill in
# NULL for two columns, MINcrit and MAXcrit
if is_range_crit:
nvpairs.append("MIN" + crit + "=NULL")
nvpairs.append("MAX" + crit + "=NULL")
# this is a single value
else:
nvpairs.append(crit + "=NULL")
# Else if this is a value criteria (not a range), insert the
# value as a space-separated list of values in case a list of
# values have been given.
elif not is_range_crit:
nvstr = crit + "='" + AIdb.sanitizeSQL(" ".join(values)) + "'"
nvpairs.append(nvstr)
# Else the values are a list this is a range criteria
else:
# Set the MIN column for this range criteria
nvpairs.append("MIN" + crit + "=" +
AIdb.format_value(crit, values[0]))
# Set the MAX column for this range criteria
nvpairs.append("MAX" + crit + "=" +
AIdb.format_value(crit, values[1]))
query = "UPDATE " + table + " SET " + ",".join(nvpairs) + \
" WHERE name='" + iname + "'"
# update the DB
query = AIdb.DBrequest(query, commit=True)
dbn.getQueue().put(query)
query.waitAns()
# in case there's an error call the response function (which
# will print the error)
query.getResponse()
def insert_SQL(files):
"""
Ensures all data is properly sanitized and formatted, then inserts it into
the database
Args: None
Returns: None
"""
query = "INSERT INTO manifests VALUES("
# add the manifest name to the query string
query += "'" + AIdb.sanitizeSQL(files.manifest_name) + "',"
# check to see if manifest name is already in database (affects instance
# number)
if AIdb.sanitizeSQL(files.manifest_name) in \
AIdb.getManNames(files.database.getQueue()):
# database already has this manifest name get the number of
# instances
instance = AIdb.numInstances(AIdb.sanitizeSQL(files.manifest_name),
files.database.getQueue())
# this a new manifest
else:
instance = 0
# actually add the instance to the query string
query += str(instance) + ","
# we need to fill in the criteria or NULLs for each criteria the database
# supports (so iterate over each criteria)
for crit in AIdb.getCriteria(files.database.getQueue(),
onlyUsed=False,
strip=False):
# for range values trigger on the MAX criteria (skip the MIN's
# arbitrary as we handle rows in one pass)
if crit.startswith('MIN'):
continue
# get the values from the manifest
values = files.criteria[crit.replace('MAX', '', 1)]
# If the critera manifest didn't specify this criteria, fill in NULLs
if values is None:
# use the criteria name to determine if this is a range
if crit.startswith('MAX'):
query += "NULL,NULL,"
# this is a single value
else:
query += "NULL,"
# Else if this is a value criteria (not a range), insert the value
# as a space-separated list of values which will account for the case
# where a list of values have been given.
elif not crit.startswith('MAX'):
# Join the values of the list with a space separator.
query += "'" + AIdb.sanitizeSQL(" ".join(values)) + "',"
# else values is a range
else:
for value in values:
# translate "unbounded" to a database NULL
if value == "unbounded":
query += "NULL,"
# we need to deal with mac addresses specially being
# hexadecimal
elif crit.endswith("mac"):
# need to insert with hex operand x'<val>'
# use an upper case string for hex values
query += "x'" + AIdb.sanitizeSQL(str(value).upper()) + \
"',"
else:
query += AIdb.sanitizeSQL(str(value).upper()) + ","
# strip trailing comma and close parentheses
query = query[:-1] + ")"
# update the database
query = AIdb.DBrequest(query, commit=True)
files.database.getQueue().put(query)
query.waitAns()
# in case there's an error call the response function (which will print the
# error)
query.getResponse()
def set_criteria(criteria, manifest_name, db, append=False):
"""
Set a manifest's record in the criteria database with the
criteria provided.
If append is True -- append ones that aren't already set for
the manifest, and replace ones that are.
if append is False -- completely remove all criteria already
set for the manifest, and use only the criteria specified.
"""
# Build a list of criteria nvpairs to update
nvpairs = list()
# we need to fill in the criteria or NULLs for each criteria the database
# supports (so iterate over each criteria)
for crit in AIdb.getCriteria(db.getQueue(), onlyUsed=False, strip=True):
# Get the value from the manifest
values = criteria[crit]
# the critera manifest didn't specify this criteria
if values is None:
# If we not appending criteria, then we must write in NULLs
# for this criteria since we're removing all criteria not
# specified.
if not append:
# if the criteria we're processing is a range criteria, fill in
# NULL for two columns, MINcrit and MAXcrit
if AIdb.isRangeCriteria(db.getQueue(), crit):
nvpairs.append("MIN" + crit + "=NULL")
nvpairs.append("MAX" + crit + "=NULL")
# this is a single value
else:
nvpairs.append(crit + "=NULL")
# this is a single criteria (not a range)
elif isinstance(values, basestring):
# translate "unbounded" to a database NULL
if values == "unbounded":
nvstr = crit + "=NULL"
else:
# use lower case for text strings
nvstr = crit + "='" + AIdb.sanitizeSQL(str(values).lower()) \
+ "'"
nvpairs.append(nvstr)
# Else the values are a list this is a range criteria
else:
# Set the MIN column for this range criteria
nvpairs.append("MIN" + crit + "=" + format_value(crit, values[0]))
# Set the MAX column for this range criteria
nvpairs.append("MAX" + crit + "=" + format_value(crit, values[1]))
query = "UPDATE manifests SET " + ",".join(nvpairs) + \
" WHERE name='" + manifest_name + "'"
# update the DB
query = AIdb.DBrequest(query, commit=True)
db.getQueue().put(query)
query.waitAns()
# in case there's an error call the response function (which
# will print the error)
query.getResponse()