def elektraMount(mountpoint, filename, resolver, plugins, recommends):
with kdb.KDB() as db:
ks = kdb.KeySet(0)
mountpoints = "system/elektra/mountpoints"
rc = 0
try:
rc = db.get(ks, mountpoints)
except kdb.KDBException as e:
raise ElektraReadException("KDB.get failed: {}".format(e))
if rc == -1:
raise ElektraMountException(
"Failed to fetch elektra facts: failed to read system/elektra/mountpoints."
)
searchKey = mountpoints + '/' + mountpoint.replace('/', '\/')
try:
key = ks[searchKey]
return (0, True)
except KeyError:
command = []
command.append("kdb")
command.append("mount")
if recommends:
command.append("--with-recommends")
command.append("-R")
command.append(resolver)
command.append(filename)
command.append(mountpoint)
for item in plugins:
for cname, cvalue in item.items():
command.append(str(cname)) # plugin
if isinstance(cvalue, dict): # iterate plugin meta
for scname, scvalue in cvalue.items():
command.append(str(scname) + "=" + str(scvalue))
return execute(command)
def set_key(self, key):
if not key.HasField('name'):
return False
name = str(key.name)
value = None
if key.type == PARAM_STRING:
if not key.HasField('paramstring'):
return False
value = str(key.paramstring)
elif key.type == PARAM_BINARY:
if not key.HasField('parambinary'):
return False
value = str(key.parambinary)
elif key.type == PARAM_INTEGER:
if not key.HasField('paramint'):
return False
value = str(key.paramint)
elif key.type == PARAM_DOUBLE:
if not key.HasField('paramdouble'):
return False
value = str(key.paramdouble)
elif key.type == PARAM_DOUBLE:
if not key.HasField('paramlist'):
return False
return False # TODO: implement
for s in self.subscriptions:
if name.startswith(s):
with kdb.KDB() as db:
ks = kdb.KeySet()
db.get(ks, s)
ks[name].string = value
db.set(ks, s)
return True
return False
def tearDownClass(cls):
# cleanup
with kdb.KDB() as db:
ks = kdb.KeySet(100)
db.get(ks, TEST_NS)
ks.cut(kdb.Key(TEST_NS))
db.set(ks, TEST_NS)
def complete_long_options():
global start_of_current_input, mount_point, last_command
completion_options = []
k = kdb.KDB()
ks = kdb.KeySet()
k.get(ks, mount_point)
word = start_of_current_input.strip()
while word.startswith('-'):
word = word[1:]
for key in ks:
if last_command and last_command != str(key):
continue
long_opt = key.getMeta(name='opt/long')
opt = key.getMeta(name='opt')
if long_opt:
if long_opt.value.startswith(word):
completion_options.append('--' + long_opt.value)
elif opt and opt.value.startswith('#'):
try:
len_opts = int((opt.value)[1:])
except ValueError:
continue
for i in range(len_opts+1):
long_opt = None
long_opt = key.getMeta(name='opt/#{}/long'.format(i))
if long_opt and long_opt.value.startswith(word):
completion_options.append('--' + long_opt.value)
k.close()
return completion_options
def test_get(self):
with kdb.KDB() as db:
ks = kdb.KeySet()
db.get(ks, "system/elektra")
key = ks["system/elektra/version/constants/KDB_VERSION"]
self.assertEqual(key.value, kdb.VERSION)
def full_update(self, basekey):
with kdb.KDB() as db:
ks = kdb.KeySet()
db.get(ks, basekey)
for k in ks:
key = self.tx.key.add()
self.convert_key(key, k)
self.add_pparams()
self.send_param_msg(basekey, MT_PARAM_FULL_UPDATE)
def test_get(self):
with kdb.KDB() as db:
ks = kdb.KeySet()
db.get(ks, "system/elektra")
import os
if os.getenv("CHECK_VERSION") is None:
key = ks["system/elektra/version/constants/KDB_VERSION"]
self.assertEqual(key.value, kdb.VERSION)
def test_set(self):
with kdb.KDB() as db:
ks = kdb.KeySet(100)
db.get(ks, TEST_NS)
try:
key = ks[TEST_NS + "/mykey"]
except KeyError:
key = kdb.Key(TEST_NS + "/mykey")
ks.append(key)
key.value = "new_value"
db.set(ks, TEST_NS)
with kdb.KDB() as db:
ks = kdb.KeySet(100)
db.get(ks, TEST_NS)
self.assertEqual(ks[TEST_NS + "/mykey"].value, "new_value")
def test_ensure(self):
with kdb.KDB() as db:
ks = kdb.KeySet()
k = kdb.Key("system:/elektra/ensure/plugins/global/gopts",
kdb.KEY_VALUE, "mounted")
parent = kdb.Key("system:/elektra")
rc = db.ensure(ks, parent)
self.assertEqual(rc, 0)
db.get(ks, parent)
def setupSpec():
with kdb.KDB() as db:
ks = kdb.KeySet(10)
db.get(ks, spec_base_key)
if len(ks.cut(kdb.Key(spec_base_key))) > 0:
print("ERROR: Couldn't setup spec, keys exist!", file=sys.stderr)
exit(1)
ks.extend(spec)
db.set(ks, spec_base_key)
def incremental_update(self, key, basekey='', delete=False):
if not delete:
with kdb.KDB() as db:
ks = kdb.KeySet()
db.get(ks, basekey)
k = ks[key]
paramKey = self.tx.key.add()
self.convert_key(paramKey, k)
else:
paramKey = self.tx.key.add()
paramKey.name = key
paramKey.deleted = True
self.send_param_msg(basekey, MT_PARAM_INCREMENTAL_UPDATE)
def elektraSet(mountpoint, keyset, keeporder):
with kdb.KDB() as db:
ks = kdb.KeySet(0)
rc = 0
try:
rc = db.get(ks, mountpoint)
except kdb.KDBException as e:
raise ElektraReadException("KDB.get failed: {}".format(e))
if rc == -1:
raise ElektraReadException(
"Failed to read keyset below {}".format(mountpoint))
flattenedKeyset = flatten_json(keyset)
i = 0
for name, value in flattenedKeyset.items():
key = None
kname = None
try:
key = ks[mountpoint + "/" + name]
if keeporder and key.hasMeta("order"):
i = int((key.getMeta("order").value)) + 1
if keeporder:
key.setMeta("order", str(i))
i += 1
except KeyError:
key = kdb.Key(mountpoint + "/" + name)
if keeporder:
key.setMeta("order", str(i))
i += 1
ks.append(key)
if isinstance(value, dict):
for sname, svalue in value.items():
if sname == 'value':
key.value = svalue
elif sname == 'meta':
for mname, mvalue in svalue.items():
key.setMeta(mname, str(mvalue))
else:
key.value = value
try:
rc = db.set(ks, mountpoint)
except kdb.KDBException as e:
raise ElektraWriteException("KDB.set failed: {}".format(e))
if rc == -1:
raise ElektraWriteException(
"Failed to write keyset to {}".format(mountpoint))
return rc
def complete_commands(start_of_input):
global mount_point, root
with kdb.KDB() as k:
ks = kdb.KeySet()
k.get(ks, mount_point)
len_path_mount_point = len(mount_point.split('/'))
completion_commands = []
for key in ks:
path = str(key).split('/')
if len(path) <= len_path_mount_point:
continue
if start_of_input is None:
completion_commands.append(path[-1])
elif path[-1].startswith(start_of_input):
completion_commands.append(path[-1])
k.close()
return completion_commands
def complete_program_args():
# TODO only add as many arguments as needed
global start_of_current_input, mount_point
completion_arguments = []
word = start_of_current_input.strip()
while word.startswith('-'):
word = word[1:]
k = kdb.KDB()
ks = kdb.KeySet()
k.get(ks, mount_point)
for key in ks:
args = key.getMeta(name='args')
if not args:
continue
if args.value == 'remaining':
shell_command = key.getMeta(name='completion/shell')
if shell_command:
completion_arguments.extend(execute_shell_command(shell_command.value))
k.close()
return completion_arguments
def complete_opt_args():
# TODO only add as many arguments as needed
global start_of_current_input, mount_point, last_option, last_option_meta
completion_arguments = []
word = start_of_current_input.strip()
while word.startswith('-'):
word = word[1:]
k = kdb.KDB()
ks = kdb.KeySet()
if last_option is None or last_option_meta is None:
return completion_options
k.get(ks, mount_point)
for key in ks:
if str(key) != last_option:
continue
opt_arg = key.getMeta(name=last_option_meta)
opt_arg_complete = key.getMeta(name=last_option_meta + '/completion/shell')
if opt_arg and opt_arg.value != 'none' and opt_arg_complete:
completion_arguments.extend(execute_shell_command(opt_arg_complete.value))
k.close()
return completion_arguments
def _get_kdb_instance():
config = kdb.KeySet(0)
contract = kdb.KeySet(0)
custom_envp = [ "%s=%s" % (k, v) for (k, v) in os.environ.items() ]
kdb.goptsContract (contract, sys.argv, custom_envp, parent_key, config)
db = kdb.KDB(contract)
#monkey patch db.get as
#- proc:/ keys are only available through a cascading lookup (See manpage elektra-namespaces: "Keys in the namespace proc ... are ignored by kdbGet ... ")
#- we don't want spec: keys to appear in the cascading namespace
orig_get = db.get
def patched_get(ks, orig_root):
justified_root = re.sub("^proc:/", "/", str(orig_root))
status = orig_get(ks, justified_root)
if kdb.Key(orig_root).isCascading():
for key_to_remove in ks.filter(lambda key: key.isSpec()):
ks.remove(key_to_remove)
return status
db.get = patched_get
return db
def elektraUmount(mountpoint):
with kdb.KDB() as db:
ks = kdb.KeySet(0)
mountpoints = "system/elektra/mountpoints"
rc = 0
try:
rc = db.get(ks, mountpoints)
except kdb.KDBException as e:
raise ElektraReadException("KDB.get failed: {}".format(e))
if rc != 1:
raise ElektraUmountException(
"Failed to fetch elektra facts: failed to read system/elektra/mountpoints."
)
key = kdb.Key()
key.name = mountpoints + '/' + mountpoint.replace('/', '\/')
ks.cut(key)
try:
rc = db.set(ks, mountpoints)
except kdb.KDBException as e:
raise ElektraWriteException("KDB.set failed: {}".format(e))
if rc != 1:
raise ElektraUmountException("Failed to umount " + key.name)
def main():
module = AnsibleModule(argument_spec=dict(mountpoint=dict(
default='system'), ))
mountpoint = module.params.get('mountpoint')
json_output = {}
with kdb.KDB() as db:
ks = kdb.KeySet(0)
rc = db.get(ks, mountpoint)
if rc != 1:
module.fail_json(msg="No configuration mounted under %s" %
mountpoint)
for k in ks:
kname = str(k)[len(mountpoint) + 1:]
miter = k.getMeta()
if miter != None:
json_output[kname] = {}
json_output[kname]['value'] = k.value
for m in miter:
json_output[kname][str(m)] = m.value
else:
json_output[kname] = k.value
module.exit_json(**json_output)
def test_gopts(self):
try:
setupSpec()
custom_argv = ["test", "get", "-v", "user:/"]
custom_envp = []
config = kdb.KeySet(0)
contract = kdb.KeySet(0)
kdb.goptsContract(contract, custom_argv, custom_envp,
kdb.Key(base_key), config)
with kdb.KDB(contract) as db:
ks = kdb.KeySet(0)
db.get(ks, base_key)
self.assertTrue((base_key in ks))
self.assertEqual(ks[base_key].value, "getter")
self.assertEqual(ks[base_key + "/getter/keyname"].value,
"user:/")
self.assertTrue((base_key + "/getter/verbose" in ks))
self.assertEqual(ks[base_key + "/getter/verbose"].value, "1")
finally:
removeSpec()
ks.cut(kdb.Key(spec_base_key))
db.set(ks, spec_base_key)
def array_index(index):
return "_" * (len(str(index)) - 1) + str(index)
setupSpec()
contract = kdb.KeySet(0)
config = kdb.KeySet(0)
kdb.goptsContract(contract, sys.argv, os.environ, base_key, config)
with kdb.KDB(contract) as db:
ks = kdb.KeySet(0)
db.get(ks, spec_base_key)
if "proc:/elektra/gopts/help" in ks and ks[
"proc:/elektra/gopts/help"].value == "1":
print(ks["proc:/elektra/gopts/help/message"].value)
removeSpec()
exit(0)
print("A real implementation would now")
if base_key + "/printversion" in ks and ks[base_key +
"/printversion"].value == "1":
print("print version information\n")
removeSpec()
def get_command_line_arguments():
global mount_point, root, typed, start_of_current_input, last_command, last_option, last_option_meta, command_or_option, opt_arg
wipe()
try:
opts, args = getopt.getopt(sys.argv[1:],'s:m:')
except getopt.GetoptError:
print('getting command line options failed')
sys.exit(2)
for opt, arg in opts:
if opt == '-s':
s = arg.strip()
if s:
start_of_current_input = s
if opt == '-m':
m = arg.strip()
if m:
mount_point = m
root = mount_point.split('/')[-1]
if mount_point is None:
print('no mount point, pass mount point with -m')
sys.exit(2)
k = kdb.KDB()
ks = kdb.KeySet()
k.get(ks, mount_point)
for i in ks:
if str(i) == mount_point:
get_complete = i.getMeta(name='complete')
if get_complete and get_complete.value == 'command':
command_or_option = True
if len(args) > 0:
typed = args[0].split()
if command_or_option:
for i in reversed(typed):
for j in ks:
if str(j).split('/')[-1] == i:
last_command = str(j)
break
if last_command is not None:
break
for i in reversed(typed):
if not i.startswith('-'):
continue
word = i.strip()
while word.startswith('-'):
word = word[1:]
for j in ks:
opt = j.getMeta(name='opt')
long_opt = j.getMeta(name='opt/long')
if long_opt and long_opt.value == word:
last_option = str(j)
last_option_meta = 'opt/long'
elif opt and not opt.value.startswith('#'):
if opt and opt.value == word:
last_option = str(j)
last_option_meta = 'opt'
elif opt and opt.value.startswith('#'):
try:
len_opts = int((opt.value)[1:])
except ValueError:
continue
for l in range(len_opts+1):
opt_loop = None
opt_loop = j.getMeta(name='opt/#{}'.format(l))
long_opt_loop = None
long_opt_loop = j.getMeta(name='opt/#{}/long'.format(l))
if opt_loop and opt_loop.value == word:
last_option = str(j)
last_option_meta = 'opt/#{}'.format(l)
if long_opt_loop and long_opt_loop.value == word:
last_option = str(j)
last_option_meta = 'opt/#{}/long'.format(l)
if last_option is not None and last_option_meta is not None:
opt_arg_meta = j.getMeta(name=last_option_meta+'/arg')
if opt_arg_meta:
opt_arg = opt_arg_meta.value
break
k.close()
if root is None:
print('getting root failed')
sys.exit(2)
def test_ctor(self):
self.assertIsInstance(kdb.KDB(), kdb.KDB)
error = kdb.Key()
self.assertIsInstance(kdb.KDB(error), kdb.KDB)
import kdb
# open database
with kdb.KDB() as db:
ks = kdb.KeySet(100)
# get keys
db.get(ks, "user:/MyApp")
# check if key exists
try:
key = ks["user:/MyApp/mykey"]
except KeyError:
# create a new key + append to keyset
key = kdb.Key("user:/MyApp/mykey")
ks.append(key)
# change keys value
key.value = "new_value"
# store new keyset
db.set(ks, "user:/MyApp")
# database close is implicit
def removeSpec():
with kdb.KDB() as db:
ks = kdb.KeySet(10)
db.get(ks, spec_base_key)
ks.cut(kdb.Key(spec_base_key))
db.set(ks, spec_base_key)
def _get_kdb_instance():
config = kdb.KeySet(0)
contract = kdb.KeySet(0)
custom_envp = ["%s=%s" % (k, v) for (k, v) in os.environ.items()]
kdb.goptsContract(contract, sys.argv, custom_envp, kdb.Key(), config)
return kdb.KDB(contract)
