Python subprocess.TimeoutExpired() Examples

The following are code examples for showing how to use subprocess.TimeoutExpired(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: code   Author: ActiveState   File: recipe-579056.py    (MIT License) View Source Project 8 votes vote down vote up
def my_thread():
  global files,path,timeout,options
  myname= threading.currentThread().getName()
  while files:
     #create command to run
     nextfile=files.pop() 
     #print name of thread and command being run
     print('Thread {0} starts processing {1}'.format(myname,nextfile))
     f=path + nextfile + options
     try:
        #timeout interrupts frozen command, shell=True does'nt open a console
        subprocess.check_call(args= f , shell=True, timeout=timeout)
     except subprocess.TimeoutExpired:
        print('Thread {0} Processing {0} took too long' .format(myname,nextfile))
     except subprocess.CalledProcessError as e: 
        print ('Thread {0} Processing {1} returned error {2}:{3}'.format(myname,nextfile,e.returncode,e.output))
     except Exception as e:
        print ('Thread {0} Processing {1} returned error {2}'.format(myname,nextfile,type(e).__name__))
  print ('thread {0} stopped'.format(myname)) 
Example 2
Project: cs-autotests   Author: galaharon   File: autotest.py    (license) View Source Project 8 votes vote down vote up
def run(self):
        """Runs the autotest. Diff will be stored in self.diff"""
        process = subprocess.Popen([self.binary] + self.args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
        
        for line in self.input:
            process.stdin.write(line.encode())
        try:
            out, err = process.communicate(timeout=self.time_limit)  # TODO test timeout
            if err:
                self.diff = """Encountered error running test:
                Output: {}
                Error output: {}
                """.format(out.decode(), err.decode())
            else:
                self.diff = diff(out.decode(), self.expected)  # TODO make sure I didn't break diff
        except subprocess.TimeoutExpired:
            self.diff = colours['red']('Time limit exceeded.') 
Example 3
Project: protofuzz   Author: trailofbits   File: pbimport.py    (MIT License) View Source Project 6 votes vote down vote up
def _compile_proto(full_path, dest):
    'Helper to compile protobuf files'
    proto_path = os.path.dirname(full_path)
    protoc_args = [find_protoc(),
                   '--python_out={}'.format(dest),
                   '--proto_path={}'.format(proto_path),
                   full_path]
    proc = subprocess.Popen(protoc_args, stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE)
    try:
        outs, errs = proc.communicate(timeout=5)
    except subprocess.TimeoutExpired:
        proc.kill()
        outs, errs = proc.communicate()
        return False

    if proc.returncode != 0:
        msg = 'Failed compiling "{}": \n\nstderr: {}\nstdout: {}'.format(
            full_path, errs.decode('utf-8'), outs.decode('utf-8'))
        raise BadProtobuf(msg)

    return True 
Example 4
Project: specton   Author: somesortoferror   File: spct_utils.py    (license) View Source Project 6 votes vote down vote up
def runCmd(cmd,cmd_timeout=300):
    ''' run command without showing console window on windows - return stdout and stderr as strings '''
    startupinfo = None
    output = ""
    output_err = ""
    debug_log("runCmd: {}".format(cmd))
    if os.name == 'nt':
        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    try:
        proc = subprocess.Popen(cmd,bufsize=-1,startupinfo=startupinfo,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=None,shell=False,universal_newlines=False)
    except SubprocessError as e:
        proc = None
        debug_log("exception in runCmd: {}".format(e),logging.ERROR)
    if proc is not None:
        try:
            outputb, output_errb = proc.communicate()
            output = outputb.decode('utf-8','replace')
            output_err = output_errb.decode('utf-8','replace')
        except subprocess.TimeoutExpired(timeout=cmd_timeout):
            proc.kill()
            debug_log("runCmd: Process killed due to timeout",logging.WARNING)
    else:
        debug_log("runCmd: Proc was none",logging.WARNING)
    return output,output_err 
Example 5
Project: ParlAI   Author: facebookresearch   File: remote_agent.py    (license) View Source Project 6 votes vote down vote up
def shutdown(self):
        """Shut down paired listener with <END> signal."""
        if hasattr(self, 'socket'):
            try:
                self.socket.send_unicode('<END>', zmq.NOBLOCK)
            except zmq.error.ZMQError:
                # may need to listen first
                try:
                    self.socket.recv_unicode(zmq.NOBLOCK)
                    self.socket.send_unicode('<END>', zmq.NOBLOCK)
                except zmq.error.ZMQError:
                    # paired process is probably dead already
                    pass
        if hasattr(self, 'process'):
            # try to let the subprocess clean up, but don't wait too long
            try:
                self.process.communicate(timeout=1)
            except subprocess.TimeoutExpired:
                self.process.kill() 
Example 6
Project: ATX   Author: NetEaseGame   File: install.py    (license) View Source Project 6 votes vote down vote up
def adb_pushfile(adb, filepath, remote_path):
    filesize = os.path.getsize(filepath)
    pb = tqdm.tqdm(unit='B', unit_scale=True, total=filesize)
    p = adb.raw_cmd('push', filepath, remote_path)

    while True:
        try:
            p.wait(0.5)
        except subprocess.TimeoutExpired:
            pb.n = get_file_size(adb, remote_path)
            pb.refresh()
            # log.info("Progress %dM/%dM", get_file_size(remote_path) >>20, filesize >>20)
            pass
        except (KeyboardInterrupt, SystemExit):
            p.kill()
            raise
        except:
            raise
        else:
            # log.info("Success pushed into device")
            break
    pb.close() 
Example 7
Project: smarthome   Author: skalavala   File: life360.py    (license) View Source Project 6 votes vote down vote up
def exec_shell_command( self, command ):

        output = None
        try:
            output = subprocess.check_output( command, shell=True, timeout=50 )
            output = output.strip().decode('utf-8')

        except subprocess.CalledProcessError:
            """ _LOGGER.error("Command failed: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None
        except subprocess.TimeoutExpired:
            """ _LOGGER.error("Timeout for command: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None

        if output == None:
            _LOGGER.error( "Life360 has not responsed well. Nothing to worry, will try again!" )
            self.value = CONST_STATE_ERROR
            return None
        else:
            return output 
Example 8
Project: snappy   Author: ricci   File: tarsnap.py    (license) View Source Project 6 votes vote down vote up
def runTarsnap(args, timeout = None):
    command = [config.tarsnap_bin] + config.tarsnap_extra_args + args
    proc = subprocess.Popen(command,
                stdout = subprocess.PIPE, stderr = subprocess.PIPE,
                stdin = subprocess.DEVNULL, universal_newlines = True)
    result = CheapoCompletedProcess()
    try:
        result.stdout, result.stderr = proc.communicate(timeout = timeout)
        result.returncode = proc.wait()
        if result.returncode:
            sys.exit("Error running tarsnap:\nCommand: {}\nSTDOUT:\n{}\nSTDERR:\n{}\n".format(" ".join(command),result.stdout,result.stderr))
        return result
    except subprocess.TimeoutExpired:
        print("Tarsnap timed out, sending SIGQUIT...")
        proc.send_signal(signal.SIGQUIT)
        result.stdout, result.stderr = proc.communicate()
        result.returncode = proc.wait()
        print("Tarsnap finished")
        if result.returncode:
            sys.exit("Error running tarsnap:\nCommand: {}\nSTDOUT:\n{}\nSTDERR:\n{}\n".format(" ".join(command),result.stdout,result.stderr))
        return result 
Example 9
Project: bridge-test   Author: Half-Shot   File: npm.py    (license) View Source Project 6 votes vote down vote up
def install(self, path):
        logger.info("Installing npm packages...")
        process = subprocess.Popen(
            ["npm", "install"],
            cwd=path,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
        )
        try:
            return_code = process.wait()
        except subprocess.TimeoutExpired:
            return True
        if return_code is not 0:
            raise Exception("Return code was non-zero")
        logger.info("Done.")
        return True 
Example 10
Project: bridge-test   Author: Half-Shot   File: npm.py    (license) View Source Project 6 votes vote down vote up
def __read_process_stream(self, proc, kill_after=None):
        timedOut = False
        outS = ""
        errS = ""
        try:
            outs, errs = proc.communicate(timeout=kill_after)
            outS = outs.decode()
            errS = errs.decode()
        except subprocess.TimeoutExpired as e:
            proc.terminate()
            proc.wait()
            if e.stdout is not None:
                outS = e.stdout.decode()
            if e.stderr is not None:
                errS = e.stderr.decode()
            timedOut = True
        logger.debug("%s was terminated", str(" ".join(proc.args)))
        return (outS, errS, timedOut) 
Example 11
Project: rofi-skyss   Author: torrottum   File: rofi.py    (license) View Source Project 6 votes vote down vote up
def close(self):
        """Close any open window.

        Note that this only works with non-blocking methods.

        """
        if self._process:
            # Be nice first.
            self._process.send_signal(signal.SIGINT)

            # If it doesn't close itself promptly, be brutal.
            try:
                self._process.wait(timeout=1)
            except subprocess.TimeoutExpired:
                self._process.send_signal(signal.SIGKILL)

            # Clean up.
            self._process = None 
Example 12
Project: probe-website   Author: UNINETT   File: util.py    (license) View Source Project 6 votes vote down vote up
def get_interface_connection_status(port):
    """Return a json string specifying whether the probe is connected
    to the interntet via eth0 or wlan0 (or both).

    Format of returned string: {"eth0": 0 or 1, "wlan0": 1 or 0}
    """
    command = ['ssh',
               '-p', str(port),
               '-o', 'UserKnownHostsFile={}/known_hosts'.format(settings.ANSIBLE_PATH),
               '[email protected]',
               '[ -e /root/connection_status.sh ] && /root/connection_status.sh']
    try:
        data = subprocess.check_output(command, timeout=20).decode('utf-8')
    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
        return None

    # Make sure the returned status is correct
    status = json.loads(data)
    if 'wlan0' in status and 'eth0' in status:
        return data

    return None 
Example 13
Project: marge-bot   Author: smarkets   File: git.py    (license) View Source Project 6 votes vote down vote up
def _run(*args, env=None, check=False, timeout=None):
    with subprocess.Popen([a.encode('utf-8') for a in args], env=env, stdout=PIPE, stderr=PIPE) as process:
        try:
            stdout, stderr = process.communicate(input, timeout=timeout)
        except TimeoutExpired:
            process.kill()
            stdout, stderr = process.communicate()
            raise TimeoutExpired(
                process.args, timeout, output=stdout, stderr=stderr,
            )
        except:
            process.kill()
            process.wait()
            raise
        retcode = process.poll()
        if check and retcode:
            raise subprocess.CalledProcessError(
                retcode, process.args, output=stdout, stderr=stderr,
            )
        return subprocess.CompletedProcess(process.args, retcode, stdout, stderr) 
Example 14
Project: tensorflow-layer-library   Author: bioinf-jku   File: resume.py    (license) View Source Project 6 votes vote down vote up
def sigint_handler(sig, frame):
    print("Killing sub-process...")
    if process_handle is not None:
        global kill_retry_count
        while process_handle.returncode is None and kill_retry_count < kill_retry_max:
            kill_retry_count += 1
            print("Killing sub-process ({})...".format(kill_retry_count))
            try:
                os.killpg(os.getpgid(process_handle.pid), signal.SIGTERM)
                os.waitpid(process_handle.pid, os.WNOHANG)
            except ProcessLookupError:
                break
            
            try:
                process_handle.wait(1)
            except subprocess.TimeoutExpired:
                pass
    
    if working_dir is not None:
        rmdir(working_dir)
    
    sys.exit(0) 
Example 15
Project: donkey   Author: wroscoe   File: utils.py    (license) View Source Project 6 votes vote down vote up
def run_shell_command(cmd, cwd=None, timeout=15):
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
    out = []
    err = []

    try:
        proc.wait(timeout=timeout)
    except subprocess.TimeoutExpired:
        kill(proc.pid)

    for line in proc.stdout.readlines():
        out.append(line.decode())

    for line in proc.stderr.readlines():
        err.append(line)
    return out, err, proc.pid 
Example 16
Project: parsl   Author: Parsl   File: start_controller.py    (license) View Source Project 6 votes vote down vote up
def close(self):
        ''' Terminate the controller process and it's child processes.

        Args:
              - None
        '''
        if self.reuse :
            logger.debug("Ipcontroller not shutting down: reuse enabled")
            return

        try:
            pgid = os.getpgid(self.proc.pid)
            status = os.killpg(pgid, signal.SIGTERM)
            time.sleep(0.2)
            os.killpg(pgid, signal.SIGKILL)
            try:
                self.proc.wait(timeout=1)
                x = self.proc.returncode
                logger.debug("Controller exited with {0}".format(x))
            except subprocess.TimeoutExpired :
                logger.warn("Ipcontroller process:{0} cleanup failed. May require manual cleanup".format(self.proc.pid))

        except Exception as e:
            logger.warn("Failed to kill the ipcontroller process[{0}]: {1}".format(self.proc.pid,
                                                                                   e)) 
Example 17
Project: mobly   Author: google   File: utils.py    (license) View Source Project 6 votes vote down vote up
def wait_for_standing_subprocess(proc, timeout=None):
    """Waits for a subprocess started by start_standing_subprocess to finish
    or times out.

    Propagates the exception raised by the subprocess.wait(.) function.
    The subprocess.TimeoutExpired exception is raised if the process timed-out
    rather then terminating.

    If no exception is raised: the subprocess terminated on its own. No need
    to call stop_standing_subprocess() to kill it.

    If an exception is raised: the subprocess is still alive - it did not
    terminate. Either call stop_standing_subprocess() to kill it, or call
    wait_for_standing_subprocess() to keep waiting for it to terminate on its
    own.

    Args:
        p: Subprocess to wait for.
        timeout: An integer number of seconds to wait before timing out.
    """
    proc.wait(timeout) 
Example 18
Project: MUBench   Author: stg-tud   File: shell.py    (license) View Source Project 6 votes vote down vote up
def exec(command: str, cwd: str = os.getcwd(), logger=logging.getLogger(__name__), timeout: Optional[int] = None):
        logger.debug("Execute '%s' in '%s'", command, cwd)
        encoding = Shell.__get_encoding()
        try:
            # On our Debian server subprocess does not return until after the process finished, but then correctly
            # raises TimeoutExpired, if the process took to long. We use `timeout` to ensure that the process terminates
            # eventually.
            if "Linux" in platform() and timeout is not None:
                command = "timeout {} {}".format(timeout + 60, command)

            output = Shell.__exec(command, cwd, timeout, encoding)
            logger.debug(output)
            return output
        except CalledProcessError as e:
            raise CommandFailedError(e.cmd, e.output.decode(encoding), e.stderr.decode(encoding))
        except TimeoutExpired as e:
            raise TimeoutError(e.cmd, e.output.decode(encoding)) 
Example 19
Project: web_ctp   Author: molebot   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout(self):
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stderr.write("pineapple\\n");'
                              'time.sleep(1);'
                              'sys.stderr.write("pear\\n");'
                              'sys.stdout.write(sys.stdin.read())'],
                             universal_newlines=True,
                             stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, "banana",
                          timeout=0.3)
        # Make sure we can keep waiting for it, and that we get the whole output
        # after it completes.
        (stdout, stderr) = p.communicate()
        self.assertEqual(stdout, "banana")
        self.assertStderrEqual(stderr.encode(), b"pineapple\npear\n") 
Example 20
Project: web_ctp   Author: molebot   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout_large_ouput(self):
        # Test an expiring timeout while the child is outputting lots of data.
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'],
                             stdout=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, timeout=0.4)
        (stdout, _) = p.communicate()
        self.assertEqual(len(stdout), 4 * 64 * 1024)

    # Test for the fd leak reported in http://bugs.python.org/issue2791. 
