path: root/lib/d2/bin/d2_setup.py

import os
import argparse
import stat
from d2.config.locations import Locations
from d2.config.configfile import WriteConfigFile


class Args(object):

    DESCRIPTION = "Build config files for d2"
    WEBSERVER_PORT = 8888
    DATABASE_PROTOCOL = 'sqlite'
    LDAP_CERT = 'ldap.cer'
    LDAP_SERVER = 'ldaps://goliath.agcom.amgreetings.com:636'
    LDAP_VERSION = 3
    LDAP_BASE_DN = 'DC=Floorplan,DC=AGI,DC=com'

    def __init__(self, locations):
        self.locations = locations
        self._parser_ = None

    @classmethod
    def load(cls, locations=None):
        locations = locations or Locations.load()
        return cls(locations)

    @classmethod
    def parse(cls, locations=None):
        locations = locations or Locations.load()
        obj = cls(locations)
        return obj()

    def __call__(self):
        self._config_directory()
        self._data_directory()
        self._index_directory()
        self._log_directory()
        self._log_level()
        self._webserver_port()
        self._webserver_static_directory()
        self._webserver_template_directory()
        self._database_protocol()
        self._ldap_server()
        self._ldap_base_dn()
        self._ldap_version()
        args = self.parser.parse_args()
        args.project = self.locations.project
        return args

    @property
    def parser(self):
        if not self._parser_:
            self._parser_ = argparse.ArgumentParser(
                            description=self.DESCRIPTION)
        return self._parser_

    def _config_directory(self):
        self.parser.add_argument(
                '--config-directory',
                type=str,
                default=self.locations.config_directory,
                help='The directory that will contain the configuration '\
                     'files: (default: %(default)s)'
        )

    def _data_directory(self):
        self.parser.add_argument(
                '--data-directory',
                type=str,
                default=self.locations.data_directory,
                help='The directory that will contain the data '\
                     'files: (default: %(default)s)'
        )

    def _index_directory(self):
        self.parser.add_argument(
                '--index-directory',
                type=str,
                default=self.locations.index_directory,
                help='The directory that will contain the index (search) '\
                     'files: (default: %(default)s)'
        )

    def _log_directory(self):
        self.parser.add_argument(
                '--log-directory',
                type=str,
                default=self.locations.data_directory,
                help='The directory that will contain the log '\
                     'files: (default: %(default)s)'
        )

    def _log_level(self):
        self.parser.add_argument(
                '--log-level',
                type=str,
                default='debug',
                choices=['debug', 'info', 'warning', 'critical'],
                help='The default log level (default: %(default)s)'
        )

    def _webserver_port(self):
        self.parser.add_argument(
                '--webserver-port',
                type=int,
                default=self.WEBSERVER_PORT,
                help='The web server port (default: %(default)s)'
        )

    def _webserver_static_directory(self):
        self.parser.add_argument(
                '--webserver-static-directory',
                type=str,
                default=self.locations.static_directory,
                help='The webserver static files directory '\
                     '(default: %(default)s)'
        )

    def _webserver_template_directory(self):
        self.parser.add_argument(
                '--webserver-template-directory',
                type=str,
                default=self.locations.template_directory,
                help='The webserver template files directory '\
                     '(default: %(default)s)'
        )

    def _database_protocol(self):
        self.parser.add_argument(
                '--database-protocol',
                type=str,
                default=self.DATABASE_PROTOCOL,
                choices=['sqlite', 'postgres', 'mysql', 'oracle'],
                help='The database protocol (default: %(default)s)'
        )

    def _ldap_server(self):
        self.parser.add_argument(
                '--ldap-server',
                type=str,
                default=self.LDAP_SERVER,
                help='The ldap server connection string (default: %(default)s)'
        )
    def _ldap_base_dn(self):
        self.parser.add_argument(
                '--ldap-base-dn',
                type=str,
                default=self.LDAP_BASE_DN,
                help='The ldap base dn (default: %(default)s)'
        )

    def _ldap_version(self):
        self.parser.add_argument(
                '--ldap-version',
                type=int,
                default=self.LDAP_VERSION,
                help='The ldap server version (default: %(default)s)'
        )


class BaseFilesystem(object):
    PERM_DIR = stat.S_IXUSR | stat.S_IRUSR | stat.S_IWUSR
    PERM_FILE = stat.S_IRUSR | stat.S_IWUSR | 0

    def _touch(self, filename):
        open(filename, 'w').close()
        self._set_file_perm(filename)

    def _set_file_perm(self, filename):
        os.chmod(filename, self.PERM_FILE)

    def _directory_created(self, path):
        print "Created Directory: {0}".format(path)

    def _directory_exists(self, path):
        print "Directory already exists: {0}".format(path)

    def _file_created(self, path):
        print "Created File: {0}".format(path)

    def _file_exists(self, path):
        print "File already exists: {0}".format(path)


