def run_hook(component, script, *args):
    """
    Generic script hook executor.
    """
    if script:
        command = [script]
        if args:
            command.extend(args)
        environment = get_clean_env()
        if component.is_repo_link:
            target = component.linked_subproject
        else:
            target = component
        environment['WL_VCS'] = target.vcs
        environment['WL_REPO'] = target.repo
        environment['WL_PATH'] = target.get_path()
        environment['WL_FILEMASK'] = component.filemask
        environment['WL_FILE_FORMAT'] = component.file_format
        try:
            subprocess.check_call(
                command,
                env=environment,
                cwd=component.get_path(),
            )
            return True
        except (OSError, subprocess.CalledProcessError) as err:
            component.log_error(
                'failed to run hook script %s: %s',
                script,
                err
            )
            return False

def generate_ssh_key(request):
    """
    Generates SSH key.
    """
    # Create directory if it does not exist
    key_dir = os.path.dirname(RSA_KEY_FILE)

    # Try generating key
    try:
        if not os.path.exists(key_dir):
            os.makedirs(key_dir)

        subprocess.check_output(
            [
                'ssh-keygen', '-q',
                '-N', '',
                '-C', 'Weblate',
                '-t', 'rsa',
                '-f', RSA_KEY_FILE[:-4]
            ],
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        messages.success(request, _('Created new SSH key.'))
    except (subprocess.CalledProcessError, OSError) as exc:
        messages.error(
            request,
            _('Failed to generate key: %s') %
            getattr(exc, 'output', str(exc))
        )

 def create_new_file(cls, filename, code, base):
     """Handles creation of new translation file."""
     with open(base, 'r') as handle:
         data = handle.read()
     # Assume input is UTF-8 if not specified
     if b'Content-Type: text/plain; charset=CHARSET' in data:
         data = data.replace(
             b'Content-Type: text/plain; charset=CHARSET',
             b'Content-Type: text/plain; charset=UTF-8'
         )
     process = subprocess.Popen(
         [
             'msginit',
             '--input', '-',
             '--output', filename,
             '--no-translator',
             '--locale', code
         ],
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         env=get_clean_env(),
     )
     output, output_err = process.communicate(input=data)
     retcode = process.poll()
     if retcode:
         raise ValueError(output_err if output_err else output)

def generate_ssh_key(request):
    """
    Generates SSH key.
    """
    try:
        # Create directory if it does not exist
        ensure_ssh_dir()

        # Actually generate the key
        subprocess.check_output(
            [
                'ssh-keygen', '-q',
                '-N', '',
                '-C', 'Weblate',
                '-t', 'rsa',
                '-f', ssh_file(RSA_KEY)
            ],
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        messages.success(request, _('Created new SSH key.'))
    except (subprocess.CalledProcessError, OSError) as exc:
        messages.error(
            request,
            _('Failed to generate key: %s') %
            getattr(exc, 'output', str(exc))
        )

def add_host_key(request):
    """
    Adds host key for a host.
    """
    ensure_ssh_dir()
    host = request.POST.get('host', '')
    port = request.POST.get('port', '')
    if len(host) == 0:
        messages.error(request, _('Invalid host name given!'))
    else:
        cmdline = ['ssh-keyscan']
        if port:
            cmdline.extend(['-p', port])
        cmdline.append(host)
        try:
            output = subprocess.check_output(
                cmdline,
                stderr=subprocess.STDOUT,
                env=get_clean_env(),
            )
            keys = []
            for key in output.splitlines():
                key = key.strip()
                if not is_key_line(key):
                    continue
                keys.append(key)
                host, keytype, fingerprint = parse_hosts_line(key)
                messages.warning(
                    request,
                    _(
                        'Added host key for %(host)s with fingerprint '
                        '%(fingerprint)s (%(keytype)s), '
                        'please verify that it is correct.'
                    ) % {
                        'host': host,
                        'fingerprint': fingerprint,
                        'keytype': keytype,
                    }
                )
            if len(keys) == 0:
                messages.error(
                    request,
                    _('Failed to fetch public key for a host!')
                )
            with open(ssh_file(KNOWN_HOSTS), 'a') as handle:
                for key in keys:
                    handle.write('%s\n' % key)
        except subprocess.CalledProcessError as exc:
            messages.error(
                request,
                _('Failed to get host key: %s') % exc.output
            )
        except OSError as exc:
            messages.error(
                request,
                _('Failed to get host key: %s') % str(exc)
            )

    def _getenv():
        """Generate environment for process execution."""
        env = {'GIT_SSH': get_wrapper_filename()}

        # Add path to config if it exists
        userconfig = os.path.expanduser('~/.config/hub')
        if os.path.exists(userconfig):
            env['HUB_CONFIG'] = userconfig

        return get_clean_env(env)

    def _getenv():
        """Generates environment for process execution."""
        env = {"GIT_SSH": ssh_file(SSH_WRAPPER)}

        # Add path to config if it exists
        userconfig = os.path.expanduser("~/.config/hub")
        if os.path.exists(userconfig):
            env["HUB_CONFIG"] = userconfig

        return get_clean_env(env)

 def add_language(filename, code, base):
     """
     Adds new language file.
     """
     subprocess.check_call(
         ["msginit", "-i", base, "-o", filename, "--no-translator", "-l", code],
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         env=get_clean_env(),
     )

 def add_language(filename, code, base):
     '''
     Adds new language file.
     '''
     subprocess.check_call(
         [
             'msginit',
             '-i', base,
             '-o', filename,
             '--no-translator',
             '-l', code
         ],
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         env=get_clean_env(),
     )

 def supports_new_language(cls):
     '''
     Checks whether we can create new language file.
     '''
     if cls.msginit_found is None:
         try:
             ret = subprocess.check_call(
                 ['msginit', '--help'],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
                 env=get_clean_env(),
             )
             cls.msginit_found = (ret == 0)
         except (subprocess.CalledProcessError, OSError):
             cls.msginit_found = False
     return cls.msginit_found

def can_generate_key():
    """
    Checks whether we can generate key.
    """
    try:
        ret = subprocess.check_call(
            ['which', 'ssh-keygen'],
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        if ret == 0 and not os.path.exists(RSA_KEY_FILE):
            return is_home_writable()
        return False
    except subprocess.CalledProcessError:
        return False

def ssh(request):
    """
    Show information and manipulate with SSH key.
    """
    # Check whether we can generate SSH key
    try:
        ret = subprocess.check_call(
            ['which', 'ssh-keygen'],
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        can_generate = (ret == 0 and not os.path.exists(RSA_KEY_FILE))
    except subprocess.CalledProcessError:
        can_generate = False

    if not os.access(os.path.expanduser('~'), os.W_OK):
        can_generate = False
        messages.error(
            request,
            _('Can not write to home directory, please check documentation.')
        )

    # Grab action type
    action = request.POST.get('action', None)

    # Generate key if it does not exist yet
    if can_generate and action == 'generate':
        generate_ssh_key(request)

    # Read key data if it exists
    key = get_key_data()

    # Add host key
    if action == 'add-host':
        add_host_key(request)

    return render(
        request,
        "admin/ssh.html",
        {
            'public_key': key,
            'can_generate': can_generate,
            'host_keys': get_host_keys(),
            'ssh_docs': weblate.get_doc_url('admin/projects', 'private'),
        }
    )

def add_host_key(request):
    """
    Adds host key for a host.
    """
    host = request.POST.get('host', '')
    port = request.POST.get('port', '')
    if len(host) == 0:
        messages.error(request, _('Invalid host name given!'))
    else:
        cmdline = ['ssh-keyscan']
        if port:
            cmdline.extend(['-p', port])
        cmdline.append(host)
        try:
            output = subprocess.check_output(
                cmdline,
                stderr=subprocess.STDOUT,
                env=get_clean_env(),
            )
            keys = [
                line
                for line in output.splitlines()
                if ' ssh-rsa ' in line or ' ecdsa-sha2-nistp256 ' in line
            ]
            for key in keys:
                host, keytype, fingerprint = parse_hosts_line(key)
                messages.warning(
                    request,
                    _(
                        'Added host key for %(host)s with fingerprint '
                        '%(fingerprint)s (%(keytype)s), '
                        'please verify that it is correct.'
                    ) % {
                        'host': host,
                        'fingerprint': fingerprint,
                        'keytype': keytype,
                    }
                )
            with open(KNOWN_HOSTS_FILE, 'a') as handle:
                for key in keys:
                    handle.write('%s\n' % key)
        except (subprocess.CalledProcessError, OSError) as exc:
            messages.error(
                request,
                _('Failed to get host key: %s') % exc.output
            )

    def __git_commit(self, author, timestamp, sync=False):
        '''
        Commits translation to git.
        '''

        # Format commit message
        msg = self.get_commit_message()

        # Pre commit hook
        if self.subproject.pre_commit_script != '':
            try:
                subprocess.check_call(
                    [
                        self.subproject.pre_commit_script,
                        self.get_filename()
                    ],
                    env=get_clean_env(),
                )
            except (OSError, subprocess.CalledProcessError) as err:
                weblate.logger.error(
                    'Failed to run pre commit script %s: %s',
                    self.subproject.pre_commit_script,
                    err
                )

        # Create list of files to commit
        files = [self.filename]
        if self.subproject.extra_commit_file != '':
            extra_file = self.subproject.extra_commit_file % {
                'language': self.language_code,
            }
            full_path_extra = os.path.join(
                self.subproject.get_path(),
                extra_file
            )
            if os.path.exists(full_path_extra):
                files.append(extra_file)

        # Do actual commit
        self.repository.commit(
            msg, author, timestamp, files
        )

        # Optionally store updated hash
        if sync:
            self.store_hash()

 def _popen(cls, args, cwd=None):
     if args is None:
         raise RepositoryException('Not supported functionality')
     args = [cls._cmd] + args
     process = subprocess.Popen(
         args,
         cwd=cwd,
         env=get_clean_env(),
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )
     output, output_err = process.communicate()
     retcode = process.poll()
     if retcode:
         message = output_err.strip()
         if not message:
             message = output.strip()
         raise RepositoryException(message)
     return output

 def _popen(cls, args, cwd=None):
     '''
     Executes the command using popen.
     '''
     if args is None:
         raise RepositoryException(0, 'Not supported functionality', '')
     args = [cls._cmd] + args
     process = subprocess.Popen(
         args,
         cwd=cwd,
         env=get_clean_env(),
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )
     output, output_err = process.communicate()
     retcode = process.poll()
     if retcode:
         raise RepositoryException(retcode, output_err, output)
     return output

 def run_hook(self, script, *args):
     """
     Generic script hook executor.
     """
     if script:
         command = [script]
         if args:
             command.extend(args)
         try:
             subprocess.check_call(
                 command,
                 env=get_clean_env(),
             )
         except (OSError, subprocess.CalledProcessError) as err:
             self.log_error(
                 'failed to run hook script %s: %s',
                 script,
                 err
             )

 def _popen(cls, args, cwd=None):
     """
     Executes the command using popen.
     """
     if args is None:
         raise RepositoryException(0, "Not supported functionality", "")
     args = [cls._cmd] + args
     process = subprocess.Popen(
         args,
         cwd=cwd,
         env=get_clean_env({"GIT_SSH": ssh_file(SSH_WRAPPER)}),
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )
     output, output_err = process.communicate()
     retcode = process.poll()
     if retcode:
         raise RepositoryException(retcode, output_err, output)
     return output

def can_generate_key():
    """
    Checks whether we can generate key.
    """
    try:
        ensure_ssh_dir()
    except OSError:
        return False

    try:
        ret = subprocess.check_call(
            ['which', 'ssh-keygen'],
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        return ret == 0
    except subprocess.CalledProcessError:
        return False

def generate_gpg_key():
    try:
        subprocess.check_output(
            [
                'gpg',
                '--batch',
                '--pinentry-mode', 'loopback',
                '--passphrase', '',
                '--quick-generate-key',
                settings.WEBLATE_GPG_IDENTITY,
                settings.WEBLATE_GPG_ALGO,
                'default', 'never',
            ],
            stderr=subprocess.STDOUT,
            env=get_clean_env(),
        )
        return get_gpg_key()
    except (subprocess.CalledProcessError, OSError) as exc:
        add_configuration_error('GPG key generating', force_text(exc))
        return None