Example 21
Project: online-judge-tools   Author: kmyk   File: utils.py    (license) View Source Project 6 votes vote down vote up
def exec_command(command, timeout=None, **kwargs):
    try:
        proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=sys.stderr, **kwargs)
    except FileNotFoundError:
        log.error('No such file or directory: %s', command)
        sys.exit(1)
    except PermissionError:
        log.error('Permission denied: %s', command)
        sys.exit(1)
    try:
        answer, _ = proc.communicate(timeout=timeout)
    except subprocess.TimeoutExpired:
        answer = b''
    return answer, proc

# We should use this instead of posixpath.normpath
# posixpath.normpath doesn't collapse a leading duplicated slashes. see: https://stackoverflow.com/questions/7816818/why-doesnt-os-normpath-collapse-a-leading-double-slash 
Example 22
Project: vswitchperf   Author: opnfv   File: xena.py    (license) View Source Project 6 votes vote down vote up
def _wait_xena_2544_complete(self):
        """
        Wait for Xena2544.exe completion.
        :return: None
        """
        data = ''
        while True:
            try:
                self.mono_pipe.wait(60)
                self._log_handle.close()
                break
            except subprocess.TimeoutExpired:
                # check the log to see if Xena2544 has completed and mono is
                # deadlocked.
                data += self._log_handle.read()
                if 'TestCompletedSuccessfully' in data:
                    self._log_handle.close()
                    self.mono_pipe.terminate()
                    break 