class ConfigDirectory(BaseFilesystem):

    def __call__(self, args):
        if os.path.exists(args.config_directory):
            self._directory_exists(args.config_directory)
        else:
            os.mkdir(args.config_directory, self.PERM_DIR)
            self._directory_created(args.config_directory)


class DataDirectory(BaseFilesystem):

    def __call__(self, args):
        if os.path.exists(args.data_directory):
            self._directory_exists(args.data_directory)
        else:
            os.mkdir(args.data_directory, self.PERM_DIR)
            self._directory_created(args.data_directory)


class LogFile(BaseFilesystem):

    FILENAME = '{args.project}.log'

    def __call__(self, args):
        filename = self.filename(args)
        if os.path.exists(filename):
            self._file_exists(filename)
        else:
            self._touch(filename)
            self._file_created(filename)

    @classmethod
    def filename(cls, args):
        filename = cls.FILENAME.format(args=args)
        return os.path.join(args.log_directory, filename)


class LdapCert(BaseFilesystem):

    FILENAME = 'ldap.cer'
    FILE_DATA = "789c6d95c9ceb2481486f724dc43efcd1f504464d18b2a6604b49079c758"\
        "8c820a825e7de3d7e94e7a2061c8a9ca7baace799fe2d7aff58292a259bf0992ed68"\
        "b2260047fa067f9184a9696b4c10c07b87c1ac418035946e3717ea98274c6c291749"\
        "2c39ad668f0eb0206eee655329fc4c43805c1988305f156c739650781222adaba2cb"\
        "db501054ec500c77fc68dacf59f9ef9811fadb5bda796da6b41349448cb9c80e7020"\
        "eef5a68af586d29e119022197b65b4b35e892339e6ba01b07525b09827e4666214e8"\
        "340a3c3a16c1ba0679a667eb03b6669d2e6707cd9603e335b698f5df31c672dad894"\
        "f78bf401f6bf33ad0ad8aa931dbd281f10fd771d6399f8d93bf2d77c3e7b4b3f9267"\
        "4253117077d5fbce39564b4312c06e7ce8cbb73ff7fd5313d1434894e601dab4d5a6"\
        "371b6681ddaf15875afdef6a4af2aa00ce024047f09d21e0d3fa2d818f3432ec566b"\
        "83a5352e8bfc56703f51d82d16eec2d47c67951538301f0f158e772489303a736674"\
        "cfe5290abc01047a68f04d61e6b5c64e2c64ce56b34f79b6b662172ecd5d849b4c91"\
        "af2a48c78f7a33d8f64312aeed3ea2500677c617def289955f627fb68b6ba5d997fc"\
        "5ae265e382bb4ce11e377c9689cfb3cba5912dde8658e3f57eae4922f8dc44d93cc9"\
        "666edcc33b67cf1bc63e3ed69e8fc68be5877952e36d2aec3db9028c7168f45ad358"\
        "5e2b783084dc691c5e24f1111e4e6c0f22e73ecea36fd2573a35649f9aee58bcc022"\
        "f6e6b474baa5988406a8d471cf0b2ccbe4f38090ebe12bb04392a875276b2ebc6f74"\
        "808ff1503f8672fbc41f196d7c3ed0fd4ce33937a8e285439a081080fd5edd989aca"\
        "fd74f5fa54d65e2004719dba002345c508a01942133cbf1eccc4796dccca8a5d830b"\
        "c496a7da2604c551820e58d554ca84f457e13b13231f42f452e377e6ecddc61aa5dd"\
        "b553834e7d3e97fde6024501b660f5894d1750534c5353f4f5567a4d1149627d82b2"\
        "def6996acfe7eaf80afd6c307cab34ba3f5db6bec788d1db28b087a4cb3e46b7b272"\
        "e57fd8b07df64d12c96e791ab4aca29df7ce24799b29780a19fd59aed689fda5fdaa"\
        "06f2b252d68ce14e9ad60c5f0aa6bff824892fa12b9fd3375f20fdb8584e6efa2b51"\
        "96f41f1c0a6c9d76f32c81503fcd21844011acc585240181b93a19cc225a47fa482b"\
        "5fa9f5f53b4440c4588240cf93f8b6ab76cffd32dce29adbb54711c2d1327aa9b86c"\
        "cf2441d3f71325881f7ba9a7001f04ff7c8b0af0ca82f71220ff4847efbc671eacfd"\
        "4e0a345ec5ae3a45703f3b77c114cebc947b24e173ba556c8d65933f2a2a5ea86bf4"\
        "f28ac87115452f0e5e53520fcc940a55ab856c666ea7474a544cc76ddf9b97ee5a1f"\
        "179278efb7716fe5ca363ca068615a78b7effb4ba6b3bcd01a280791c4a9ce49b36e"\
        "383c38db7229df074a9592ceec392047de4012ced81e90c876607f488c56f0aeca87"\
        "0a60462313ec106517e9c50b8d6983156bc3a3215745357b7417e631d72a1e75ee41"\
        "121ea25fa7de3cd07964eff787bcdd5d4f4cc952c9899baa71c272221f17da566fda"\
        "793ed05572ac4ebcbcc3bf93c4cf612f59e2fffc00fe0069b0ee62"

    def __call__(self, args):
        filename = self.filename(args)
        if os.path.exists(filename):
            self._file_exists(filename)
        else:
            data = self.FILE_DATA.decode('hex').decode('zip')
            with open(filename, 'wb') as fileobj:
                fileobj.write(data)
            self._set_file_perm(filename)
            self._file_created(filename)

    @classmethod
    def filename(cls, args):
        filename = cls.FILENAME.format(args=args)
        path = os.path.join(args.config_directory, filename)
        return os.path.expanduser(path)

