def install_solr():
    with sudo():
        version = blueprint.get('version')
        version_tuple = tuple(map(int, version.split('.')))

        archive = 'solr-{}.tgz'.format(version)
        if version_tuple < (4, 1, 0):
            archive = 'apache-{}'.format(archive)
        url = 'https://archive.apache.org/dist/lucene/solr/{}/{}'.format(version, archive)

        with cd('/tmp'):
            info('Download {} ({})', 'Solr', version)
            run('wget {}'.format(url))

            info('Extracting archive...')
            with silent():
                run('tar xzf {}'.format(archive))
                solr_version_dir = os.path.splitext(archive)[0]
                solr_version_path = os.path.join('/usr', 'share', solr_version_dir)
                debian.chmod(solr_version_dir, 755, 'solr', 'solr', recursive=True)
                if files.exists(solr_version_path):
                    info('Found same existing version, removing it...')
                    debian.rm(solr_version_path, recursive=True)
                debian.mv(solr_version_dir, '/usr/share/')
                debian.ln(solr_version_path, solr_home)
                debian.rm(archive)

def dump(schema=None, ignore_tables=''):
    """
    Dump and download a schema.

    :param schema: Specific shema to dump and download.
    :param ignore_tables: Tables to skip, separated by | (pipe)
    """
    if not schema:
        schemas = blueprint.get('schemas', {}).keys()
        for i, schema in enumerate(schemas, start=1):
            print("{i}. {schema}".format(i=i, schema=schema))
        valid_indices = '[1-{}]+'.format(len(schemas))
        schema_choice = prompt('Select schema to dump:', default='1', validate=valid_indices)
        schema = schemas[int(schema_choice)-1]

    now = datetime.now().strftime('%Y-%m-%d')
    output_file = '/tmp/{}_{}.backup.gz'.format(schema, now)
    filename = os.path.basename(output_file)

    info('Dumping schema {}...', schema)
    extra_args = []
    for table in ignore_tables.split('|'):
        extra_args.append('--ignore-table={}.{}'.format(schema, table))

    dump_cmd = 'mysqldump {} {} | gzip > {}'.format(schema, ' '.join(extra_args), output_file)

    run('sudo su root -c "{}"'.format(dump_cmd))
    info('Downloading dump...')
    local_file = '~/%s' % filename
    fabric.contrib.files.get(output_file, local_file)

    with sudo(), silent():
        debian.rm(output_file)

    info('New smoking hot dump at {}', local_file)

def update_modules(beat):
    changes = []

    # Get desired state
    desired_modules = set(blueprint.get('{}.modules'.format(beat), []))

    # Get current state
    with silent():
        module_files = run('find /etc/{}/modules.d -iname "*.yml"'.format(beat)).split()
        enabled_modules = {os.path.basename(module).split('.')[0] for module in module_files}

    # Disable extra services
    for extra in enabled_modules - desired_modules:
        info('Disabling {} module: {}', beat, extra)
        changes.append(extra)

        with silent(), sudo():
            run('{} modules disable {}'.format(beat, extra))

    # Enable services
    for missing in desired_modules - enabled_modules:
        info('Enabling {} module: {}', beat, missing)
        changes.append(missing)

        with silent(), sudo():
            run('{} modules enable {}'.format(beat, missing))

    return changes

def send_deploy_event():

    newrelic_key = blueprint.get('newrelic_key', None)
    app_name = blueprint.get('app_name', None)

    if newrelic_key and app_name:
        url = 'https://api.newrelic.com/deployments.xml'
        headers = {'x-api-key': newrelic_key}
        with cd(python_path()):
            tag = run('git describe --tags')
            commit_hash = run('git rev-parse HEAD')

        deployer = git.get_local_commiter()

        payload = {
                'deployment[app_name]': app_name,
                # 'application_id': '1234567',
                'deployment[description]': tag,
                'deployment[revision]': commit_hash,
                # 'deployment[changelog]': changes,
                'deployment[user]': deployer,
            }

        response = requests.post(url, data=payload, headers=headers)
        info(response.text)
    else:
        info('No key found')

#http://gc-taylor.com/blog/2013/02/11/fabric-task-for-notifying-new-relic-code-deploy/#sthash.5AnhN3An.sfju

