def _process_snapshot(self, snapshot_path, pixfmt="yuv420p"): hflip = self._settings.global_get_boolean(["webcam", "flipH"]) vflip = self._settings.global_get_boolean(["webcam", "flipV"]) rotate = self._settings.global_get_boolean(["webcam", "rotate90"]) ffmpeg = self._settings.global_get(["webcam", "ffmpeg"]) if not ffmpeg or not os.access(ffmpeg, os.X_OK) or (not vflip and not hflip and not rotate): return ffmpeg_command = [ffmpeg, "-y", "-i", snapshot_path] rotate_params = ["format={}".format(pixfmt)] # workaround for foosel/OctoPrint#1317 if rotate: rotate_params.append("transpose=2") # 90 degrees counter clockwise if hflip: rotate_params.append("hflip") # horizontal flip if vflip: rotate_params.append("vflip") # vertical flip ffmpeg_command += ["-vf", sarge.shell_quote(",".join(rotate_params)), snapshot_path] self._logger.info("Running: {}".format(" ".join(ffmpeg_command))) p = sarge.run(ffmpeg_command, stdout=sarge.Capture(), stderr=sarge.Capture()) if p.returncode == 0: self._logger.info("Rotated/flipped image with ffmpeg") else: self._logger.warn("Failed to rotate/flip image with ffmpeg, " "got return code {}: {}, {}".format(p.returncode, p.stdout.text, p.stderr.text))
def _start(self): """Start work task running in the background. User should not need to call this directly. Work with your subclasses `run` method instead. """ self._results = None if not self.command: raise ValueError('command not defined') # Pre-existing process ID? if self.is_running: if self.verbose: print('\nProcess already running with PID: {:d}'.format( self.pid)) return self.pid # Instantiate command and run it self._proc = sarge.Command(self.command, stdout=sarge.Capture(), stderr=sarge.Capture(), shell=True) self._proc.run(async=True) if not self.is_running: raise ValueError('Problem starting process: {}'.format( self.fname_exe))
def autodetect_pip(cls): commands = [ [sys.executable, "-m", "pip"], [ os.path.join(os.path.dirname(sys.executable), "pip.exe" if sys.platform == "win32" else "pip") ], # this should be our last resort since it might fail thanks to using pip programmatically like # that is not officially supported or sanctioned by the pip developers [ sys.executable, "-c", "import sys; sys.argv = ['pip'] + sys.argv[1:]; import pip; pip.main()" ] ] for command in commands: p = sarge.run(command + ["--version"], stdout=sarge.Capture(), stderr=sarge.Capture()) if p.returncode == 0: logging.getLogger(__name__).info( "Using \"{}\" as command to invoke pip".format( " ".join(command))) return command return None
def generate_password(self): """Generates an org password with the sfdx utility. """ if self.password_failed: self.logger.warn( "Skipping resetting password since last attempt failed") return # Set a random password so it's available via cci org info command = sarge.shell_format( "sfdx force:user:password:generate -u {0}", self.username) self.logger.info( "Generating scratch org user password with command {}".format( command)) p = sarge.Command( command, stdout=sarge.Capture(buffer_size=-1), stderr=sarge.Capture(buffer_size=-1), shell=True, ) p.run() stdout = [] for line in p.stdout: stdout.append(line) stderr = [] for line in p.stderr: stderr.append(line) if p.returncode: self.config["password_failed"] = True # Don't throw an exception because of failure creating the # password, just notify in a log message self.logger.warn("Failed to set password: \n{}\n{}".format( "\n".join(stdout), "\n".join(stderr)))
def executeSystemCommand(source, command): logger = logging.getLogger(__name__) if command == "divider": return make_response("Dividers cannot be executed", 400) command_spec = _get_command_spec(source, command) if not command_spec: return make_response("Command {}:{} not found".format(source, command), 404) if not "command" in command_spec: return make_response( "Command {}:{} does not define a command to execute, can't proceed" .format(source, command), 500) async = command_spec["async"] if "async" in command_spec else False ignore = command_spec["ignore"] if "ignore" in command_spec else False logger.info("Performing command for {}:{}: {}".format( source, command, command_spec["command"])) try: # we run this with shell=True since we have to trust whatever # our admin configured as command and since we want to allow # shell-alike handling here... p = sarge.run(command_spec["command"], stdout=sarge.Capture(), stderr=sarge.Capture(), shell=True, async=async)
def run(cmd, raise_on_error=True, capture_output=True, suppress_output=False, **kwargs): """ Wrapper around sarge.run that can raise errors and capture stdout. """ if capture_output: kwargs['stdout'] = sarge.Capture() kwargs['stderr'] = sarge.Capture() result = sarge.run(cmd, **kwargs) code = result.returncode if code and raise_on_error: raise RuntimeError('Command failed, exit code %s' % code) if capture_output: stdout = result.stdout.read() result.stdout_lines = stdout.decode().split('\n') if result.stdout_lines[-1] == '': result.stdout_lines = result.stdout_lines[:-1] if not suppress_output: if stdout: click.echo(stdout) stderr = result.stderr.read() if stderr: click.echo(stderr, err=True) return result
def execute(command, cwd=None, evaluate_returncode=True, **kwargs): do_async = kwargs.get("do_async", kwargs.get("async", False)) import sarge p = None try: p = sarge.run(command, cwd=cwd, stdout=sarge.Capture(), stderr=sarge.Capture(), async_=do_async) except: logging.getLogger(__name__).exception( "Error while executing command: {}".format(command)) returncode = p.returncode if p is not None else None stdout = p.stdout.text if p is not None and p.stdout is not None else "" stderr = p.stderr.text if p is not None and p.stderr is not None else "" raise ScriptError(returncode, stdout, stderr) if evaluate_returncode and p.returncode != 0: raise ScriptError(p.returncode, p.stdout.text, p.stderr.text) if not do_async: return p.returncode, p.stdout.text, p.stderr.text
def run_command_with_logging(args): logger.info(f"Running command: {args}") with sarge.Capture(buffer_size=1) as stdout, sarge.Capture( buffer_size=1) as stderr: pipeline = sarge.run(args, async_=True, stdout=stdout, stderr=stderr) while pipeline.commands[-1].poll() == None: stdout_result = stdout.read(block=False) if stdout_result != b'': logger.info(stdout_result) stderr_result = stderr.read(block=False) if stderr_result != b'': logger.error(stderr_result) if stdout_result != b'' or stderr_result != b'': time.sleep(0.1) stdout_result = stdout.read() if stdout_result != b'': logger.info(stdout_result) stderr_result = stderr.read() if stderr_result != b'': logger.error(stderr_result) if pipeline.commands[-1].poll() != 0: raise CmError(args, stdout, stderr)
def _render(self, template_filename): render_config = self.render_config(template_filename) if self.badge_instance: url = reverse( "main:instance-filename", kwargs={ "slug": self.badge_template.slug, "pk": self.badge_instance.pk, "filename": template_filename, }, ) else: url = reverse( "main:preview-filename", kwargs={ "slug": self.badge_template.slug, "filename": template_filename, }, ) file_format = render_config.get("format", "png") if file_format == "pdf": f = tempfile.NamedTemporaryFile(delete=False) tmppdf = f.name f.close() cmd = ( "node {chrome_pdf_bin} " "--paper-width 8.27 --paper-height 11.69" "--no-margins --landscape --include-background --url {url} --pdf {tmppdf}" .format( chrome_pdf_bin=settings.CHROME_PDF_BIN, tmppdf=tmppdf, url="{}{}".format(settings.RENDER_PREFIX_URL, url), )) sarge.run(cmd, stdout=sarge.Capture()) f = open(tmppdf, "rb") image = f.read() f.close() os.unlink(f.name) else: cmd = ("{capture_bin} {url} --width={width} --height={height} " "--type={type} --element={element} --no-default-background". format( width=render_config.get("screen_width", 1000), height=render_config.get("screen_height", 1000), type=file_format, element=sarge.shell_quote( render_config.get("element", ".screenshot")), url="{}{}".format(settings.RENDER_PREFIX_URL, url), capture_bin=settings.CAPTURE_BIN, )) p = sarge.run(cmd, stdout=sarge.Capture()) image = p.stdout.bytes mime = magic.from_buffer(image, mime=True) return image, mime
def _prepareCapture(encoding, *, wantOut=False, wantErr=False): ret = {} if wantOut: ret["stdout"] = sarge.Capture(encoding=encoding) if wantErr: ret["stderr"] = sarge.Capture(encoding=encoding) return ret
def _render(self): """Rendering runnable.""" ffmpeg = settings().get(["webcam", "ffmpeg"]) bitrate = settings().get(["webcam", "bitrate"]) if ffmpeg is None or bitrate is None: self._logger.warn("Cannot create movie, path to ffmpeg or desired bitrate is unset") return input = os.path.join(self._capture_dir, self._capture_format.format(prefix=self._prefix, postfix=self._postfix if self._postfix is not None else "")) output = os.path.join(self._output_dir, self._output_format.format(prefix=self._prefix, postfix=self._postfix if self._postfix is not None else "")) for i in range(4): if os.path.exists(input % i): break else: self._logger.warn("Cannot create a movie, no frames captured") self._notify_callback("fail", output, returncode=0, stdout="", stderr="", reason="no_frames") return hflip = settings().getBoolean(["webcam", "flipH"]) vflip = settings().getBoolean(["webcam", "flipV"]) rotate = settings().getBoolean(["webcam", "rotate90"]) watermark = None if settings().getBoolean(["webcam", "watermark"]): watermark = os.path.join(os.path.dirname(__file__), "static", "img", "watermark.png") if sys.platform == "win32": # Because ffmpeg hiccups on windows' drive letters and backslashes we have to give the watermark # path a special treatment. Yeah, I couldn't believe it either... watermark = watermark.replace("\\", "/").replace(":", "\\\\:") # prepare ffmpeg command command_str = self._create_ffmpeg_command_string(ffmpeg, self._fps, bitrate, self._threads, input, output, hflip=hflip, vflip=vflip, rotate=rotate, watermark=watermark) self._logger.debug("Executing command: {}".format(command_str)) with self.render_job_lock: try: self._notify_callback("start", output) p = sarge.run(command_str, stdout=sarge.Capture(), stderr=sarge.Capture()) if p.returncode == 0: self._notify_callback("success", output) else: returncode = p.returncode stdout_text = p.stdout.text stderr_text = p.stderr.text self._logger.warn("Could not render movie, got return code %r: %s" % (returncode, stderr_text)) self._notify_callback("fail", output, returncode=returncode, stdout=stdout_text, stderr=stderr_text, reason="returncode") except: self._logger.exception("Could not render movie due to unknown error") self._notify_callback("fail", output, reason="unknown") finally: self._notify_callback("always", output)
def call(self, command, **kwargs): if isinstance(command, (list, tuple)): joined_command = " ".join(command) else: joined_command = command self._logger.debug(u"Calling: {}".format(joined_command)) self.on_log_call(joined_command) kwargs.update(dict(async=True, stdout=sarge.Capture(), stderr=sarge.Capture()))
def _get_pip_version(self, pip_command): # Debugging this with PyCharm/IntelliJ with Python plugin and no output is being # generated? PyCharm bug. Disable "Attach to subprocess automatically when debugging" # in IDE Settings or patch pydevd.py # -> https://youtrack.jetbrains.com/issue/PY-18365#comment=27-1290453 pip_command_str = pip_command if isinstance(pip_command_str, list): pip_command_str = " ".join(pip_command_str) if not self.ignore_cache and pip_command_str in _cache["version"]: self._logger.debug( "Using cached pip version information for {}".format( pip_command_str)) return _cache["version"][pip_command_str] sarge_command = self.to_sarge_command(pip_command, "--version") p = sarge.run(sarge_command, stdout=sarge.Capture(), stderr=sarge.Capture()) if p.returncode != 0: self._logger.warn( "Error while trying to run pip --version: {}".format( p.stderr.text)) return None, None output = PipCaller._preprocess(p.stdout.text) # output should look something like this: # # pip <version> from <path> (<python version>) # # we'll just split on whitespace and then try to use the second entry if not output.startswith("pip"): self._logger.warn( "pip command returned unparseable output, can't determine version: {}" .format(output)) split_output = [x.strip() for x in output.split()] if len(split_output) < 2: self._logger.warn( "pip command returned unparseable output, can't determine version: {}" .format(output)) version_segment = split_output[1] try: pip_version = pkg_resources.parse_version(version_segment) except: self._logger.exception( "Error while trying to parse version string from pip command") return None, None result = pip_version, version_segment _cache["version"][pip_command_str] = result return result
def run(self) -> (int, str): cancelled = False finished = False capture_out = sarge.Capture() capture_err = sarge.Capture() captured_out = [] captured_err = [] logger.debug("Process executed: %s", self._cmd) pipeline = sarge.run(self._cmd, async=True, stdout=capture_out, stderr=capture_err, shell=False) def kill_all_if_cancelled(): process_is_running = 2 while process_is_running: if finished: process_is_running = process_is_running - 1 while True: line_out_bin = capture_out.readline(block=False) line_out = str(line_out_bin, encoding='utf-8') line = line_out.replace('\n', '').replace('\r', '').replace('\0', '') if not line_out or ord(line_out[0]) == 0: break else: captured_out.append(line) if not self.get_parameters()['dont_log_stdout']: logger.debug(f"| {line}") while True: line_out_bin = capture_err.readline(block=False) line_err = str(line_out_bin, encoding='utf-8') line = line_err.replace('\n', '').replace('\r', '').replace('\0', '') if not line_out or ord(line_out[0]) == 0: break else: captured_err.append(line) if not self.get_parameters()['dont_log_stderr']: logger.warning(f"| {line}") if self._is_cancelled(): nonlocal cancelled cancelled = True for c in pipeline.commands: c.terminate() time.sleep(0.1) if self.get_parameters()['async']: return 0, '', '' watchdog = threading.Thread(target=kill_all_if_cancelled, name='process-watchdog', daemon=True) watchdog.start() pipeline.wait() finished = True watchdog.join() if cancelled: raise UserCancelledError() return pipeline.returncode, '\n'.join(captured_out), '\n'.join(captured_err)
def _erase_dfuprog(self): dfuprog_path = self.get_profile_setting("dfuprog_path") dfuprog_avrmcu = self.get_profile_setting("dfuprog_avrmcu") working_dir = os.path.dirname(dfuprog_path) dfuprog_erasecommand = self.get_profile_setting("dfuprog_erasecommandline") dfuprog_erasecommand = dfuprog_erasecommand.replace( "{dfuprogrammer}", dfuprog_path) dfuprog_erasecommand = dfuprog_erasecommand.replace( "{mcu}", dfuprog_avrmcu) import sarge self._logger.info(u"Running '{}' in {}".format(dfuprog_erasecommand, working_dir)) self._console_logger.info(dfuprog_erasecommand) try: p = sarge.run(dfuprog_erasecommand, cwd=working_dir, async_=True, stdout=sarge.Capture(buffer_size=1), stderr=sarge.Capture(buffer_size=1)) p.wait_events() while p.returncode is None: output = p.stderr.read(timeout=0.5).decode('utf-8') if not output: p.commands[0].poll() continue for line in output.split("\n"): if line.endswith("\r"): line = line[:-1] self._console_logger.info(u"> {}".format(line)) if DFUPROG_ERASING in line: self._logger.info(u"Erasing memory...") self._send_status("progress", subtype="erasing") elif DFUPROG_NODEVICE in line: raise FlashException("No device found") if p.returncode == 0: return True else: raise FlashException( "dfu-programmer returned code {returncode}".format( returncode=p.returncode)) except FlashException as ex: self._logger.error(u"Erasing failed. {error}.".format(error=ex.reason)) self._send_status("flasherror", message=ex.reason) return False except: self._logger.exception(u"Erasing failed. Unexpected error.") self._send_status("flasherror") return False
def executeSystemCommand(source, command): logger = logging.getLogger(__name__) if command == "divider": return make_response("Dividers cannot be executed", 400) command_spec = _get_command_spec(source, command) if not command_spec: return make_response("Command {}:{} not found".format(source, command), 404) if not "command" in command_spec: return make_response( "Command {}:{} does not define a command to execute, can't proceed" .format(source, command), 500) do_async = command_spec.get("async", False) do_ignore = command_spec.get("ignore", False) logger.info("Performing command for {}:{}: {}".format( source, command, command_spec["command"])) try: if "before" in command_spec and callable(command_spec["before"]): command_spec["before"]() except Exception as e: if not do_ignore: error = "Command \"before\" failed: {}".format(str(e)) logger.warn(error) return make_response(error, 500) try: # we run this with shell=True since we have to trust whatever # our admin configured as command and since we want to allow # shell-alike handling here... p = sarge.run(command_spec["command"], stdout=sarge.Capture(), stderr=sarge.Capture(), shell=True, async=do_async) if not do_async: if not do_ignore and p.returncode != 0: returncode = p.returncode stdout_text = p.stdout.text stderr_text = p.stderr.text error = "Command failed with return code {}:\nSTDOUT: {}\nSTDERR: {}".format( returncode, stdout_text, stderr_text) logger.warn(error) return make_response(error, 500) except Exception as e: if not do_ignore: error = "Command failed: {}".format(str(e)) logger.warn(error) return make_response(error, 500) return NO_CONTENT
def _execute(command, **kwargs): import sarge if isinstance(command, (list, tuple)): joined_command = " ".join(command) else: joined_command = command _log_call(joined_command) kwargs.update(dict(async=True, stdout=sarge.Capture(), stderr=sarge.Capture()))
def execute(self, *args): if self.refresh: self.trigger_refresh() if self._command is None: raise UnknownPip() command = [self._command] + list(args) if self._use_sudo: command = ["sudo"] + command joined_command = " ".join(command) self._logger.debug(u"Calling: {}".format(joined_command)) self.on_log_call(joined_command) p = sarge.run(command, async=True, stdout=sarge.Capture(), stderr=sarge.Capture()) p.wait_events() all_stdout = [] all_stderr = [] try: while p.returncode is None: lines = p.stderr.readlines(timeout=0.5) if lines: lines = self._convert_lines(lines) self._log_stderr(*lines) all_stderr += lines lines = p.stdout.readlines(timeout=0.5) if lines: lines = self._convert_lines(lines) self._log_stdout(*lines) all_stdout += lines p.commands[0].poll() finally: p.close() lines = p.stderr.readlines() if lines: lines = map(self._convert_line, lines) self._log_stderr(*lines) all_stderr += lines lines = p.stdout.readlines() if lines: lines = map(self._convert_line, lines) self._log_stdout(*lines) all_stdout += lines return p.returncode, all_stdout, all_stderr
def execute(self, *args): if self.refresh: self.trigger_refresh() if self._command is None: raise UnknownPip() command = [self._command] + list(args) if self._use_sudo: command = ["sudo"] + command joined_command = " ".join(command) self._logger.debug(u"Calling: {}".format(joined_command)) self.on_log_call(joined_command) p = sarge.run(command, async=True, stdout=sarge.Capture(), stderr=sarge.Capture()) p.wait_events() all_stdout = [] all_stderr = [] try: while p.returncode is None: line = p.stderr.readline(timeout=0.5) if line: line = to_unicode(line, errors="replace") self._log_stderr(line) all_stderr.append(line) line = p.stdout.readline(timeout=0.5) if line: line = to_unicode(line, errors="replace") self._log_stdout(line) all_stdout.append(line) p.commands[0].poll() finally: p.close() stderr = p.stderr.text if stderr: split_lines = stderr.split("\n") self._log_stderr(*split_lines) all_stderr += split_lines stdout = p.stdout.text if stdout: split_lines = stdout.split("\n") self._log_stdout(*split_lines) all_stdout += split_lines return p.returncode, all_stdout, all_stderr
def _flash_worker_from_path(self, hex_path, selected_port): if self._printer.is_operational(): self._printer.disconnect() avrdude_path = self._settings.get(["avrdude_path"]) working_dir = os.path.dirname(avrdude_path) avrdude_command = [ avrdude_path, "-v", "-p", "m2560", "-c", "wiring", "-P", selected_port, "-U", "flash:w:" + hex_path + ":i", "-D" ] import sarge self._logger.info(u"Running %r in %s" % (' '.join(avrdude_command), working_dir)) try: p = sarge.run(avrdude_command, cwd=working_dir, async=True, stdout=sarge.Capture(), stderr=sarge.Capture()) p.wait_events() while p.returncode is None: line = p.stderr.read(timeout=0.5) if not line: p.commands[0].poll() continue if "avrdude: writing" in line: self._logger.info(u"Writing memory...") elif "avrdude: verifying ..." in line: self._logger.info(u"Verifying memory...") elif "timeout communicating with programmer" in line: e_msg = "Timeout communicating with programmer" raise AvrdudeException elif "avrdude: ERROR:" in line: e_msg = "AVRDUDE error: " + line[ line.find("avrdude: ERROR:") + len("avrdude: ERROR:"):].strip() raise AvrdudeException if p.returncode == 0: self._logger.info(u"Flashing successful.") else: e_msg = "Avrdude returned code {returncode}".format( returncode=p.returncode) raise AvrdudeException except AvrdudeException: self._logger.error( u"Flashing failed. {error}.".format(error=e_msg)) except: self._logger.exception(u"Flashing failed. Unexpected error.") finally: self.isUpdating = False
def get_git_config(config_key): p = sarge.Command( sarge.shell_format('git config --get "{0!s}"', config_key), stderr=sarge.Capture(buffer_size=-1), stdout=sarge.Capture(buffer_size=-1), shell=True, ) p.run() config_value = io.TextIOWrapper(p.stdout).read().strip() return config_value if config_value and not p.returncode else None
def sh(cmd, show_cmd=False, CaptureOutput = False, Timeout = -1): if show_cmd: print(cmd) try: if CaptureOutput: if Timeout > -1: P = sarge.run(cmd, shell=True, stdout=sarge.Capture(), stderr=sarge.Capture(), async_=True) # sleep(3) try: CMD = P.commands[0] #type: sarge.Command # FIXME: This line generates index exception sometime timed_out = util.wait_process(Timeout, CMD) if timed_out: util.print_color('The command "%s" is timed out!'%cmd, util.tty_colors_cmds.On_Red) util.kill_alive_process(CMD) except: pass else: P = sarge.run(cmd, shell=True, stdout=sarge.Capture(), stderr=sarge.Capture()) else: if Timeout > -1: P = sarge.run(cmd, shell=True, async_=True) # sleep(3) try: CMD = P.commands[0] #type: sarge.Command # FIXME: This line generates index exception sometime timed_out = util.wait_process(Timeout, CMD) if timed_out: util.print_color('The command "%s" is timed out!'%cmd, util.tty_colors_cmds.On_Red) util.kill_alive_process(CMD) except: pass else: P = sarge.run(cmd, shell=True) outputs = '' if P.stdout and len(P.stdout.text) > 0: outputs = P.stdout.text if P.stderr and len(P.stderr.text) > 0: if outputs == '': outputs = P.stderr.text else: outputs += '\n' + P.stderr.text return P.returncode == 0, outputs except: if util.get_makefile_var('Debug') == True: util.Print_Debuging_messages() return False, ''
def callScript(self, panValue, tiltValue): self.panValue = max( self._settings.get(["pan", "minValue"]), min(self._settings.get(["pan", "maxValue"]), panValue)) self.tiltValue = max( self._settings.get(["tilt", "minValue"]), min(self._settings.get(["tilt", "maxValue"]), tiltValue)) # if there are anly pantilt handlers, loop through them, then return if len(self.pantiltHandlers) > 0: values = { 'pan': self.panValue, 'panMin': self._settings.get(["pan", "minValue"]), 'panMax': self._settings.get(["pan", "maxValue"]), 'tilt': self.tiltValue, 'tiltMin': self._settings.get(["tilt", "minValue"]), 'tiltMax': self._settings.get(["tilt", "maxValue"]) } for name, handler in self.pantiltHandlers.items(): handler(values) return script = self._settings.get(["pathToScript"]) if script == "": return self._logger.info("Performing command: {}".format(script)) try: # we run this with shell=True since we have to trust whatever # our admin configured as command and since we want to allow # shell-alike handling here... p = sarge.run(sarge.shell_format('{0} {1} {2}', script, panValue, tiltValue), stdout=sarge.Capture(), stderr=sarge.Capture(), shell=True, async=False) if p.returncode != 0: returncode = p.returncode stdout_text = p.stdout.text stderr_text = p.stderr.text error = "Command failed with return code {}:\nSTDOUT: {}\nSTDERR: {}".format( returncode, stdout_text, stderr_text) self._logger.warn(error) except Exception, e: error = "Command failed: {}".format(str(e)) self._logger.warn(error)
def battery(): result = { "battery_perc": -1, "remaining_seconds": -1, "temperature_c": -1, "adapter_on": None } p = sarge.run("acpi --everything", stdout=sarge.Capture()) output = p.stdout.text first_line = output.splitlines()[0].strip() print(first_line) batt_perc_raw = re.findall("(\d\d\d?)%", first_line) print(batt_perc_raw) result["battery_perc"] = int(batt_perc_raw[0]) try: batt_remain_time = re.findall("(\d\d):(\d\d):(\d\d)", first_line) result["remaining_seconds"] = ( lambda x: x[0] * 3600 + x[1] * 60 + x[2])(list( map(int, batt_remain_time[0]))) except IndexError: result["remaining_seconds"] = -1 temperature_raw = re.findall("Thermal .+(\d\d\.\d) degrees C", output) print("temp", temperature_raw) result["temperature_c"] = float(temperature_raw[0]) adapter_on_raw = re.findall("Adapter \d: (on-line|off-line)", output)[0] print(adapter_on_raw) result["adapter_on"] = (adapter_on_raw == "on-line") and True or False return json_response(result, status_code=200)
def performSystemAction(): if "action" in request.values.keys(): action = request.values["action"] available_actions = s().get(["system", "actions"]) for availableAction in available_actions: if availableAction["action"] == action: command = availableAction["command"] if command: logger = logging.getLogger(__name__) logger.info("Performing command: %s" % command) try: p = sarge.run(command, stderr=sarge.Capture()) if p.returncode != 0: returncode = p.returncode stderr_text = p.stderr.text logger.warn( "Command failed with return code %i: %s" % (returncode, stderr_text)) return make_response( ("Command failed with return code %i: %s" % (returncode, stderr_text), 500, [])) else: return OK except Exception, e: logger.warn("Command failed: %s" % e) return make_response( ("Command failed: %s" % e, 500, [])) else: break
def delete_org(self): """ Uses sfdx force:org:delete to delete the org """ if not self.created: self.logger.info( "Skipping org deletion: the scratch org has not been created") return command = sarge.shell_format("sfdx force:org:delete -p -u {0}", self.username) self.logger.info( "Deleting scratch org with command {}".format(command)) p = sarge.Command(command, stdout=sarge.Capture(buffer_size=-1), shell=True) p.run() org_info = None stdout = [] for line in p.stdout: stdout.append(line) if line.startswith("An error occurred deleting this org"): self.logger.error(line) else: self.logger.info(line) if p.returncode: message = "Failed to delete scratch org: \n{}".format( "".join(stdout)) raise ScratchOrgException(message) # Flag that this org has been created self.config["created"] = False self.config["username"] = None
def executeCommand(command, logger): timeSleeping = 0.5 #if shutdown send message to plugin if action == "reboot" or action == "shutdown": eventManager().fire(Events.SHUTTING_DOWN, {'status': action}) timeSleeping = 1 time.sleep( timeSleeping ) #add a small delay to make sure the response is sent try: p = sarge.run(command, stderr=sarge.Capture()) if p.returncode != 0: returncode = p.returncode stderr_text = p.stderr.text logger.warn( "Command failed with return code %i: %s" % (returncode, stderr_text)) if action == "reboot" or action == "shutdown": eventManager().fire( Events.SHUTTING_DOWN, {'status': None}) else: logger.info("Command executed sucessfully") except Exception, e: logger.warn("Command failed: %s" % e) if command == "reboot" or command == "shutdown": eventManager().fire(Events.SHUTTING_DOWN, {'status': None})
def delete_org(self): """ Uses sfdx force:org:delete to create the org """ if not self.created: self.logger.info( 'Skipping org deletion: the scratch org has not been created') return command = 'sfdx force:org:delete -p -u {}'.format(self.username) self.logger.info( 'Deleting scratch org with command {}'.format(command)) p = sarge.Command(command, stdout=sarge.Capture(buffer_size=-1)) p.run() org_info = None stdout = [] for line in p.stdout: stdout.append(line) if line.startswith('An error occurred deleting this org'): self.logger.error(line) else: self.logger.info(line) if p.returncode: message = 'Failed to delete scratch org: \n{}'.format( ''.join(stdout)) raise ScratchOrgException(message) # Flag that this org has been created self.config['created'] = False self.config['username'] = None
def remove_cref(tex, cwd): """ """ sty_file = cwd+'/dynlearn.sty' # add poorman to cleveref import cref_regex1 = (r'usepackage\{cleveref\}', r'usepackage[poorman]{cleveref}') cref_regex2 = (r'usepackage\[(\w*)\]\{cleveref\}', r'usepackage[\g<1>,poorman]{cleveref}') with open(sty_file) as dynlearn: source = dynlearn.read() for exp, repl in [cref_regex1, cref_regex2]: source = re.sub(exp, repl, source) with open(sty_file, 'w') as dynlearn: dynlearn.write(source) # generate and run the sed script compile_tex(tex, cwd) sed_cmd = sarge.shell_format("sed -f {0}.sed {0}.tex", tex.split('.')[0]) cleaned = RUN_CMD(sed_cmd, cwd=cwd, stdout=sarge.Capture()) with (pathlib.Path(cwd) / tex).open('w') as output: output.write(cleaned.stdout.text) # remove the cleveref import cref_regex3 = r'\\usepackage\[.*\]\{cleveref\}' comment_lines(sty_file, [cref_regex3])
def create_org(self): """ Uses heroku force:org:create to create the org """ if not self.config_file: # FIXME: raise exception return if not self.scratch_org_type: self.config['scratch_org_type'] = 'workspace' command = 'heroku force:org:create -t {} -f {}'.format( self.scratch_org_type, self.config_file) self.logger.info( 'Creating scratch org with command {}'.format(command)) p = sarge.Command(command, stdout=sarge.Capture(buffer_size=-1)) p.run() org_info = None re_obj = re.compile( 'Successfully created workspace org: (.+), username: (.+)') for line in p.stdout: match = re_obj.search(line) if match: self.config['org_id'] = match.group(1) self.config['username'] = match.group(2) self.logger.info(line) if p.returncode: # FIXME: raise exception raise ConfigError('Failed to create scratch org: {}'.format( '\n'.join(p.stdout))) # Flag that this org has been created self.config['created'] = True