def test_update_parameters(connect):
with Inventory('test_database') as inv:
inv.update_parameters('key_1', 'value_1')
eq_(inv.cursor.execute.call_count, 1)
eq_(inv.cursor.execute.call_args[0][1], ('value_1', 'key_1'))
def decrypt_all(self, passphrase):
"""Decrypt all files from encrypted source.
Files that are being decrypted must be registered under the same
public id in the database, so the passed passphrase would work
for decryption process.
"""
register = {}
with Inventory(self.database) as i:
register = i.read_register("all")
for filename, record in register.items():
# first decrypt regular files
if record['is_link'] == 0 and record[
'encrypted_file'] and record['public_id']:
if record['public_id'] != self.public_id:
continue
try:
self.decrypt(record['encrypted_file'],
record['unencrypted_file'], passphrase)
except IOError as e:
logging.warning('decrypt_all: {}'.format(e))
print('Failed to create file {} : {}'.format(
record['unencrypted_file'], str(e)))
# then restore empty directories
elif record['is_link'] == 0 and not record[
'encrypted_file'] and not record['public_id']:
FileOps.create_directory(self.restoredir,
record['unencrypted_file'])
# finally restore symlinks
elif record['is_link'] == 1:
FileOps.create_symlink(self.restoredir,
record['unencrypted_file'],
record['target'])
def test_exists_encrypted_file(connect):
with Inventory('test_database') as inv:
r = inv.exists_encrypted_file('filename')
assert inv.cursor.execute.call_count == 1
assert inv.cursor.execute.call_args[0][1] == ('filename', )
def check(self):
"""Check file existence based on the register file set.
Both unencrypted and encrypted files are checked in their
respective plain and encrypted directories. A flag is set
based on the check and fileset dict is updated.
This method does not report or do anything else, so another
method may be required to show the result of the check.
"""
# Load registered file list.
with Inventory(self.database) as inventory:
self.registered_files = inventory.read_register("files")
for filename in self.registered_files:
unenc_full_path = os.path.expanduser(os.path.join(
self.parameters['plaindir'],
self.registered_files[filename]['unencrypted_file']))
self.registered_files[filename]['unencrypted_file_check'] = \
os.path.exists(unenc_full_path)
enc_full_path = os.path.expanduser(os.path.join(
self.parameters['securedir'],
self.registered_files[filename]['encrypted_file']))
self.registered_files[filename]['encrypted_file_check'] = \
os.path.exists(enc_full_path)
def __init__(self, database):
"""Load program parameters.
Program parameters are needed for file locations.
"""
self.database = database
with Inventory(self.database) as inventory:
self.parameters = inventory.read_parameters()
def test_register(connect):
with Inventory('test_database') as inv:
inv.register('plain', 'encrypted', 'public_id')
eq_(inv.cursor.execute.call_count, 1)
eq_(inv.cursor.execute.call_args[0][1],
('plain', 'encrypted', 'public_id'))
def do_list(self, arg):
"""list
Prints all stored settings."""
print('%-15s %s' % ('PARAMETER', 'VALUE'))
print('-' * 40)
with Inventory(self.database) as i:
params = i.read_parameters(params_only=True)
for key, value in i.read_parameters(params_only=True).items():
print('%-15s %s' % (key, value))
print()
def test_read_parameters(connect):
connect().cursor().execute.side_effect = [[
('param-key-1', 'param-value-1'), ('param-key-2', 'param-value-2')
], [('state-key-1', 'state-value-1')]]
with Inventory('test_database') as inv:
params = inv.read_parameters()
eq_(len(params), 3)
for k in ['param-key-1', 'param-key-2', 'state-key-1']:
ok_(k in params.keys())
eq_(params['state-key-1'], 'state-value-1')
def list_records(self):
"Display number of records."
with Inventory(self.database) as inv:
total_records = len(inv.read_register("all"))
reg_files = len(inv.read_register("files"))
reg_links = len(inv.read_register("links"))
reg_dirs = len(inv.read_register("dirs"))
print("- Registered regular files : {}".format(reg_files))
print("- Registered symlinks : {}".format(reg_links))
print("- Registered empty directories : {}".format(reg_dirs))
print()
print("Total number of records : {}".format(total_records))
def delete_orphans_encrypted_files(self):
"""Delete orphans encoded files (which are not in register).
Normally this should not happen, but it can happen anyway
after a crash during encryption or by modifying register
manually.
"""
with Inventory(self.database) as inv:
enc_files = list()
for (dirpath, dirnames, filenames) in os.walk(self.parameters['securedir']):
for name in filenames:
enc_files.append(name)
for enc_file in enc_files:
if not inv.exists_encrypted_file(enc_file):
FileOps.delete_file(self.parameters['securedir'], enc_file)
def test_read_registered_dirs(connect):
connect().cursor().execute.return_value = [('unenc_1', '', '', 0, ''),
('unenc_2', '', '', 0, '')]
with Inventory('test_database') as inv:
rows = inv.read_register("dirs")
eq_(len(rows), 2)
for f in ['unenc_1', 'unenc_2']:
ok_(f in rows.keys())
eq_(rows['unenc_2']['unencrypted_file'], 'unenc_2')
eq_(rows['unenc_2']['encrypted_file'], '')
eq_(rows['unenc_2']['public_id'], '')
eq_(rows['unenc_2']['is_link'], 0)
eq_(rows['unenc_2']['target'], '')
def test_read_register(connect):
connect().cursor().execute.return_value = [
('unenc_1', 'uuid-1', 'public_id_1'),
('unenc_2', 'uuid-2', 'public_id_2'),
('unenc_3', 'uuid-3', 'public_id_3')
]
with Inventory('test_database') as inv:
rows = inv.read_register()
eq_(len(rows), 3)
for f in ['unenc_1', 'unenc_2', 'unenc_3']:
ok_(f in rows.keys())
eq_(rows['unenc_2']['unencrypted_file'], 'unenc_2')
eq_(rows['unenc_2']['encrypted_file'], 'uuid-2')
eq_(rows['unenc_2']['public_id'], 'public_id_2')
def decrypt_all(self, passphrase):
"""Decrypt all files from encrypted source.
Files that are being decrypted must be registered under the same
public id in the database, so the passed passphrase would work
for dectyption process.
"""
register = {}
with Inventory(self.database) as i:
register = i.read_register()
for filename, record in register.items():
if record['public_id'] != self.public_id:
continue
try:
self.decrypt(record['encrypted_file'],
record['unencrypted_file'], passphrase)
except IOError as e:
logging.warning('decrypt_all: {}'.format(e))
def test_read_all_register(connect):
connect().cursor().execute.return_value = [
('unenc_1', 'uuid-1', 'public_id_1', 0, ''),
('unenc_2', '', '', 1, 'target_2'), ('unenc_3', '', '', 1, 'target_3'),
('unenc_4', '', '', 0, '')
]
with Inventory('test_database') as inv:
rows = inv.read_register("all")
eq_(len(rows), 4)
for f in ['unenc_1', 'unenc_2', 'unenc_3', 'unenc_4']:
ok_(f in rows.keys())
eq_(rows['unenc_2']['unencrypted_file'], 'unenc_2')
eq_(rows['unenc_2']['encrypted_file'], '')
eq_(rows['unenc_2']['public_id'], '')
eq_(rows['unenc_2']['is_link'], 1)
eq_(rows['unenc_2']['target'], 'target_2')
def set_parameters(self, args):
"""Set parameters based on database config and passed args."""
self.verbose = False
if args and args.verbose:
self.verbose = True
with Inventory(self.database) as i:
parameters = i.read_parameters()
for parameter, value in parameters.items():
if self.verbose:
print('Parameters: {:<15} : {}'.format(parameter, value))
self.last_timestamp = parameters['last_timestamp']
self.plaindir = os.path.expanduser(parameters['plaindir'])
self.securedir = os.path.expanduser(parameters['securedir'])
self.restoredir = os.path.expanduser(parameters['restoredir'])
self.public_id = parameters['public_id']
self.gpg_keyring = parameters['gpg_keyring']
self.gpg_homedir = os.path.expanduser(parameters['gpg_homedir'])
self.gpg_binary = os.path.expanduser(parameters['gpg_binary'])
if args is None:
return
if args.plaindir:
self.plaindir = os.path.expanduser(args.plaindir)
if args.securedir:
self.securedir = os.path.expanduser(args.securedir)
if args.restoredir:
self.restoredir = os.path.expanduser(args.restoredir)
if args.public_id:
self.public_id = args.public_id
if args.gpg_keyring:
self.gpg_keyring = args.gpg_keyring
if args.gpg_homedir:
self.gpg_homedir = os.path.expanduser(args.gpg_homedir)
if args.gpg_binary:
self.gpg_binary = os.path.expanduser(args.gpg_binary)
def encrypt_all(self):
"""Encrypt all new files from unencrypted directory.
New files are those that have modified timestamp newer than
the timestamp of the last run. At the start of run, the timestamp
is updated.
The files are recursively searched for in the source directory.
"""
register = {}
with Inventory(self.database) as inv:
register = inv.read_register()
inv.update_last_timestamp()
files = self.find_unencrypted_files(register)
for plainfile, val in files.items():
if not val['is_new']:
# remove old file in secure directory
encfile = inv.read_line_from_register(plainfile)
FileOps.delete_file(self.securedir, encfile)
encryptedfile = self.generate_name()
self.encrypt(plainfile, encryptedfile, inv)
if self.verbose:
printit('Encrypted: {} ---> {}', plainfile, encryptedfile)
def encrypt_all(self):
"""Encrypt all new files from unencrypted directory.
New files are those that have modified timestamp newer than
the timestamp of the last run. At the start of run, the timestamp
is updated.
The files are recursively searched for in the source directory.
"""
register = {}
print("Encrypting all directory '{}', please wait...".format(
self.plaindir))
with Inventory(self.database) as inv:
register = inv.read_register("all")
# treat regular files first
self.encrypt_regular_files(register, inv)
# then treat empty directories
self.register_empty_dirs(register, inv)
# finally treat symlinks
self.register_symlinks(register, inv)
self.do_inv_maintenance(inv)
print("Done !")
def clean_registry(self, filename):
"""Clean entry from registry."""
print("Cleaning from registry: {}".format(filename))
with Inventory(self.database) as inventory:
inventory.clean_record(filename)
return True
def update(self, key, value):
"""Generic function to update a single parameter."""
print('Setting %s to: %s' % (key, value))
with Inventory(self.database) as i:
i.update_parameters(key, value)
def test_inventory_enter(sqlite3):
with Inventory('test_database') as i:
ok_(i.cursor)