def install():
    with sudo():
        # Generate a root password and save it in root home
        root_conf_path = '/root/.my.cnf'
        if not fabric.contrib.files.exists(root_conf_path):
            root_pw = generate_password()
            blueprint.upload('root_my.cnf', '/root/.my.cnf', {'password': root_pw})
            debian.chmod('/root/.my.cnf', mode=600)
        else:
            # TODO: use fabric.operations.get instead of cat when up to date with upstream
            with silent():
                output = run('cat {}'.format(root_conf_path))
            fd = StringIO(output)
            config_parser = ConfigParser.RawConfigParser()
            config_parser.readfp(fd)
            root_pw = config_parser.get('client', 'password')

        # Install external PPA
        info('Adding apt key for {}', __name__)
        run("apt-key adv --keyserver keys.gnupg.net --recv-keys 1C4CBDCDCD2EFD2A")

        info('Adding apt repository for {}', __name__)
        debian.add_apt_repository('http://repo.percona.com/apt trusty main')
        debian.apt_get('update')

        # Percona/MySQL base dependencies
        dependencies = (
            'percona-server-server',
            'percona-server-client',
            'libmysqlclient-dev',
            'mysqltuner'
        )

        # Configure debconf to autoset root password on installation prompts
        server_package = dependencies[0]
        debian.debconf_communicate('PURGE', server_package)
        with silent():
            debian.debconf_set_selections(
                '{}/root_password password {}'.format(server_package, root_pw),
                '{}/root_password_again password {}'.format(server_package, root_pw)
            )

        # Install package
        info('Installing {}', __name__)
        debian.apt_get('install', *dependencies)
        debian.debconf_communicate('PURGE', server_package)

        # Auto-answer mysql_secure_installation prompts
        prompts = {
            'Enter current password for root (enter for none): ': root_pw,
            'Change the root password? [Y/n] ': 'n',
            'Remove anonymous users? [Y/n] ': 'Y',
            'Disallow root login remotely? [Y/n] ': 'Y',
            'Remove test database and access to it? [Y/n] ': 'Y',
            'Reload privilege tables now? [Y/n] ': 'Y'

        }
        # Run mysql_secure_installation to remove test-db and remote root login
        with settings(prompts=prompts):
            run('mysql_secure_installation')

def install():
    with sudo():
        info('Install python dependencies')
        debian.apt_get('install', 'python-dev', 'python-setuptools')
        run('easy_install pip')
        run('touch {}'.format(pip_log_file))
        debian.chmod(pip_log_file, mode=777)
        pip('install', 'setuptools', '--upgrade')

def flush():
    """
    Delete all cached keys
    """
    info('Flushing Memcached...')
    with sudo(), silent():
        run('echo "flush_all" | /bin/netcat -q 2 127.0.0.1 11211')
    info('Down the drain!')

def pip_sync(manifest, quiet=False):
    pip('install', 'pip-tools', quiet=quiet)

    options = ""
    if quiet:
        options += ' -q'

    run('pip-sync{} {}'.format(options, manifest), pty=False)

def configure():
    """
    Configure newrelic server
    """

    with sudo():
        info('Adding license key to config')
        newrelic_key = blueprint.get('newrelic_key', None)
        run('nrsysmond-config --set license_key={}'.format(newrelic_key))

def create_server_ssl_cert():
    with sudo():
        info('Generating SSL certificate...')
        debian.mkdir('/etc/pki/tls/certs')
        debian.mkdir('/etc/pki/tls/private')
        with cd('/etc/pki/tls'):
            key = 'private/logstash-forwarder.key'
            crt = 'certs/logstash-forwarder.crt'
            run('openssl req -x509 -batch -nodes -days 3650 -newkey rsa:2048 -keyout {} -out {}'.format(key, crt))

def ctl(command=None):
    """
    Run rabbitmqctl with given command
    :param command: Control command to execute
    """
    if not command:
        abort('No command given, $ fab rabbitmq.ctl:stop_app')

    with sudo():
        run('rabbitmqctl {}'.format(command))

    def reload(self, vassals=None):
        """
        Touch reload specified vassals

        :param vassals: Vassals to reload
        """
        for vassal_ini in vassals or self.list_vassals():
            vassal_ini_path = os.path.join(self.get_config_path(), vassal_ini)
            with sudo(), silent():
                run('touch {}'.format(vassal_ini_path))

