class EggHandler(BaseHandler):

    def _handle_stdout(self, stdout):
        deps = {}
        result = REGEX.findall(stdout)
        client = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
        for dep in result:
            egg_name = dep[0]
            latest_version = client.package_releases(egg_name)[0]
            deps[egg_name] = string_version_compare(dep[1], latest_version)
            deps[egg_name]['current_version'] = dep[1]
            deps[egg_name]['latest_version'] = latest_version

        self.render('result.html', package_name=self.git_url.split('/')[-1], dependencies=deps)

    def _handle_pip_result(self, setup_py):
        self.sbp.stdout.read_until_close(self._handle_stdout)

    @tornado.web.asynchronous
    def post(self):
        self.git_url = self.get_argument('git_url')
        pip = self.find_pip()
        self.sbp = Subprocess([pip, 'install',  'git+%s' % self.git_url, '--no-install'],
                              io_loop=self.application.main_loop,
                              stdout=Subprocess.STREAM,
                              stderr=Subprocess.STREAM)

        self.sbp.set_exit_callback(self._handle_pip_result)

    @tornado.web.asynchronous
    def get(self):
        self.render('index.html')

    def find_pip(self):
        return os.path.sep.join(os.path.split(sys.executable)[:-1] + ('pip',))

 def test_wait_for_exit_raise(self):
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, "-c", "import sys; sys.exit(1)"])
     with self.assertRaises(subprocess.CalledProcessError) as cm:
         yield subproc.wait_for_exit()
     self.assertEqual(cm.exception.returncode, 1)

def load_sync(context, url, callback):
    # Disable storage of original. These lines are useful if
    # you want your Thumbor instance to store all originals persistently
    # except video frames.
    #
    # from thumbor.storages.no_storage import Storage as NoStorage
    # context.modules.storage = NoStorage(context)

    unquoted_url = unquote(url)

    command = BaseWikimediaEngine.wrap_command([
        context.config.FFPROBE_PATH,
        '-v',
        'error',
        '-show_entries',
        'format=duration',
        '-of',
        'default=noprint_wrappers=1:nokey=1',
        '%s%s' % (uri_scheme, unquoted_url)
    ], context)

    logger.debug('Command: %r' % command)

    process = Subprocess(command, stdout=Subprocess.STREAM)
    process.set_exit_callback(
        partial(
            _parse_time_status,
            context,
            unquoted_url,
            callback,
            process
        )
    )

 def test_sigchild_future(self):
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, "-c", "pass"])
     ret = yield subproc.wait_for_exit()
     self.assertEqual(ret, 0)
     self.assertEqual(subproc.returncode, ret)

 def test_sigchild_signal(self):
     skip_if_twisted()
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, '-c',
                           'import time; time.sleep(30)'],
                          stdout=Subprocess.STREAM)
     self.addCleanup(subproc.stdout.close)
     subproc.set_exit_callback(self.stop)
     os.kill(subproc.pid, signal.SIGTERM)
     try:
         ret = self.wait(timeout=1.0)
     except AssertionError:
         # We failed to get the termination signal. This test is
         # occasionally flaky on pypy, so try to get a little more
         # information: did the process close its stdout
         # (indicating that the problem is in the parent process's
         # signal handling) or did the child process somehow fail
         # to terminate?
         subproc.stdout.read_until_close(callback=self.stop)
         try:
             self.wait(timeout=1.0)
         except AssertionError:
             raise AssertionError("subprocess failed to terminate")
         else:
             raise AssertionError("subprocess closed stdout but failed to "
                                  "get termination signal")
     self.assertEqual(subproc.returncode, ret)
     self.assertEqual(ret, -signal.SIGTERM)

    async def send_to_ruby(self, request_json):
        env = {
            "PCSD_DEBUG": "true" if self.__debug else "false"
        }
        if self.__gem_home is not None:
            env["GEM_HOME"] = self.__gem_home

        if self.__no_proxy is not None:
            env["NO_PROXY"] = self.__no_proxy
        if self.__https_proxy is not None:
            env["HTTPS_PROXY"] = self.__https_proxy

        pcsd_ruby = Subprocess(
            [
                self.__ruby_executable, "-I",
                self.__pcsd_dir,
                self.__pcsd_cmdline_entry
            ],
            stdin=Subprocess.STREAM,
            stdout=Subprocess.STREAM,
            stderr=Subprocess.STREAM,
            env=env
        )
        await Task(pcsd_ruby.stdin.write, str.encode(request_json))
        pcsd_ruby.stdin.close()
        return await multi([
            Task(pcsd_ruby.stdout.read_until_close),
            Task(pcsd_ruby.stderr.read_until_close),
            pcsd_ruby.wait_for_exit(raise_error=False),
        ])

 def test_h2spec(self):
     h2spec_cmd = [self.h2spec_path, "-p",
                   str(self.get_http_port())]
     for section in options.h2spec_section:
         h2spec_cmd.extend(["-s", section])
     h2spec_proc = Subprocess(h2spec_cmd)
     yield h2spec_proc.wait_for_exit()

 def test_wait_for_exit_raise_disabled(self):
     skip_if_twisted()
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, '-c', 'import sys; sys.exit(1)'])
     ret = yield subproc.wait_for_exit(raise_error=False)
     self.assertEqual(ret, 1)

