fixture.py

"""
DB and filesystem fixtures for credit unions.
"""

import distutils.dir_util
import json
import os.path
import psycopg2
import shellish
import shutil
import tarfile
import tempfile

SCHEMA_VERSION = 1
FIXTURE_PATH = '/fixtures'


class Fixture(shellish.Command):
    """ Load and save database fixtures. """

    name = 'fixture'

    def setup_args(self, parser):
        self.add_subcommand(Load)
        self.add_subcommand(Save)


class Load(shellish.Command):
    """ Load a DB and/or FS fixture.

    Typically fixtures are tar/gz bundles located in your project's
    `/fixtures` directory.  The exact layout of these bundles is documented in
    the README.md of this same directory.  In short, each fixture bundle
    represents data associated with a single customer (credit union).  In the
    Odyssey system credit union data consists of custom DB tables prefixed
    with the credit union code, (cruisecu for example) and of customizable
    filesystem assets which are typically located in /home/<cucode>/.
    Initially the filesystem content is just boilerplate, but can be
    customized for each customer. """

    name = 'load'
    # owner/group id for destination container (php:apache)
    file_owner = 33
    file_group = 33

    def setup_args(self, parser):
        self.add_argument('name', help='Name of fixture file (sans file '
                          'extension)')
        self.add_argument('--dbhost', env='DATABASE_HOST',
                          help="Database server host or IP.")
        self.add_argument('--dbport', type=int, env='DATABASE_PORT',
                          help="Database server port.")
        self.add_argument('--dbuser', env='DATABASE_USER',
                          help="Database username.")
        self.add_argument('--dbpassword', env='DATABASE_PASSWORD',
                          help="Database password.")
        self.add_argument('--dbname', env='DATABASE_NAME',
                          help="Database to load into.")


    def run(self, args):
        path = '%s/%s' % (FIXTURE_PATH, args.name)
        tarpath = '%s.tgz' % path
        if os.path.isfile(tarpath):
            shellish.vtmlprint('<b>Extracting: <blue>%s</blue></b>' % tarpath)
            with tarfile.open(tarpath) as bundle:
                with tempfile.TemporaryDirectory() as tmpdir:
                    bundle.extractall(tmpdir)
                    self.load_from_dir(args, tmpdir)
        elif os.path.isdir(path):
            shellish.vtmlprint('<b>Loading fixture directory: <blue>%s'
                               '</blue></b>' % path)
            self.load_from_dir(args, path)
        else:
            raise SystemExit("Fixture not found: %s" % path)

    def load_from_dir(self, args, path):
        os.chdir(path)
        with open('./manifest.json') as f:
            manifest = json.load(f)
        shellish.vtmlprint("Name: %s" % manifest['name'])
        shellish.vtmlprint("ID: %s" % manifest['id'])
        shellish.vtmlprint("Bundle Version: %s" % manifest['version'])
        shellish.vtmlprint("Schema Version: %s" % manifest['schema'])
        if manifest['schema'] < SCHEMA_VERSION:
            raise ValueError("Fixture schema is incompatible with this stack "
                             "(%s < %s)" % (manifest['schema'],
                             SCHEMA_VERSION))
        try:
            sqlfiles = sorted(x for x in os.listdir('db')
                              if not x.startswith('.'))
        except FileNotFoundError:
            sqlfiles = []
        if not sqlfiles:
            shellish.vtmlprint('<yellow>No database content found')
        else:
            with psycopg2.connect(host=args.dbhost, port=args.dbport,
                                  user=args.dbuser, password=args.dbpassword,
                                  dbname=args.dbname) as db:
                for x in sqlfiles:
                    if x.endswith('.sql'):
                        shellish.vtmlprint("Loading DB file: <cyan>%s" % x)
                        with open('db/%s' % x) as f:
                            with db.cursor() as c:
                                c.execute(f.read())
                    else:
                        shellish.vtmlprint('<yellow>Invalid DB file: %s' % x)
        self.install_files('fs', '/home/%s' % manifest['id'])
        shellish.vtmlprint("\n<b>Fixture README:</b>\n")
        with open('README.md') as f:
            print(f.read())

    def install_files(self, src, dst):
        """ Copy the file tree into the destination location and correct
        ownership as needed. """
        distutils.dir_util.copy_tree(src, dst, preserve_symlinks=1,
                                     verbose=1)
        shutil.chown(dst, self.file_owner, self.file_group)
        for root, dirs, files in os.walk(dst):
            for x in files + dirs:
                shutil.chown(os.path.join(root, x), self.file_owner,
                             self.file_group)


class Save(shellish.Command):
    """ Create a fixture bundle.

    TBD """

    name = 'save'

    def run(self, args):
        raise NotImplementedError('implement me')