def create(path):
    options = ''

    if python.requested_version() >= (3,):
        options += ' -p /usr/bin/python3'

    if not files.exists(path):
        info('Creating virtualenv: {}', path)
        run('virtualenv{options} {}'.format(path, options=options))
    else:
        info('Virtualenv already exists: {}', path)

def top(vassal_name=None):
    """
    Launch uwsgitop for vassal stats socket

    :param vassal_name: The vassal to show stats for (Default: project setting)
    """
    # TODO: fix missing output
    with sudo(), hide_prefix():
        vassal = vassal_name or blueprint.get('project')
        stats_path = os.path.join(tmpfs_path, '{}-stats.sock'.format(vassal))
        run('uwsgitop {}'.format(stats_path))

def fifo(vassal_name, command):
    """
    Issue FIFO commands to a vassal.

    :param vassal_name: The vassal to command
    :param command: The FIFO command to issue

    See: http://uwsgi-docs.readthedocs.org/en/latest/MasterFIFO.html
    """
    fifo_file = '/run/uwsgi/fifo-{}'.format(vassal_name)
    with sudo(), silent():
        run('echo {} > {}'.format(command, fifo_file))

def reload(vassal_path=None):
    """
    Reload uwsgi or reload specific vassal @ path, via touch.

    :param vassal_path: The absolute path to vassal ini to reload. If not given, the uwsgi service will reload
    """
    if not vassal_path:
        debian.service('uwsgi', 'reload', check_status=False)
    else:
        vassal_name = os.path.splitext(os.path.basename(vassal_path))[0]
        with sudo():
            info('Reloading {} uWSGI vassal', vassal_name)
            run('touch {}'.format(vassal_path))

def install():
    with sudo():
        info('Downloading kibana')
        version = blueprint.get('version', '3.1.2')
        tar_file = 'kibana-{}.tar.gz'.format(version)
        run('wget -P /tmp/ https://download.elasticsearch.org/kibana/kibana/{f}'.format(f=tar_file))

        # Extract and soft link kibana in web root
        web_root = '/srv/www/'
        debian.mkdir(web_root, mode=1775, owner='www-data', group='www-data')
        run('tar xzf /tmp/{f} -C {web_root}'.format(f=tar_file, web_root=web_root))
        src_root = os.path.join(web_root, 'kibana-{version}'.format(version=version))
        debian.chown(src_root, owner='www-data', group='www-data', recursive=True)
        debian.ln(src_root, '/srv/www/kibana')

def install_testing():
    package_name = 'rabbitmq-server'
    debian.debconf_set_selections('%s rabbitmq-server/upgrade_previous note' % package_name)

    with sudo():
        info('Adding apt key for {}', package_name)
        run("apt-key adv --keyserver pgp.mit.edu --recv-keys 0x056E8E56")

        info('Adding apt repository for {}', package_name)
        debian.add_apt_repository('http://www.rabbitmq.com/debian/ testing main')
        debian.apt_get_update()

        info('Installing {}', package_name)
        debian.apt_get('install', package_name)

def install():
    with sudo():

        info('Downloading wowza')
        version = blueprint.get('wowza_version', '4.1.2')
        binary = 'WowzaStreamingEngine-{}.deb.bin'.format(version)
        version_path = version.replace('.', '-')
        url = 'http://www.wowza.com/downloads/WowzaStreamingEngine-{}/{}'.format(version_path,
                                                                                 binary)
        run('wget -P /tmp/ {url}'.format(url=url))

        debian.chmod('/tmp/{}'.format(binary), '+x')
        info('Installing wowza')
        run('/tmp/{}'.format(binary))

def create_server_ssl_cert():
    with sudo():
        info("Generating SSL certificate...")
        debian.mkdir("/etc/pki/tls/certs")
        debian.mkdir("/etc/pki/tls/private")
        with cd("/etc/pki/tls"):
            hostname = debian.hostname()
            key = "private/logstash-forwarder.key"
            crt = "certs/logstash-forwarder.crt"
            run(
                "openssl req -x509 -batch -nodes -days 3650 -newkey rsa:2048 "
                "-keyout {} "
                "-out {} "
                '-subj "/CN={}"'.format(key, crt, hostname)
            )