Example 23
Project: wifimitm   Author: mvondracek   File: updatableProcess.py    (license) View Source Project 6 votes vote down vote up
def stop(self):
        """
        Stop process if it's running.
        """
        if self.cleaned:
            raise ValueError("Can't call stop on process after cleanup was performed.")
        if self.poll() is None:
            # process is running
            self.terminate()
            try:
                logger.debug('Waiting for {} process to terminate.'.format(type(self).__name__))
                self.wait(timeout=10)
            except subprocess.TimeoutExpired:
                self.kill()
                logger.warning('Process {} killed after unsuccessful termination.'.format(type(self).__name__))
            else:
                logger.debug('Process {} terminated.'.format(type(self).__name__))

        self.update() 
Example 24
Project: GAFBot   Author: DiNitride   File: core.py    (license) View Source Project 6 votes vote down vote up
def update(self, ctx):
        """
        Updates the bot from the Github repo
        """
        await ctx.send("Calling process to update! :up: :date: ")
        try:
            done = subprocess.run("git pull", shell=True, stdout=subprocess.PIPE, timeout=30)
            if done:
                message = done.stdout.decode()
                await ctx.send("`{}`".format(message))
                if message == "Already up-to-date.\n":
                    await ctx.send("No update available :no_entry:")
                else:
                    await ctx.send("Succesfully updated! Rebooting now :repeat: ")
                    await self.bot.logout()
        except subprocess.CalledProcessError:
            await ctx.send("Error updating! :exclamation: ")
        except subprocess.TimeoutExpired:
            await ctx.send("Error updating - Process timed out! :exclamation: ") 