class DatabaseFile(BaseFilesystem):
    pass


class ConfigFile(BaseFilesystem):

    DATABASE_FILENAME = '{args.project}_data.sqlite'
    FILENAME = 'config'

    def __call__(self, args):

        filename = os.path.join(args.config_directory, self.FILENAME)

        if os.path.exists(filename):
            self._file_exists(filename)
        else:
            config = WriteConfigFile()
            self._build_log_section(config, args)
            self._build_directories_section(config, args)
            self._build_web_server_section(config, args)
            self._build_db_section(config, args)
            self._build_ldap_section(config, args)
            with open(filename, 'wb') as configfile:
                config.write(configfile)
            self._set_file_perm(filename)
            self._file_created(filename)

            print
            print "Before continuing you must edit the configuration "\
                  "file: {0}".format(filename)

    def _build_log_section(self, config, args):

        filename = LogFile.filename(args)
        sec = 'log'
        config.add_section(sec)
        config.set(sec, 'level', args.log_level)

    def _build_directories_section(self, config, args):
        sec = 'directories'
        config.add_section(sec)
        config.set(sec, 'data', args.data_directory)
        config.set(sec, 'index', args.index_directory)

    def _build_log_section(self, config, args):
        filename = LogFile.filename(args)
        sec = 'log'
        config.add_section(sec)
        config.set(sec, 'level', args.log_level)
        config.set(sec, 'log_file', filename)

    def _build_web_server_section(self, config, args):
        sec = 'web_server'
        config.add_section(sec)
        config.set(sec, 'port', args.webserver_port)
        config.set(sec, 'static_directory', args.webserver_static_directory)
        config.set(sec, 'template_directory', args.webserver_template_directory)

    def _build_db_section(self, config, args):
        sec = 'db'
        config.add_section(sec)
        config.set(sec, 'protocol', args.database_protocol)

        if args.database_protocol == 'sqlite':
            filename = self.DATABASE_FILENAME.format(args=args)
            filename = os.path.join(args.data_directory, filename)
            config.set(sec, 'filename', filename)
        else:
            config.set(sec, 'hostname', '127.0.0.1')
            config.set(sec, 'username', 'username')
            config.set(sec, 'password', 'password')
            config.set(sec, 'port', '0')
            config.set(sec, 'database', args.project)
            config.set(sec, 'schema', args.project)

    def _build_ldap_section(self, config, args):
        sec = 'ldap'
        config.add_section(sec)
        config.set(sec, 'server', args.ldap_server)
        config.set(sec, 'certfile', LdapCert.filename(args))
        config.set(sec, 'version', args.ldap_version)
        config.set(sec, 'base_dn', args.ldap_base_dn)
        config.set(sec, 'username', 'username')
        config.set(sec, 'password', 'password')


class Process(object):

    def __init__(self):
        self._chain = [
            ConfigDirectory(),
            DataDirectory(),
            LogFile(),
            LdapCert(),
            ConfigFile(),
        ]

    @classmethod
    def run(cls, args):
        obj = cls()
        obj(args)

    def __call__(self, args):
        for obj in self._chain:
            obj(args)

def main():
    Process.run(Args.parse())