def run_proc(port, cmd, stdout_file, stderr_file, directory):
    run_cmd = cmd.format(numproc=port)

    if directory.startswith('.'):
        directory = os.path.realpath(directory)
        print "Directory", directory

    if not os.path.exists(directory):
        raise Exception('working directory doesnt exist')

    proc = Subprocess(
        shlex.split(run_cmd),
        stdout=Subprocess.STREAM,
        stderr=Subprocess.STREAM,
        cwd=directory
    )
    proc.set_exit_callback(exit_callback)

    std_out_log_file_name = get_out_file_name(directory, stdout_file.format(numproc=port))
    std_err_log_file_name = get_out_file_name(directory, stderr_file.format(numproc=port))
    stdout_fhandler = open(std_out_log_file_name, 'a')
    stderr_fhandler = open(std_err_log_file_name, 'a')
    out_fn = partial(_out, filehandler=stdout_fhandler, head="%s: " % port)
    err_fn = partial(_out, filehandler=stderr_fhandler, head="%s: " % port)

    proc.stdout.read_until_close(exit_callback, streaming_callback=out_fn)
    proc.stderr.read_until_close(exit_callback, streaming_callback=err_fn)

    return proc

    def call_process(self, cmd, stream, address, io_loop=None): 
        """ Calls process 

        cmd: command in a list e.g ['ls', '-la']
        stdout_callback: callback to run on stdout


        TODO: add some way of calling proc.kill() if the stream is closed
        """

        stdout_stream = Subprocess.STREAM 
        stderr_stream = Subprocess.STREAM 
        proc = Subprocess(cmd, stdout=stdout_stream, stderr=stderr_stream)
        call_back = partial(self.on_exit, address)
        proc.set_exit_callback(call_back)

        pipe_stream = PipeIOStream(proc.stdout.fileno())

        try:
            while True:
                str_ = yield pipe_stream.read_bytes(102400, partial=True)
                yield stream.write(str_)
        except StreamClosedError:
            pass
        print("end address: {}".format(address))

class GeneralSubprocess:
    def __init__(self, id, cmd):
        self.pipe = None
        self.id = id
        self.cmd = cmd
        self.start = None
        self.end = None

    @coroutine
    def run_process(self):
        self.pipe = Subprocess(shlex.split(self.cmd),
                               stdout=Subprocess.STREAM,
                               stderr=Subprocess.STREAM)
        self.start = time.time()
        (out, err) = (yield [Task(self.pipe.stdout.read_until_close),
                             Task(self.pipe.stderr.read_until_close)])
        return (out, err)

    def stat(self):
        self.pipe.poll()
        if self.pipe.returncode is not None:
            self.end = time.time()
            print('Done time : %f', self.end - self.start)
        else:
            print('Not done yet')

