def p7zopen(cls, name, mode="r", fileobj=None): """Open 7z compressed cpio archive name for reading, writing. Appending is not allowed """ if len(mode) > 1 or mode not in "rw": raise ValueError, "mode must be 'r' or 'w'." pre, ext = os.path.splitext(name) pre = os.path.basename(pre) if ext == ".7z": ext = "" cpioname = pre + ext try: # To extract: 7z e -so <fname> # To create an archive: 7z a -si <fname> cmd = "7z %s -%s %s" % ({ 'r': 'e', 'w': 'a' }[mode], { 'r': 'so', 'w': 'si' }[mode], name) p = subprocess.Popen(cmd.split(), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) pobj = p.stdout if mode == "w": pobj = p.stdin comptype = "cpio" bufsize = 20 * 512 obj = _Stream(cpioname, mode, comptype, pobj, bufsize) t = cls.cpioopen(cpioname, mode, obj) except IOError: raise ReadError, "read/write via 7z failed" t._extfileobj = False return t
def testRemoveOfRunningExecutable(self): if util.get_canonical_os_type() != 'windows': return import pkg.portable.os_windows as os_windows cwd = os.getcwdu() exefilesrc = 'C:\\Windows\\system32\\more.com' self.assertTrue(os.path.exists(exefilesrc)) # create an image, copy an executable into it, # run the executable, remove the executable tdir1 = tempfile.mkdtemp() img1 = image.Image(tdir1, imgtype=image.IMG_USER, should_exist=False, user_provided_dir=True) img1.history.client_name = "pkg-test" img1.set_attrs(False, "test", origins=["http://localhost:10000"], refresh_allowed=False) exefile = os.path.join(tdir1, 'less.com') shutil.copyfile(exefilesrc, exefile) proc = subprocess.Popen([exefile], stdin=subprocess.PIPE) self.assertRaises(OSError, os.unlink, exefile) portable.remove(exefile) self.assertTrue(not os.path.exists(exefile)) proc.communicate() # Make sure that the moved executable gets deleted # This is a white-box test # To simulate running another process, we delete the cache # and call get_trashdir as if another file was being moved # to the trash. os_windows.cached_image_info = [] os_windows.get_trashdir(exefile) self.assertTrue(not os.path.exists( os.path.join(img1.imgdir, os_windows.trashname))) # cleanup os.chdir(cwd) shutil.rmtree(tdir1)
def __call(args, zone=None): # a way to invoke a separate executable for testing cmds_dir = DebugValues.get_value("smf_cmds_dir") if cmds_dir: args = (os.path.join(cmds_dir, args[0].lstrip("/")), ) + args[1:] if zone: cmd = DebugValues.get_value("bin_zlogin") if cmd is None: cmd = zlogin_path args = (cmd, zone) + args try: proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) buf = [misc.force_str(l) for l in proc.stdout.readlines()] ret = proc.wait() except OSError as e: raise RuntimeError("cannot execute {0}: {1}".format(args, e)) if ret != 0: raise NonzeroExitException(args, ret, buf) return buf
def __get_dates_of_creation(be_list): #zfs list -H -o creation rpool/ROOT/opensolaris-1 cmd = ["/sbin/zfs", "list", "-H", "-o", "creation"] for bee in be_list: if bee.get("orig_be_name"): name = bee.get("orig_be_name") pool = bee.get("orig_be_pool") cmd += [pool + "/ROOT/" + name] if len(cmd) <= 5: return None list_of_dates = [] try: proc = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) line_out = proc.stdout.readline() while line_out: list_of_dates.append(line_out) line_out = proc.stdout.readline() except OSError: return list_of_dates return list_of_dates
def __initial_start(self): if self.__state != self.HALTED: raise DepotStateException("Depot already starting or running") # XXX what about stdin and stdout redirection? args = self.get_args() if self.__network_ping(): raise DepotStateException("A depot (or some " + "other network process) seems to be " + "running on port %d already!" % self.__port) self.__state = self.STARTING self.__output = open(self.__logpath, "w", 0) self.__depot_handle = subprocess.Popen(args=args, stdin=subprocess.PIPE, stdout=self.__output, stderr=self.__output, close_fds=True) if self.__depot_handle == None: raise DepotStateException("Could not start Depot")
if x == 7: # ta requires a password to unlock cert, don't use continue fn = "{0}/ta{1:d}/ta{2:d}_cert.pem".format(output_dir, x, x) fhr = open(fn, "r") fhw.write(fhr.read()) fhr.close() fhw.close() # Create a certificate with an extension that Cryptography can't # understand. We can't do it by the OpenSSL CLI, but we can use a C # program that calls OpenSSL libraries to do it. os.chdir("../../../util/mkcert") cmdline = "./certgen" p = subprocess.Popen(cmdline, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) p.wait() output, error = p.communicate() if p.returncode == 127: print("certgen not found; execute 'make' in the mkcert " "directory first") sys.exit(p.returncode) elif p.returncode != 0: print("failed: {0} {1}".format(output, error)) sys.exit(p.returncode) # copy the generated cert files from util/mkcert to the ro_data area shutil.copy("cust_key.pem", "../../tests/ro_data/signing_certs/produced/keys/")
def check_firmware(self, dep_action, firmware_name): """Check firmware dependency. returns ((true, false, none (internal error)), error text)""" firmware_dir = "/usr/lib/fwenum" # leverage smf test infrastructure cmds_dir = DebugValues["smf_cmds_dir"] if DebugValues["firmware-dependency-bypass"]: return (True, None) if cmds_dir: # we're testing; firmware_dir = cmds_dir args = [os.path.join(firmware_dir, firmware_name[len("feature/firmware/"):])] args.extend([ "{0}={1}".format(k, quote_attr_value(v)) for k,v in sorted(six.iteritems(dep_action.attrs)) if k not in ["type", "root-image", "fmri"] ]) key = str(args) # use a cache since each check may be expensive and each # pkg version may have the same dependency. # ignore non-solaris systems here if portable.osname != "sunos" and key not in self.firmware: self.__firmware[key] = (True, None) if key not in self.__firmware: try: proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) # output from proc is bytes buf = [misc.force_str(l) for l in proc.stdout.readlines()] ret = proc.wait() # if there was output, something went wrong. # Since generic errors are often exit(1), # map this to an internal error. if ret == 1 and len(buf) > 0: ret = 255 if ret == 0: ans = (True, None) elif 0 < ret <= 239: ans = (False, (_("There are {0} instances" " of downrev firmware for the '{1}' " " devices present on this system. " "Update each to version {2} or better." ).format(ret, args[1], dep_action.attrs.get("minimum-version", _("UNSPECIFIED"))))) elif ret == 240: ans = (False, (_("There are 240 or more " "instances of downrev firmware for the" "'{0}' devices present on this system. " "Update each to version {1} or better." ).format(args[1], dep_action.attrs.get("minimum-version", _("UNSPECIFIED"))))) elif ret < 0: ans = (None, (_("Firmware dependency error: {0} " " exited due to signal {1}").format( " ".join(args), misc.signame(-ret)))) else: ans = (None, (_("Firmware dependency error: General " "internal error {0} running '{1}': '{2}'" ).format(str(ret), " ".join(args), "\n".join(buf)))) except OSError as e: # we have no enumerator installed. This can # occur if this driver is being installed # for the first time or, more likely, we # just added enumerators & a firmware dependency # for the first time. For now, drive on and # ignore this to permit the addition of such # dependencies concurrently with their # enumerarators. # ans = (None, (_("Firmware dependency error:" # " Cannot exec {0}: {1}").format(" ".join(args) # , str(e)))) ans = (True, 0) self.__firmware[key] = ans return self.__firmware[key]
http_proxy = get_http_proxy() if os.getenv(HTTP_PROXY_VARIABLE) == None: os.putenv(HTTP_PROXY_VARIABLE, http_proxy) if os.getenv(HTTPS_PROXY_VARIABLE) == None: os.putenv(HTTPS_PROXY_VARIABLE, http_proxy) # If /usr/bin/packagemanager was checked for instead, that would make # testing (especially automated) impossible for web links. allow_links = False args = sys.argv[1:] if args[0].find("packagemanager") != -1 and not portable.is_admin(): allow_links = True args.append("--allow-links") args = ["/usr/bin/gksu", " ".join(args)] proc = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True) # Reap the defunct gksu now rather than wait for kernel to do it. proc.wait() if not allow_links: # Nothing to do for other programs. sys.exit() # XXX PackageManager should not run as a privileged process! # This rather convoluted solution allows packagemanager to open links # as the original user that launched the packagemanager instead of as # a privileged user. It does this by using select to poll the output # of the packagemanager, and open links as it requests them. Once # the packagemanager has exited, the pipe is broken and pm-launch will # exit as well.