Example 25
Project: build   Author: freenas   File: vm.py    (license) View Source Project 6 votes vote down vote up
def do_install():
    info('Starting up VM for unattended install')
    vm_proc = sh_spawn(
        'bhyve -m ${MEMSIZE} -c ${CORES} -A -H -P',
        '-s 3:0,ahci-hd,${destdir}/boot.img',
        '-s 4:0,ahci-hd,${destdir}/hd1.img',
        '-s 5:0,ahci-hd,${destdir}/hd2.img',
        '-s 6:0,ahci-cd,${isopath}',
        '-s 7:0,virtio-net,${tapdev}',
        '-s 8:0,fbuf,tcp=5900,w=1024,h=768',
        '-s 31,lpc',
        '-l bootrom,/usr/local/share/uefi-firmware/BHYVE_UEFI.fd',
        '${VM_NAME}'
    )

    try:
        vm_proc.wait(timeout=3600)
    except subprocess.TimeoutExpired:
        fail('Install timed out after 1 hour') 
Example 26
Project: tfhfs   Author: fingon   File: perf_fs.py    (license) View Source Project 6 votes vote down vote up
def close_fs(t):
    import test_fs

    (p, args) = t
    args = test_fs.argument_parser().parse_args(args)
    try:
        subprocess.call(['umount', args.mountpoint], stderr=subprocess.DEVNULL)
    except:
        pass
    try:
        rc = p.wait(timeout=3)
    except subprocess.TimeoutExpired:
        p.terminate()
        try:
            rc = p.wait(timeout=3)
        except subprocess.TimeoutExpired:
            p.kill()
            p.wait() 
