def _loads(self, response): return bser.loads( response, False, value_encoding=self._value_encoding, value_errors=self._value_errors, )
def _resolvesockname(self): # if invoked via a trigger, watchman will set this env var; we # should use it unless explicitly set otherwise path = os.getenv("WATCHMAN_SOCK") if path: return SockPath(sockpath=path) cmd = [self.binpath, "--output-encoding=bser", "get-sockname"] try: args = dict(stdout=subprocess.PIPE, stderr=subprocess.PIPE) # noqa: C408 if os.name == "nt": # if invoked via an application with graphical user interface, # this call will cause a brief command window pop-up. # Using the flag STARTF_USESHOWWINDOW to avoid this behavior. startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW args["startupinfo"] = startupinfo p = subprocess.Popen(cmd, **args) except OSError as e: raise WatchmanError('"watchman" executable not in PATH (%s)', e) stdout, stderr = p.communicate() exitcode = p.poll() if exitcode: raise WatchmanError("watchman exited with code %d" % exitcode) result = bser.loads(stdout) if "error" in result: raise WatchmanError("get-sockname error: %s" % result["error"]) def get_path_result(name): value = result.get(name, None) if value is None: return None return value.decode(sys.getfilesystemencoding(), errors="surrogateescape") # sockname is always present sockpath = get_path_result("sockname") assert sockpath is not None return SockPath( # unix_domain and named_pipe are reported by newer versions # of the server and may not be present unix_domain=get_path_result("unix_domain"), named_pipe=get_path_result("named_pipe"), # sockname is always present sockpath=sockpath, )
def load(fp, mutable=True, value_encoding=None, value_errors=None): """Deserialize a BSER-encoded blob. @param fp: The file-object to deserialize. @type file: @param mutable: Whether to return mutable results. @type mutable: bool @param value_encoding: Optional codec to use to decode values. If unspecified or None, return values as bytestrings. @type value_encoding: str @param value_errors: Optional error handler for codec. 'strict' by default. The other most common argument is 'surrogateescape' on Python 3. If value_encoding is None, this is ignored. @type value_errors: str """ buf = ctypes.create_string_buffer(8192) SNIFF_BUFFER_SIZE = len(EMPTY_HEADER) header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) read_len = _read_bytes(fp, header) if read_len < len(header): return None total_len = bser.pdu_len(buf) if total_len > len(buf): ctypes.resize(buf, total_len) body = (ctypes.c_char * (total_len - len(header))).from_buffer( buf, len(header)) read_len = _read_bytes(fp, body) if read_len < len(body): raise RuntimeError("bser data ended early") return bser.loads( (ctypes.c_char * total_len).from_buffer(buf, 0), mutable, value_encoding, value_errors, )
def _resolvesockname(self): # if invoked via a trigger, watchman will set this env var; we # should use it unless explicitly set otherwise path = os.getenv("WATCHMAN_SOCK") if path: return path cmd = [self.binpath, "--output-encoding=bser", "get-sockname"] try: args = dict(stdout=subprocess.PIPE, stderr=subprocess.PIPE) # noqa: C408 if os.name == "nt": # if invoked via an application with graphical user interface, # this call will cause a brief command window pop-up. # Using the flag STARTF_USESHOWWINDOW to avoid this behavior. startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW args["startupinfo"] = startupinfo p = subprocess.Popen(cmd, **args) except OSError as e: raise WatchmanError('"watchman" executable not in PATH (%s)', e) stdout, stderr = p.communicate() exitcode = p.poll() if exitcode: raise WatchmanError("watchman exited with code %d" % exitcode) result = bser.loads(stdout) if "error" in result: raise WatchmanError("get-sockname error: %s" % result["error"]) return result["sockname"]