def run(self, args):
params, args = args
make, = lowered(
self.owner.fillParams(
names=[("make", "")],
params=params,
))
# get rid of any duplicate names
models = tuple(unique_everseen(lowered(args)))
# ensure the make and models exist
self.owner.ensure_models_exist(make=make, models=models)
# remove associated firmware
self.remove_related_firmware(make=make, models=models)
# now delete the models
self.owner.db.execute(
"""
DELETE firmware_model FROM firmware_model
INNER JOIN firmware_make
ON firmware_model.make_id=firmware_make.id
WHERE firmware_model.name IN %s AND firmware_make.name=%s
""",
(models, make),
)
def run(self, args):
params, args = args
# Lowercase and make all args unique.
models = tuple(unique_everseen(lowered(args)))
make, version_regex, = lowered(
self.owner.fillParams(
names=[
("make", ""),
("version_regex", ""),
],
params=params,
), )
self.owner.ensure_models_exist(make=make, models=models)
self.owner.ensure_version_regex_exists(name=version_regex)
# get the version_regex ID
version_regex_id = self.owner.get_version_regex_id(name=version_regex)
# associate the models with the version_regex
self.owner.db.execute(
"""
UPDATE firmware_model
INNER JOIN firmware_make ON firmware_make.id = firmware_model.make_id
SET firmware_model.version_regex_id=%s WHERE firmware_model.name IN %s AND firmware_make.name=%s
""",
(version_regex_id, models, make),
)
def run(self, args):
params, args = args
models = tuple(unique_everseen(lowered(args)))
imp, make, = lowered(
self.owner.fillParams(
names=[
("imp", ""),
("make", ""),
],
params=params,
), )
self.owner.ensure_models_exist(make=make, models=models)
self.owner.ensure_imp_exists(imp=imp)
# get the implementation ID
imp_id = self.owner.get_imp_id(imp=imp)
# associate the models with the imp
self.owner.db.execute(
"""
UPDATE firmware_model
INNER JOIN firmware_make
ON firmware_model.make_id = firmware_make.id
SET firmware_model.imp_id=%s
WHERE firmware_make.name = %s AND firmware_model.name IN %s
""",
(imp_id, make, models),
)
def run(self, args):
params, args = args
make, imp, = lowered(
self.owner.fillParams(
names=[
("make", ""),
("imp", ""),
],
params=params,
), )
# require a make
if not make:
raise ParamRequired(cmd=self.owner, param="make")
# require an implementation
if not imp:
raise ParamRequired(cmd=self.owner, param="imp")
# get rid of any duplicate names
models = tuple(unique_everseen(lowered(args)))
# ensure the model name doesn't already exist for the given make
self.owner.ensure_unique_models(make=make, models=models)
with ExitStack() as cleanup:
# create the make if it doesn't already exist
self.create_missing_make(make=make, cleanup=cleanup)
# create the implementation if it doesn't already exist
self.create_missing_imp(imp=imp, cleanup=cleanup)
# get the ID of the make to associate with
make_id = self.owner.get_make_id(make=make)
# get the ID of the imp to associate with
imp_id = self.owner.get_imp_id(imp=imp)
self.owner.db.execute(
"""
INSERT INTO firmware_model (
name,
make_id,
imp_id
)
VALUES (%s, %s, %s)
""",
[(model, make_id, imp_id) for model in models],
many=True,
)
# everything was successful, dismiss cleanup.
cleanup.pop_all()
def run(self, args):
# lowercase all args and remove any duplicates
names = tuple(unique_everseen(lowered(args)))
# The version_regexes must exist
self.owner.ensure_version_regexes_exist(names = names)
# remove the version_regexes
self.owner.db.execute("DELETE FROM firmware_version_regex WHERE name IN %s", (names,))
def run(self, args):
params, args = args
hosts = tuple(unique_everseen(lowered(args)))
# process hosts if present
if hosts:
# hosts must exist
hosts = self.owner.getHosts(args=hosts)
make, model, versions = lowered(
self.owner.fillParams(
names=[
("make", ""),
("model", ""),
("versions", ""),
],
params=params,
), )
# process make if present
self.validate_make(make=make)
# process model if present
self.validate_model(make=make, model=model)
# Process versions if present
if versions:
# turn a comma separated string into a list of versions and
# get rid of any duplicate names
versions = tuple(
unique_everseen((version.strip()
for version in versions.split(",")
if version.strip())))
# ensure the versions exist
self.owner.ensure_firmwares_exist(make=make,
model=model,
versions=versions)
mappings_to_remove = self.get_firmware_mappings_to_remove(
hosts=hosts,
versions=versions,
make=make,
model=model,
)
# remove the mappings
if mappings_to_remove:
self.owner.db.execute(
"DELETE FROM firmware_mapping WHERE id IN %s",
(mappings_to_remove, ))
def run(self, args):
params, args = args
args = tuple(unique_everseen(lowered(args)))
hosts = self.owner.getHosts(args=args)
version, make, model, = lowered(
self.owner.fillParams(
names=[
("version", ""),
("make", ""),
("model", ""),
],
params=params,
))
# Make, model, and version are required. This checks them all.
self.owner.ensure_firmware_exists(make=make,
model=model,
version=version)
# Make sure the proposed mappings are unique.
self.ensure_unique_mappings(hosts=hosts,
make=make,
model=model,
version=version)
# Get the ID's of all the hosts
node_ids = (row[0] for row in self.owner.db.select(
"ID FROM nodes WHERE Name in %s", (hosts, )))
# Get the firmware version ID
firmware_id = self.owner.get_firmware_id(make=make,
model=model,
version=version)
# Add the mapping entries.
self.owner.db.execute(
"""
INSERT INTO firmware_mapping (
node_id,
firmware_id
)
VALUES (%s, %s)
""",
[(node_id, firmware_id) for node_id in node_ids],
many=True,
)
def run(self, args):
params, args = args
models = tuple(unique_everseen(lowered(args)))
expanded, make = lowered(
self.owner.fillParams(
names=[("expanded", "false"), ("make", "")],
params=params,
))
expanded = self.owner.str2bool(expanded)
self.validate_make(make=make)
self.validate_models(make=make, models=models)
# If expanded is true, also list the implementation and any version regex associated with the model.
if expanded:
return self.get_expanded_results(make=make, models=models)
# Otherwise just return the names of the makes and models.
return self.get_results(make=make, models=models)
def run(self, args):
params, args = args
# Lowercase all args and remove any duplicates.
models = tuple(unique_everseen(lowered(args)))
make, = lowered(
self.owner.fillParams(names=[("make", "")], params=params))
# The make and models must exist.
self.owner.ensure_models_exist(models=models, make=make)
# disassociate the models from version_regexes
self.owner.db.execute(
"""
UPDATE firmware_model
INNER JOIN firmware_make ON firmware_make.id = firmware_model.make_id
SET firmware_model.version_regex_id=NULL WHERE firmware_model.name IN %s AND firmware_make.name=%s
""",
(models, make),
)
def run(self, args):
params, args = args
makes = tuple(unique_everseen(lowered(args)))
version_regex, = lowered(
self.owner.fillParams(names=[("version_regex", "")],
params=params), )
# The makes must exist
self.owner.ensure_makes_exist(makes=makes)
# The version_regex must exist
self.owner.ensure_version_regex_exists(name=version_regex)
# get the version_regex ID
version_regex_id = self.owner.get_version_regex_id(name=version_regex)
# associate the makes with the version_regex
self.owner.db.execute(
"UPDATE firmware_make SET version_regex_id=%s WHERE name in %s",
(version_regex_id, makes),
)
def run(self, args):
# get rid of any duplicate names
makes = tuple(unique_everseen(lowered(args)))
# ensure the make names already exist
self.owner.ensure_makes_exist(makes=makes)
# Remove any related models.
self.remove_related_models(makes=makes)
# now delete the makes
self.owner.db.execute("DELETE FROM firmware_make WHERE name IN %s",
(makes, ))
def run(self, args):
# Require make names
if not args:
raise ArgRequired(cmd=self.owner, arg="makes")
# lowercase all args and remove any duplicates
args = tuple(unique_everseen(lowered(args)))
# The makes must exist
self.owner.ensure_makes_exist(makes=args)
# disassociate the makes from version_regexes
self.owner.db.execute(
"UPDATE firmware_make SET version_regex_id=NULL WHERE name IN %s",
(args, ))
def run(self, args):
# get rid of any duplicate names
makes = tuple(unique_everseen(lowered(args)))
# ensure the make names don't already exist
self.owner.ensure_unique_makes(makes=makes)
self.owner.db.execute(
"""
INSERT INTO firmware_make (
name
)
VALUES (%s)
""",
[(make, ) for make in makes],
many=True,
)
def run(self, args):
# remove any duplicates
args = tuple(unique_everseen(lowered(args)))
# The imps must exist
self.owner.ensure_imps_exist(imps = args)
# remove the implementations
try:
self.owner.db.execute("DELETE FROM firmware_imp WHERE name IN %s", (args,))
except IntegrityError:
raise CommandError(
cmd = self.owner,
msg = (
"Failed to remove all implementations because some are still in use."
" Please run 'stack list firmware model expanded=true' to list the"
" models still using the implementation and 'stack remove firmware model'"
" to remove them."
)
)
def run(self, args):
params, args = args
self.validate_args(args=args)
imp = args[0].lower()
self.validate_imp(imp=imp)
make, models, = lowered(
self.owner.fillParams(
names=[("make", ""), ("models", "")],
params=params,
))
# If either make or model are set, both arguments are required and must be valid.
if make or models:
# process a comma separated list of models
models = [
model.strip() for model in models.split(",") if model.strip()
]
self.owner.ensure_models_exist(make=make, models=models)
with ExitStack() as cleanup:
# Add the implementation
self.owner.db.execute(
"INSERT INTO firmware_imp (name) VALUES (%s)", (imp, ))
cleanup.callback(self.owner.call,
command="remove.firmware.imp",
args=[imp])
# If the make and model are specified associate the imp with the make + model
if make and models:
self.owner.call(
command="set.firmware.model.imp",
args=[*models, f"make={make}", f"imp={imp}"],
)
# else no association, just put it in the database.
# everything worked, dismiss cleanup
cleanup.pop_all()
def run(self, args):
params, args = args
self.validate_args(args=args)
version = args[0].lower()
*params_to_lower, hash_value, source = self.owner.fillParams(
names=[
("make", ""),
("model", ""),
("imp", ""),
("hosts", ""),
("hash_alg", "md5"),
("hash", ""),
("source", ""),
],
params=params,
)
# Lowercase all params that can be.
make, model, imp, hosts, hash_alg = lowered(params_to_lower)
self.validate_inputs(
source=source,
make=make,
model=model,
version=version,
imp=imp,
hash_alg=hash_alg,
)
# Convert hosts to a list if set
if hosts:
# Make sure the host names are unique.
hosts = tuple(
unique_everseen(host.strip() for host in hosts.split(",")
if host.strip()))
# Validate the hosts exist.
hosts = self.owner.getHosts(args=hosts)
# we use ExitStack to hold our cleanup operations and roll back should something fail.
with ExitStack() as cleanup:
# Get the firmware file on disk in the right location and add the metadata to the database.
self.add_firmware(
source=source,
make=make,
model=model,
version=version,
imp=imp,
hash_value=hash_value,
hash_alg=hash_alg,
cleanup=cleanup,
)
# if hosts are provided, set the firmware relation
if hosts:
self.owner.call(command="add.host.firmware.mapping",
args=[
*hosts, f"version={version}",
f"make={make}", f"model={model}"
])
# everything went down without a problem, dismiss the cleanup
cleanup.pop_all()