Example 27
Project: thesis_scripts   Author: PhilippKopp   File: eos_starter_lib.py    (license) View Source Project 6 votes vote down vote up
def run(cmd, timeout_sec):

	if (sys.version_info >= (3,5)):
		try:
			completed = subprocess.run(shlex.split(cmd), timeout=timeout_sec, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
			return completed.stdout.decode('utf-8'), completed.stderr.decode('utf-8')
		except subprocess.TimeoutExpired:
			message = 'Fitting got killed by timeout after '+str(timeout_sec)+' sec!'
			print (message)
			raise EslException(message)
	else:
		proc = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
		kill_proc = lambda p: p.kill()
		timer = Timer(timeout_sec, kill_proc, [proc])
	
		try:
			timer.start()
			stdout,stderr = proc.communicate()
		finally:
			timer.cancel()
			if (proc.poll() == -9 ):
				raise EslException('Fitting probably got killed by timeout!')
			#if (proc.poll() != 0 ):
			#	raise EslException('Fitting crashed! returned '+str(proc.poll()))
			return stdout, stderr 
Example 28
Project: ouroboros   Author: pybee   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout(self):
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stderr.write("pineapple\\n");'
                              'time.sleep(1);'
                              'sys.stderr.write("pear\\n");'
                              'sys.stdout.write(sys.stdin.read())'],
                             universal_newlines=True,
                             stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, "banana",
                          timeout=0.3)
        # Make sure we can keep waiting for it, and that we get the whole output
        # after it completes.
        (stdout, stderr) = p.communicate()
        self.assertEqual(stdout, "banana")
        self.assertStderrEqual(stderr.encode(), b"pineapple\npear\n") 
Example 29
Project: ouroboros   Author: pybee   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout_large_ouput(self):
        # Test an expiring timeout while the child is outputting lots of data.
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'],
                             stdout=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, timeout=0.4)
        (stdout, _) = p.communicate()
        self.assertEqual(len(stdout), 4 * 64 * 1024)

    # Test for the fd leak reported in http://bugs.python.org/issue2791. 
Example 30
Project: simple-ostinato   Author: little-dude   File: utils.py    (license) View Source Project 6 votes vote down vote up
def kill_drone():
    global DRONE_RUNNING
    LOG.info('stopping drone')
    if DRONE_RUNNING is False:
        LOG.warning('drone is not running, nothing to do')
        return
    LOG.info('trying to stop drone gracefully')
    DRONE.terminate()
    try:
        DRONE.wait(timeout=10)
        LOG.info('drone exited gracefully')
    except subprocess.TimeoutExpired:
        LOG.info('could not terminate drone properly, kill it.')
        DRONE.kill()
        DRONE.wait(timeout=10)
        LOG.info('drone has been killed')
    DRONE_RUNNING = False 
Example 31
Project: OverviewOne   Author: SpaceVR-O1   File: stagger.py    (license) View Source Project 6 votes vote down vote up
def do_onecam(i, offset_ms,iterator):
    time.sleep(offset_ms/1000.0)
    print("Time = %f ms : Capturing camera num %d" % (offset_ms, i))
    # TODO: run the camera capture code
    filename = "/media/ubuntu/VRcameraSSD/tmp/cam%d.%d" % (i,iterator)
    p = subprocess.Popen(
            ["sudo", "./snapshot", filename, "--dev", ("/dev/still%d" % i), "--format", "jpg", "--size", str(4192), str(3104), "--suspend", "--resume"],
            stdout=subprocess.PIPE)
    try:
            (output, err) = p.communicate(timeout=30)
            output_str = output.decode("utf-8")

            if re.search(r"\*FULL\*", output_str, flags=re.MULTILINE):
                print("OK")
            elif re.search(r"\*INCOMPLETE\*", output_str, flags=re.MULTILINE):
                print("INCOMPLETE")
            else:
                print("*** FAILED ***")
                print("Kernel log:")
                #print(get_kern_log(10))

    except subprocess.TimeoutExpired:
    	print("TIMEOUT") 
Example 32
Project: OverviewOne   Author: SpaceVR-O1   File: uvcstill.py    (license) View Source Project 6 votes vote down vote up
def test_all_cameras(numCams, width, height):
    for i in range(0, numCams):

        print("  cam %d : " % i, end="")
        p = subprocess.Popen(
            ["sudo", "./snapshot", "/dev/null", "--dev", ("/dev/still%d" % i), "--format", "none", "--size", str(width), str(height), "--suspend", "--resume"],
            stdout=subprocess.PIPE)
        try:
            (output, err) = p.communicate(timeout=30)
            output_str = output.decode("utf-8")

            if re.search(r"\*FULL\*", output_str, flags=re.MULTILINE):
                print("OK")
            elif re.search(r"\*INCOMPLETE\*", output_str, flags=re.MULTILINE):
                print("INCOMPLETE")
            else:
                print("*** FAILED ***")
                print("Kernel log:")
                print(get_kern_log(10))

        except subprocess.TimeoutExpired:
            print("TIMEOUT")