def start(op,*args,**kw):
    if anonymity:
        args = ('--anonymity',str(anonymity))+args
    done = gen.Future()
    note.cyan('gnunet-'+op+' '+' '.join(args))
    action = Subprocess(('gnunet-'+op,)+args,**kw)
    action.set_exit_callback(done.set_result)
    return action, done

 def test_sigchild_future(self):
     skip_if_twisted()
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, '-c', 'pass'])
     ret = yield subproc.wait_for_exit()
     self.assertEqual(ret, 0)
     self.assertEqual(subproc.returncode, ret)

 def test_sigchild(self):
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, "-c", "pass"])
     subproc.set_exit_callback(self.stop)
     ret = self.wait()
     self.assertEqual(ret, 0)
     self.assertEqual(subproc.returncode, ret)

def work1():
    p = Subprocess(['sleep', '5'])
    future = p.wait_for_exit()

    ioloop.IOLoop.instance().add_future(future, finish_callback)
    print('work1: After add_future....')

    ioloop.IOLoop.instance().add_callback(dumy_callback)
    print ('work1: After add_callback...')

 def test_sigchild(self):
     # Twisted's SIGCHLD handler and Subprocess's conflict with each other.
     skip_if_twisted()
     Subprocess.initialize()
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, '-c', 'pass'])
     subproc.set_exit_callback(self.stop)
     ret = self.wait()
     self.assertEqual(ret, 0)
     self.assertEqual(subproc.returncode, ret)

 def test_sigchild_signal(self):
     skip_if_twisted()
     Subprocess.initialize(io_loop=self.io_loop)
     self.addCleanup(Subprocess.uninitialize)
     subproc = Subprocess([sys.executable, "-c", "import time; time.sleep(30)"], io_loop=self.io_loop)
     subproc.set_exit_callback(self.stop)
     os.kill(subproc.pid, signal.SIGTERM)
     ret = self.wait()
     self.assertEqual(subproc.returncode, ret)
     self.assertEqual(ret, -signal.SIGTERM)

def seek_and_screenshot(callback, context, normalized_url, seek):
    output_file = NamedTemporaryFile(delete=False)

    command = [
        context.config.FFMPEG_PATH,
        # Order is important, for fast seeking -ss and -headers have to be before -i
        # As explained on https://trac.ffmpeg.org/wiki/Seeking
        '-ss',
        '%d' % seek
    ]

    if hasattr(context.config, 'SWIFT_HOST'):
        command += [
            '-headers',
            'X-Auth-Token: %s' % get_swift_token(context)
        ]

    command += [
        '-i',
        '%s' % normalized_url,
        '-y',
        '-vframes',
        '1',
        '-an',
        '-f',
        'image2',
        '-vf',
        'scale=iw*sar:ih',  # T198043 apply any codec-specific aspect ratio
        '-nostats',
        '-loglevel',
        'fatal',
        output_file.name
    ]

    command = ShellRunner.wrap_command(command, context)

    logger.debug('[Video] _parse_time: %r' % command)

    process = Subprocess(
        command,
        stdout=Subprocess.STREAM,
        stderr=Subprocess.STREAM
    )

    process.set_exit_callback(
        partial(
            _process_done,
            callback,
            process,
            context,
            normalized_url,
            seek,
            output_file
        )
    )

 def tearDown(self):
     # Clean up Subprocess, so it can be used again with a new ioloop.
     Subprocess.uninitialize()
     self.loop.clear_current()
     if (not IOLoop.initialized() or
             self.loop is not IOLoop.instance()):
         # Try to clean up any file descriptors left open in the ioloop.
         # This avoids leaks, especially when tests are run repeatedly
         # in the same process with autoreload (because curl does not
         # set FD_CLOEXEC on its file descriptors)
         self.loop.close(all_fds=True)
     super(TornadoAPITest, self).tearDown()

    def _recognize_sample_with_gracenote(self, sample_path):
        conf = self.settings['gn_config']
        proc = Subprocess([
            'tools/gracetune_identify.py',
            '--client-id', conf['client_id'],
            '--user-id', conf['user_id'],
            '--license', conf['license'],
            '--filename', sample_path
            ], stdout=Subprocess.STREAM)

        yield proc.wait_for_exit()
        ret = yield proc.stdout.read_until_close()
        raise Return(json.loads(ret))