# Read an image from each camera and save it to disk. 
Example 33
Project: OverviewOne   Author: SpaceVR-O1   File: run_parallel_capture.py    (license) View Source Project 6 votes vote down vote up
def do_onecam(i, offset_ms):
    time.sleep(offset_ms/1000.0)
    print("Time = %f ms : Capturing camera num %d" % (offset_ms, i))
    # TODO: run the camera capture code
    filename = "/media/ubuntu/VRcameraSSD/tmp/cam%d.yuyv" % (i)
    p = subprocess.Popen(
            ["sudo", "./snapshot", filename, "--dev", ("/dev/still%d" % i), "--format", "yuyv", "--size", str(4192), str(3104), "--suspend", "--resume"],
            stdout=subprocess.PIPE)
    try:
            (output, err) = p.communicate(timeout=30)
            output_str = output.decode("utf-8")

            if re.search(r"\*FULL\*", output_str, flags=re.MULTILINE):
                print("OK")
            elif re.search(r"\*INCOMPLETE\*", output_str, flags=re.MULTILINE):
                print("INCOMPLETE")
            else:
                print("*** FAILED ***")
                print("Kernel log:")
                #print(get_kern_log(10))

    except subprocess.TimeoutExpired:
    	print("TIMEOUT") 
Example 34
Project: USTC-Software-2017   Author: igemsoftware2017   File: __main__.py    (license) View Source Project 6 votes vote down vote up
def main(arguments):

    global celery_process, server_process

    print('Starting celery...')
    celery_process = subprocess.Popen(
        ['celery', '-E', '-A', 'abacus_server', 'worker',
         '--concurrency', str(arguments.concurrency),
         '-l', 'info',
         '-n', '[email protected]:%s' % arguments.port],
        cwd=BASE_DIR, stdout=subprocess.PIPE
    )

    try:
        output, _ = celery_process.communicate(timeout=.5)
    except subprocess.TimeoutExpired:
        # Celery starts successfully
        print('Celery process started successfully!')
    else:
        return

    print('Starting server...')
    server_process = subprocess.Popen(['./manage.py', 'runserver', str(arguments.port)], cwd=BASE_DIR)

    server_process.communicate() 
Example 35
Project: Home-Assistant-Config   Author: Norien   File: life360.py    (license) View Source Project 6 votes vote down vote up
def exec_shell_command( self, command ):

        output = None
        try:
            output = subprocess.check_output( command, shell=True, timeout=50 )
            output = output.strip().decode('utf-8')

        except subprocess.CalledProcessError:
            """ _LOGGER.error("Command failed: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None
        except subprocess.TimeoutExpired:
            """ _LOGGER.error("Timeout for command: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None

        if output == None:
            _LOGGER.error( "Life360 has not responsed well. Nothing to worry, will try again!" )
            self.value = CONST_STATE_ERROR
            return None
        else:
            return output 
Example 36
Project: gitsome   Author: donnemartin   File: jobs.py    (license) View Source Project 6 votes vote down vote up
def wait_for_active_job(signal_to_send=None):
        """
        Wait for the active job to finish, to be killed by SIGINT, or to be
        suspended by ctrl-z.
        """
        _clear_dead_jobs()
        act = builtins.__xonsh_active_job__
        if act is None:
            return
        job = builtins.__xonsh_all_jobs__[act]
        obj = job['obj']
        if job['bg']:
            return
        while obj.returncode is None:
            try:
                obj.wait(0.01)
            except TimeoutExpired:
                pass
            except KeyboardInterrupt:
                obj.kill()
        if obj.poll() is not None:
            builtins.__xonsh_active_job__ = None 
Example 37
Project: simphony-remote   Author: simphony   File: test_spawners.py    (license) View Source Project 6 votes vote down vote up
def test_cmd_spawning(self):
        env = os.environ.copy()
        env["PROXY_API_TOKEN"] = "dummy_token"
        path = fixtures.get("remoteappmanager_config.py")
        self.spawner.config_file_path = path

        args = self.spawner.get_args()

        try:
            with self.assertRaises(subprocess.TimeoutExpired):
                subprocess.check_output(
                    self.spawner.cmd + args,
                    timeout=2,
                    env=env,
                    stderr=subprocess.STDOUT)
        except subprocess.CalledProcessError as exc:
            print("Output of the command:\n\n{}".format(
                exc.output.decode(sys.getdefaultencoding())))
            raise 
Example 38
Project: homeassistant-config   Author: arsaboo   File: life360.py    (license) View Source Project 6 votes vote down vote up
def exec_shell_command( self, command ):

        output = None
        try:
            output = subprocess.check_output( command, shell=True, timeout=60 )
            output = output.strip().decode('utf-8')

        except subprocess.CalledProcessError:
            """ _LOGGER.error("Command failed: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None
        except subprocess.TimeoutExpired:
            """ _LOGGER.error("Timeout for command: %s", command)"""
            self.value = CONST_STATE_ERROR
            output = None

        if output == None:
            _LOGGER.error( "Life360 has not responsed well. Nothing to worry, will try again!" )
            self.value = CONST_STATE_ERROR
            return None
        else:
            return output 
Example 39
Project: kbe_server   Author: xiaohaoppy   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout(self):
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stderr.write("pineapple\\n");'
                              'time.sleep(1);'
                              'sys.stderr.write("pear\\n");'
                              'sys.stdout.write(sys.stdin.read())'],
                             universal_newlines=True,
                             stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, "banana",
                          timeout=0.3)
        # Make sure we can keep waiting for it, and that we get the whole output
        # after it completes.
        (stdout, stderr) = p.communicate()
        self.assertEqual(stdout, "banana")
        self.assertStderrEqual(stderr.encode(), b"pineapple\npear\n") 
Example 40
Project: kbe_server   Author: xiaohaoppy   File: test_subprocess.py    (license) View Source Project 6 votes vote down vote up
def test_communicate_timeout_large_ouput(self):
        # Test an expiring timeout while the child is outputting lots of data.
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os,time;'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'
                              'time.sleep(0.2);'
                              'sys.stdout.write("a" * (64 * 1024));'],
                             stdout=subprocess.PIPE)
        self.assertRaises(subprocess.TimeoutExpired, p.communicate, timeout=0.4)
        (stdout, _) = p.communicate()
        self.assertEqual(len(stdout), 4 * 64 * 1024)

    # Test for the fd leak reported in http://bugs.python.org/issue2791. 
Example 41
Project: DataBot   Author: Mego   File: EvalModule.py    (license) View Source Project 6 votes vote down vote up
def run_subprocess(cinput, invoke, universal_newlines=True, **kwargs):
    process = subprocess.Popen(invoke, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=universal_newlines, **kwargs) 
    try:
        result = process.communicate(input=cinput, timeout=60)[0]
    except subprocess.TimeoutExpired:
        process.kill()
        result = "Sorry, your code took too long to run!"
        partial_out = process.communicate()[0] # communicate returns a tuple first element is stdout second is stderr
        if partial_out:
            result += "\nPartial output:\n" + partial_out
    except:
        traceback.print_exc()
        result = "There was an issue running your code."
    return result
        
#temporary workaround while TIO is bugged 
Example 42
Project: concourse-ansible-resource   Author: SpringerPE   File: resource.py    (license) View Source Project 6 votes vote down vote up
def process(self, cmd=[], input=None, timeout=None):
        proc = subprocess.Popen(cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE)
        self.logger.info('Running process, pid=%d: %s' % (proc.pid, str(cmd)))
        try:
            output, err = proc.communicate(input, timeout=timeout)
        except subprocess.TimeoutExpired as e:
            self.logger.warning(
                'Process %d killed with timeout %s' % (proc.pid, str(timeout)))
            proc.kill()
            output, err = proc.communicate()
        self.logger.debug("stdout: " + repr(output))
        self.logger.debug("stderr: " + repr(err))
        stdout = output.decode('utf-8')
        stderr = err.decode('utf-8')
        if proc.returncode != 0:
            self.logger.warning(
                'Process %d failed with rcode %d' % (proc.pid, int(proc.returncode)))
        else:
            self.logger.debug('Process %d finished with rcode 0' % (proc.pid))
        return int(proc.returncode), stdout, stderr 
Example 43
Project: videoscreen   Author: SFTtech   File: mpd.py    (license) View Source Project 6 votes vote down vote up
def run_cmd(self, cmd):
        """ run a mpd control command """

        call = ["mpc"]
        if self.host:
            call.extend(["--host", self.host])
        if self.port:
            call.extend(["--port", self.port])

        call.append(cmd)

        proc = subprocess.Popen(call, stdout=subprocess.PIPE)
        output, _ = proc.communicate()
        try:
            proc.wait(1)
        except subprocess.TimeoutExpired:
            raise Exception("mpc doesn't terminate!")

        return output 
Example 44
Project: sawtooth-core   Author: hyperledger   File: test_shutdown_smoke.py    (license) View Source Project 6 votes vote down vote up
def _wait_for_containers_exit_status(self, containers):
        """Wait for all of the specified containers to exit
        and return their exit codes.
        Args:
            containers (list of str): The containers to wait to exit.

        Returns:
            list of int: The list of return codes for the process in each
                container.

        """
        wait = ['docker', 'wait'] + containers
        handle = subprocess.Popen(
            args=wait,
            stdout=subprocess.PIPE,
            universal_newlines=True)
        try:
            output, _ = handle.communicate(timeout=35)
            return [int(e) for e in output.strip().split('\n')]
        except subprocess.TimeoutExpired:
            handle.kill()
            LOGGER.warning("Docker timed out waiting for %s to exit",
                           containers)
            return [] 
Example 45
Project: OnlineSchemaChange   Author: facebookincubator   File: util.py    (license) View Source Project 6 votes vote down vote up
def rm(filename, sudo=False):
    """
    Remove a file on the disk, not us os.rm because we want to add timeout to
    the command. It's possible that the os call got hang when the disk has
    some problems
    """
    cmd_args = []
    if sudo:
        cmd_args += ['sudo']
    cmd_args += ['/bin/rm', filename]
    log.debug("Executing cmd: {}".format(str(cmd_args)))
    proc = subprocess.Popen(cmd_args, stdin=subprocess.PIPE,
                            stdout=subprocess.PIPE)
    try:
        (stdout, stderr) = proc.communicate(timeout=10)
    except subprocess.TimeoutExpired:
        proc.kill()
        raise OSCError('SHELL_TIMEOUT', {'cmd': ' '.join(cmd_args)}) 
Example 46
Project: charm-designate   Author: openstack   File: designate.py    (license) View Source Project 6 votes vote down vote up
def update_pools(self):
        # designate-manage communicates with designate via message bus so no
        # need to set OS_ vars
        # NOTE(AJK) this runs with every hook (once most relations are up) and
        # so if it fails it will be picked up by the next relation change or
        # update-status.  i.e. it will heal eventually.
        if hookenv.is_leader():
            try:
                cmd = "designate-manage pool update"
                # Note(tinwood) that this command may fail if the pools.yaml
                # doesn't actually contain any pools.  This happens when the
                # relation is broken, which errors out the charm.  This stops
                # this happening and logs the error.
                subprocess.check_call(cmd.split(), timeout=60)
            except subprocess.CalledProcessError as e:
                hookenv.log("designate-manage pool update failed: {}"
                            .format(str(e)))
            except subprocess.TimeoutExpired as e:
                # the timeout is if the rabbitmq server has gone away; it just
                # retries continuously; this lets the hook complete.
                hookenv.log("designate-manage pool command timed out: {}".
                            format(str(e))) 
Example 47
Project: maas   Author: maas   File: test_maas_run_remote_scripts.py    (license) View Source Project 6 votes vote down vote up
def test_run_script_timed_out_script(self):
        scripts_dir = self.useFixture(TempDirectory()).path
        script = make_script(scripts_dir=scripts_dir)
        self.mock_capture_script_output.side_effect = TimeoutExpired(
            [factory.make_name('arg') for _ in range(3)],
            script['timeout_seconds'])
        self.args.pop('status')

        self.assertFalse(run_script(script, scripts_dir))

        self.assertThat(self.mock_output_and_send, MockCallsMatch(
            call(
                'Starting %s' % script['msg_name'], status='WORKING',
                **self.args),
            call(
                'Timeout(%s) expired on %s' % (
                    str(timedelta(seconds=script['timeout_seconds'])),
                    script['msg_name']),
                files={
                    script['combined_name']: script['combined'].encode(),
                    script['stdout_name']: script['stdout'].encode(),
                    script['stderr_name']: script['stderr'].encode(),
                    script['result_name']: script['result'].encode(),
                }, status='TIMEDOUT', **self.args),
        )) 
Example 48
Project: maas   Author: maas   File: avahi.py    (license) View Source Project 6 votes vote down vote up
def _terminate_process(process, wait=2.5, kill=2.5):
    """Ensures that `process` terminates.

    :return: The exit code of the process.
    """
    try:
        # The subprocess may have already been signalled, for example as part
        # of this process's process group when Ctrl-c is pressed at the
        # terminal, so give it some time to exit.
        return process.wait(timeout=wait)
    except subprocess.TimeoutExpired:
        # Either the subprocess has not been signalled, or it's slow.
        process.terminate()  # SIGTERM.
        try:
            return process.wait(timeout=kill)
        except subprocess.TimeoutExpired:
            process.kill()  # SIGKILL.
            return process.wait() 
Example 49
Project: AlphaGSM   Author: SectorAlpha   File: custom.py    (license) View Source Project 6 votes vote down vote up
def install(server,*,eula=False):
    if not os.path.isdir(server.data["dir"]):
        os.makedirs(server.data["dir"])
    mcjar=os.path.join(server.data["dir"],server.data["exe_name"])
    if not os.path.isfile(mcjar):
        raise ServerError("Can't find server jar ({}). Please place the files in the directory and/or update the 'exe_name' then run setup again".format(mcjar))
    server.data.save()

    eulafile=os.path.join(server.data["dir"],"eula.txt")
    configfile=os.path.join(server.data["dir"],"server.properties")
    if not os.path.isfile(configfile) or (eula and not os.path.isfile(eulafile)): # use as flag for has the server created it's files
        print("Starting server to create settings")
        try:
            ret=sp.check_call(["java","-jar",server.data["exe_name"],"nogui"],cwd=server.data["dir"],shell=False,timeout=20)
        except sp.CalledProcessError as ex:
            print("Error running server. Java returned status: "+ex.returncode)
        except sp.TimeoutExpired as ex:
            print("Error running server. Process didn't complete in time")
    updateconfig(configfile,{"server-port":str(server.data["port"])})
    if eula:
        updateconfig(eulafile,{"eula":"true"}) 
Example 50
Project: hass_config   Author: azogue   File: cronip.py    (license) View Source Project 6 votes vote down vote up
def _get_cmd_output(cmd, default=None, verbose=True, **kwargs):
    list_cmd = cmd.split()
    # kwargs.update({'stdout': subprocess.PIPE})
    try:
        out = subprocess.check_output(list_cmd, **kwargs).decode()
        if out.endswith('\n'):
            return True, out[:-1]
        return True, out
    except subprocess.TimeoutExpired as e:
        time.sleep(TIME_PAUSE / 2)
        if verbose:
            print('\nERROR subprocess.CalledProcessError: {} invocando el comando: {}'.format(e, cmd))
    except subprocess.CalledProcessError as e:
        if verbose:
            print('\nERROR subprocess.CalledProcessError: {} invocando el comando: {}'.format(e, cmd))
    except FileNotFoundError as e:
        if verbose:
            print('\nERROR FileNotFoundError: {} invocando el comando: {}'.format(e, cmd))
    if default:
        return False, default
    return False, 0