Python subprocess.PIPE() Examples
The following are code examples for showing how to use subprocess.PIPE(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.
Example 1
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 8 votes |
|
def check_sudo(self):
"""
Checks validity of sudo password
:return: True if valid False if invalid
"""
self.sudo_password = self.sudo_dialog.sudo_password.text()
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'whoami'], stdin=p1.stdout, stdout=subprocess.PIPE, encoding='utf-8', stderr=subprocess.PIPE)
p1.stdout.close()
output = p2.communicate()[0].strip()
p2.stdout.close()
if "root" in output:
self.sudo_dialog.close()
print('True')
return True
else:
error = QtWidgets.QErrorMessage(self.sudo_dialog)
error.showMessage("Invalid Password")
return False
except Exception as ex:
print('failed', ex)
self.sudo_password = None
Example 2
| Project: badge-o-matic Author: markuslindenberg File: online.py BSD 2-Clause "Simplified" License | 7 votes |
|
def main(): pdf = BytesIO() # Find all IPv6 addresses with global scope ips = [dict(a['attrs'])['IFA_ADDRESS'] for a in IPRoute().get_addr() if a['scope'] == 0 and a['family'] == 10] if ips: c = Canvas(pdf, pagesize=(PAGE_W, PAGE_H)) hello(c, 'http://[%s]/badge' % ips[0]) else: # ToDo: Legacy IP bild c = Canvas(pdf, pagesize=(PAGE_W, PAGE_H)) c.showPage() c.save() lpr = subprocess.Popen(['lpr', '-P', PRINTER], stdin=subprocess.PIPE) lpr.communicate(pdf.getvalue()) if lpr.returncode != 0: pass
Example 3
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 7 votes |
|
def enable_ipv6(self):
"""
Re-enables ipv6 system wide
"""
if self.sudo_password:
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'sysctl', '-w', 'net.ipv6.conf.all.disable_ipv6=0', '&&', 'sysctl', '-w', 'net.ipv6.conf.default.disable_ipv6=0'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR: disabling IPV6 failed", 2000)
else:
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.text_label.setText("<html><head/><body><p>VPN Network Manager requires <span style=\" font-weight:600;\">sudo</span> permissions in order to enable IPV6. Please input the <span style=\" font-weight:600;\">sudo</span> Password or run the program with elevated priveledges.</p></body></html>")
self.sudo_dialog.exec_()
if self.sudo_password:
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'sysctl', '-w', 'net.ipv6.conf.all.disable_ipv6=0', '&&', 'sysctl', '-w', 'net.ipv6.conf.default.disable_ipv6=0'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR: Enabling IPV6 failed", 2000)
Example 4
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 6 votes |
|
def get_interfaces(self):
"""
Gets current Network interfaces
:return: List of Network interfaces
"""
try:
output = subprocess.run(['nmcli', '--mode', 'tabular', '--terse', '--fields', 'TYPE,DEVICE', 'device', 'status'], stdout=subprocess.PIPE)
output.check_returncode()
lines = output.stdout.decode('utf-8').split('\n')
interfaces = []
for line in lines:
if line:
elements = line.strip().split(':')
if (elements[0] == 'wifi') or (elements[0] == 'ethernet'):
interfaces.append(elements[1])
return interfaces
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR Fetching interfaces")
Example 5
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 6 votes |
|
def disable_ipv6(self):
"""
Disables IPV6 system wide
"""
if self.sudo_password:
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'sysctl', '-w', 'net.ipv6.conf.all.disable_ipv6=1', '&&', 'sysctl', '-w', 'net.ipv6.conf.default.disable_ipv6=1'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR: disabling IPV6 failed", 2000)
else:
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.text_label.setText("<html><head/><body><p>VPN Network Manager requires <span style=\" font-weight:600;\">sudo</span> permissions in order to disable IPV6. Please input the <span style=\" font-weight:600;\">sudo</span> Password or run the program with elevated priveledges.</p></body></html>")
self.sudo_dialog.exec_()
if self.sudo_password:
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'sysctl', '-w', 'net.ipv6.conf.all.disable_ipv6=1', '&&', 'sysctl', '-w', 'net.ipv6.conf.default.disable_ipv6=0'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR: disabling IPV6 failed", 2000)
Example 6
| Project: fs_image Author: facebookincubator File: test_unshare.py MIT License | 6 votes |
|
def _popen_sleep_forever(self, unshare: Unshare):
# We need the ready signal to know when we've actually executed the
# payload -- otherwise, we might try to interact with it while we're
# still at `nsenter`.
proc = subprocess.Popen(nsenter_as_user(
unshare, 'bash', '-uec', 'echo ready $$ ; exec sleep infinity',
), stdout=subprocess.PIPE)
# Wait for the child to start
ready_and_pid = proc.stdout.readline().split(b' ')
self.assertEqual(b'ready', ready_and_pid[0])
proc.stdout.close() # `sudo` keeps stdout open, but will not write.
# Returning the PID lets us clean up the `sleep infinity` when it is
# not inside a PID namespace.
return proc, int(ready_and_pid[1])
Example 7
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 6 votes |
|
def test_boot_cmd_is_system_running(self):
ret = self._nspawn_in('bootable-systemd-os', [
'--boot',
# This needs to be root because we don't yet create a proper
# login session for non-privileged users when we execute commands.
# Systemctl will try and connect to the user session
# when it's run as non-root.
'--user=root',
'--',
'/usr/bin/systemctl', 'is-system-running', '--wait',
], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
# The assertions here are validating that the systemd instance inside
# the container completed its boot but *not* that it successfully
# started every service. This reason for this is that it's not
# a gauranteed property of the image build system that the image
# successfully boot systemd, but simply that systemd can be properly
# started and 'complete' a boot. The success of the boot is really
# something that can only be properly evaulated by unit tests for
# a specific image.
self.assertIn(ret.returncode, [0, 1], msg=ret.stderr.strip())
self.assertIn(ret.stdout.strip(),
[b'running', b'degraded'], msg=ret.stderr.strip())
# T48760757
# self.assertEqual(b'', ret.stderr)
Example 8
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 6 votes |
|
def test_boot_env_clean(self):
ret = self._nspawn_in('bootable-systemd-os', [
'--boot',
'--',
'/bin/env',
], stdout=subprocess.PIPE, check=True)
self.assertEqual(0, ret.returncode)
# Verify we aren't getting anything in from the outside we don't want
self.assertNotIn(b'BUCK_BUILD_ID', ret.stdout)
# Verify we get what we expect
self.assertIn(b'HOME', ret.stdout)
self.assertIn(b'PATH', ret.stdout)
self.assertIn(b'LOGNAME', ret.stdout)
self.assertIn(b'USER', ret.stdout)
self.assertIn(b'TERM', ret.stdout)
Example 9
| Project: fs_image Author: facebookincubator File: test_execute_installed.py MIT License | 6 votes |
|
def test_execute(self):
for print_ok in [
'/foo/bar/installed/print-ok',
'/foo/bar/installed/print-ok-too',
]:
ret = self._nspawn_in(
'exe-layer', [
# Workaround: When the test is compiled with LLVM
# profiling, then `print-ok` would try to write to
# `/default.profraw`, which is not permitted to the test
# user `nobody`. This would print errors to stderr and
# cause our assertion below to fail.
'env', 'LLVM_PROFILE_FILE=/tmp/default.profraw',
print_ok,
],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
)
self.assertEqual(b'ok\n', ret.stdout)
# systemd-nspawn >= 242 dumps out an error about capabilities when
# run in an environment that drops cap_sys_boot (such as the FB
# container runtime).
# T48760757
# self.assertEqual(b'', ret.stderr)
Example 10
| Project: fs_image Author: facebookincubator File: fs_utils.py MIT License | 6 votes |
|
def open_for_read_decompress(path):
'Wraps `open(path, "rb")` to add transparent `.zst` or `.gz` decompression.'
path = Path(path)
if path.endswith(b'.zst'):
decompress = 'zstd'
elif path.endswith(b'.gz') or path.endswith(b'.tgz'):
decompress = 'gzip'
else:
with open(path, 'rb') as f:
yield f
return
with subprocess.Popen([
decompress, '--decompress', '--stdout', path,
], stdout=subprocess.PIPE) as proc:
yield proc.stdout
check_popen_returncode(proc)
Example 11
| Project: autofff Author: ChiefGokhlayeh File: scanner.py MIT License | 6 votes |
|
def _preprocess_file(self, filename: str, cpp_path: str = 'cpp', cpp_args: str = '') -> str:
path_list = [cpp_path]
if isinstance(cpp_args, list):
path_list += cpp_args
elif cpp_args != '':
path_list += [cpp_args]
path_list += [filename]
try:
# Note the use of universal_newlines to treat all newlines
# as \n for Python's purpose
#
pipe = subprocess.Popen(path_list,
stdout=subprocess.PIPE,
universal_newlines=True)
text = pipe.communicate()[0]
except OSError as e:
raise RuntimeError("Unable to invoke 'cpp'. " +
'Make sure its path was passed correctly\n' +
('Original error: %s' % e))
filteredText = self.ignorePattern.sub('', text)
return filteredText
Example 12
| Project: pyblish-win Author: pyblish File: patchcheck.py GNU Lesser General Public License v3.0 | 6 votes |
|
def changed_files():
"""Get the list of changed or added files from the VCS."""
if os.path.isdir(os.path.join(SRCDIR, '.hg')):
vcs = 'hg'
cmd = 'hg status --added --modified --no-status'
if mq_patches_applied():
cmd += ' --rev qparent'
elif os.path.isdir('.svn'):
vcs = 'svn'
cmd = 'svn status --quiet --non-interactive --ignore-externals'
else:
sys.exit('need a checkout to get modified files')
st = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
try:
st.wait()
if vcs == 'hg':
return [x.decode().rstrip() for x in st.stdout]
else:
output = (x.decode().rstrip().rsplit(None, 1)[-1]
for x in st.stdout if x[0] in 'AM')
return set(path for path in output if os.path.isfile(path))
finally:
st.stdout.close()
Example 13
| Project: pyblish-win Author: pyblish File: os.py GNU Lesser General Public License v3.0 | 6 votes |
|
def popen4(cmd, mode="t", bufsize=-1):
"""Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
may be a sequence, in which case arguments will be passed directly to
the program without shell intervention (as with os.spawnv()). If 'cmd'
is a string it will be passed to the shell (as with os.system()). If
'bufsize' is specified, it sets the buffer size for the I/O pipes. The
file objects (child_stdin, child_stdout_stderr) are returned."""
import warnings
msg = "os.popen4 is deprecated. Use the subprocess module."
warnings.warn(msg, DeprecationWarning, stacklevel=2)
import subprocess
PIPE = subprocess.PIPE
p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
bufsize=bufsize, stdin=PIPE, stdout=PIPE,
stderr=subprocess.STDOUT, close_fds=True)
return p.stdin, p.stdout
Example 14
| Project: pyblish-win Author: pyblish File: test_sysconfig.py GNU Lesser General Public License v3.0 | 6 votes |
|
def test_customize_compiler_before_get_config_vars(self):
# Issue #21923: test that a Distribution compiler
# instance can be called without an explicit call to
# get_config_vars().
with open(TESTFN, 'w') as f:
f.writelines(textwrap.dedent('''\
from distutils.core import Distribution
config = Distribution().get_command_obj('config')
# try_compile may pass or it may fail if no compiler
# is found but it should not raise an exception.
rc = config.try_compile('int x;')
'''))
p = subprocess.Popen([str(sys.executable), TESTFN],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
outs, errs = p.communicate()
self.assertEqual(0, p.returncode, "Subprocess failed: " + outs)
Example 15
| Project: pyblish-win Author: pyblish File: test_gdb.py GNU Lesser General Public License v3.0 | 6 votes |
|
def run_gdb(*args, **env_vars):
"""Runs gdb in batch mode with the additional arguments given by *args.
Returns its (stdout, stderr)
"""
if env_vars:
env = os.environ.copy()
env.update(env_vars)
else:
env = None
# -nx: Do not execute commands from any .gdbinit initialization files
# (issue #22188)
base_cmd = ('gdb', '--batch', '-nx')
if (gdb_major_version, gdb_minor_version) >= (7, 4):
base_cmd += ('-iex', 'add-auto-load-safe-path ' + checkout_hook_path)
out, err = subprocess.Popen(base_cmd + args,
stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env,
).communicate()
return out, err
# Verify that "gdb" was built with the embedded python support enabled:
Example 16
| Project: pyblish-win Author: pyblish File: test_threading.py GNU Lesser General Public License v3.0 | 6 votes |
|
def test_join_nondaemon_on_shutdown(self):
# Issue 1722344
# Raising SystemExit skipped threading._shutdown
p = subprocess.Popen([sys.executable, "-c", """if 1:
import threading
from time import sleep
def child():
sleep(1)
# As a non-daemon thread we SHOULD wake up and nothing
# should be torn down yet
print "Woke up, sleep function is:", sleep
threading.Thread(target=child).start()
raise SystemExit
"""],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self.addCleanup(p.stdout.close)
self.addCleanup(p.stderr.close)
stdout, stderr = p.communicate()
self.assertEqual(stdout.strip(),
"Woke up, sleep function is: <built-in function sleep>")
stderr = re.sub(r"^\[\d+ refs\]", "", stderr, re.MULTILINE).strip()
self.assertEqual(stderr, "")
Example 17
| Project: pyblish-win Author: pyblish File: script_helper.py GNU Lesser General Public License v3.0 | 6 votes |
|
def _assert_python(expected_success, *args, **env_vars):
cmd_line = [sys.executable]
if not env_vars:
cmd_line.append('-E')
cmd_line.extend(args)
# Need to preserve the original environment, for in-place testing of
# shared library builds.
env = os.environ.copy()
env.update(env_vars)
p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env)
try:
out, err = p.communicate()
finally:
subprocess._cleanup()
p.stdout.close()
p.stderr.close()
rc = p.returncode
err = strip_python_stderr(err)
if (rc and expected_success) or (not rc and not expected_success):
raise AssertionError(
"Process return code is %d, "
"stderr follows:\n%s" % (rc, err.decode('ascii', 'ignore')))
return rc, out, err
Example 18
| Project: pyblish-win Author: pyblish File: test_winsound.py GNU Lesser General Public License v3.0 | 6 votes |
|
def _have_soundcard():
"""Return True iff this computer has a soundcard."""
global __have_soundcard_cache
if __have_soundcard_cache is None:
cscript_path = _get_cscript_path()
if cscript_path is None:
# Could not find cscript.exe to run our VBScript helper. Default
# to True: most computers these days *do* have a soundcard.
return True
check_script = os.path.join(os.path.dirname(__file__),
"check_soundcard.vbs")
p = subprocess.Popen([cscript_path, check_script],
stdout=subprocess.PIPE)
__have_soundcard_cache = not p.wait()
return __have_soundcard_cache
Example 19
| Project: badge-o-matic Author: markuslindenberg File: webapp.py BSD 2-Clause "Simplified" License | 5 votes |
|
def _print(pdfdata):
if app.config['DEBUG']:
app.logger.info('printing to /tmp/out.pdf')
open('/tmp/out.pdf', 'wb').write(pdfdata)
else:
lpr = subprocess.Popen(['lpr', '-P', PRINTER], stdin=subprocess.PIPE)
lpr.communicate(pdfdata)
Example 20
| Project: UrsaRobotics_SmartHome Author: stav98 File: speech_recogn.py GNU General Public License v3.0 | 5 votes |
|
def speakSpeechFromText(phrase):
if voice == 'ONLINE':
googleSpeechURL = getGoogleSpeechURL(phrase)
print(googleSpeechURL)
subprocess.call(["mplayer", "-af", "volume=5", googleSpeechURL], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#subprocess.Popen(["mplayer", "-really-quiet", googleSpeechURL], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
elif voice == 'OFFLINE':
subprocess.call(["espeak", "-vel+m5", "-s 130", phrase], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
Example 21
| Project: UrsaRobotics_SmartHome Author: stav98 File: speech_recogn.py GNU General Public License v3.0 | 5 votes |
|
def pubCommand(topic, msg):
subprocess.call(["mosquitto_pub", "-d", "-t", topic, "-m", msg], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
Example 22
| Project: UrsaRobotics_SmartHome Author: stav98 File: tts.py GNU General Public License v3.0 | 5 votes |
|
def speakSpeechFromText(phrase):
#Αν είναι ONLINE στέλνει ένα URL στην Google και αυτή επιστρέφει αρχείο ήχου, το οποίο παίζει με το Mplayer
if voice == 'ONLINE':
googleSpeechURL = getGoogleSpeechURL(phrase)
#print(googleSpeechURL) #Debug
subprocess.call(["mplayer", "-af", "volume=5", googleSpeechURL], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#subprocess.Popen(["mplayer", "-really-quiet", googleSpeechURL], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#Αν είναι OFFLINE τότε καλεί το espeak
elif voice == 'OFFLINE':
subprocess.call(["espeak", "-vel+m5", "-s 130", phrase], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#Για δημοσίευση εντολών
Example 23
| Project: UrsaRobotics_SmartHome Author: stav98 File: tts.py GNU General Public License v3.0 | 5 votes |
|
def pubCommand(topic, msg):
subprocess.call(["mosquitto_pub", "-d", "-t", topic, "-m", msg], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#Αν δεχθεί μήνυμα σε κάποιο topic που έχει κάνει subscribe
Example 24
| Project: UrsaRobotics_SmartHome Author: stav98 File: radio.py GNU General Public License v3.0 | 5 votes |
|
def play_radio():
global pid
with open(os.devnull, 'wb') as nul:
pid = subprocess.Popen(['mplayer', '-really-quiet', station], stdin=nul, stdout=subprocess.PIPE)
#pid = subprocess.Popen(['mplayer','-msglevel', 'all=4', station], stdin=nul, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
#Αν δεχθεί μήνυμα σε κάποιο topic που έχει κάνει subscribe
Example 25
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 5 votes |
|
def randomize_mac(self):
"""
Takes down network interface and brings it back with a new MAC Address
"""
try:
self.statusbar.showMessage("Randomizing MAC Address", 2000)
self.repaint()
output = subprocess.run(['nmcli', '--mode', 'tabular', '--terse', '--fields', 'TYPE,UUID', 'connection', 'show', '--active'], stdout=subprocess.PIPE)
output.check_returncode()
lines = output.stdout.decode('utf-8').split('\n')
for line in lines:
if line:
elements = line.strip().split(':')
uuid = elements[1]
connection_type = elements[0]
if type != 'vpn':
subprocess.run(['nmcli', 'connection', 'down', uuid])
subprocess.run(['nmcli', 'connection', 'modify', '--temporary', uuid, connection_type+'.cloned-mac-address', 'random'])
subprocess.run(['nmcli', 'connection', 'up', uuid])
self.statusbar.showMessage("Random MAC Address assigned", 2000)
self.write_conf()
self.repaint()
except subprocess.CalledProcessError:
self.statusbar.showMessage("ERROR: Randomizer failed", 2000)
self.repaint()
Example 26
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 5 votes |
|
def set_auto_connect(self):
"""
Generates auto_connect bash script and moves it to the NetworkManager
"""
self.config.read(self.conf_path)
interfaces = self.get_interfaces()
if interfaces:
interface_string = '|'.join(interfaces)
script =(
'#!/bin/bash\n\n'
'if [[ "$1" =~ ' + interface_string + ' ]] && [[ "$2" =~ up|connectivity-change ]]; then\n'
' nmcli con up id "' + self.generate_connection_name() + '"\n'
'fi\n'
)
try:
with open(os.path.join(self.scripts_path, 'auto_connect'), 'w') as auto_connect:
print(script, file=auto_connect)
except Exception as ex:
print(ex)
self.statusbar.showMessage("ERROR building script file")
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'mv', self.scripts_path + '/auto_connect', self.network_manager_path + 'auto_connect'], stdin=p1.stdout, stdout=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
p3 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p4 = subprocess.Popen(['sudo', '-S', 'chown', 'root:root', self.network_manager_path + 'auto_connect'], stdin=p3.stdout, stdout=subprocess.PIPE)
p3.stdout.close()
p4.stdout.close()
p5 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p6 = subprocess.Popen(['sudo', '-S', 'chmod', '744', self.network_manager_path + 'auto_connect'], stdin=p5.stdout, stdout=subprocess.PIPE)
p5.stdout.close()
p6.stdout.close()
self.config['SETTINGS']['auto_connect'] = 'True'
self.write_conf()
except Exception as ex:
print(ex)
Example 27
| Project: fs_image Author: facebookincubator File: demo_sendstreams.py MIT License | 5 votes |
|
def _populate_sendstream_dict(d):
d['build_start_time'] = _float_to_sec_nsec_tuple(time.time())
yield d
d['dump'] = subprocess.run(
['btrfs', 'receive', '--dump'],
input=d['sendstream'], stdout=subprocess.PIPE, check=True,
# split into lines to make the `pretty` output prettier
).stdout.rstrip(b'\n').split(b'\n')
d['build_end_time'] = _float_to_sec_nsec_tuple(time.time())
# Takes `path_in_repo` because this is part of the library interface, and
# thus must work in @mode/opt, and thus we cannot use `__file__` here.
Example 28
| Project: fs_image Author: facebookincubator File: rpm_metadata.py MIT License | 5 votes |
|
def _repo_query(
self,
db_path: Path,
package_name: str,
package_path: Path,
) -> "RpmMetadata":
query_args = [
"rpm",
"--query",
"--queryformat",
"'%{NAME}:%{epochnum}:%{VERSION}:%{RELEASE}'",
]
if db_path and package_name and (package_path is None):
query_args += ["--dbpath", db_path, package_name]
elif package_path and (db_path is None and package_name is None):
query_args += ["--package", package_path]
else:
raise ValueError(
"Must pass only (--dbpath and --package_name) or --package"
)
try:
result = subprocess.check_output(
query_args,
stderr=subprocess.PIPE,
).decode().strip("'\"")
except subprocess.CalledProcessError as e:
raise RuntimeError(f"Error querying RPM: {e.stdout}, {e.stderr}")
n, e, v, r = result.split(":")
return RpmMetadata(name=n, epoch=int(e), version=v, release=r)
# Returns 1 if the version of a is newer than b
# Returns 0 if the versions match
# Returns -1 if the version of a is older than b
#
# Referenced from:
# github.com/rpm-software-management/yum/blob/master/rpmUtils/miscutils.py
Example 29
| Project: fs_image Author: facebookincubator File: test_open_url.py MIT License | 5 votes |
|
def test_open_http_url(self):
with temp_dir() as server_dir:
hello_path = server_dir / 'hello'
with open(hello_path, 'w') as out_f:
out_f.write('world')
# First, check file:// URLs
with open_url(hello_path.file_url()) as in_f:
self.assertEqual(b'world', in_f.read())
# Now, http:// URLs
with subprocess.Popen([
sys.executable, '-c', '''
import http.server as hs
with hs.HTTPServer(('localhost', 0), hs.SimpleHTTPRequestHandler) as httpd:
print('http://{}:{}/'.format(*httpd.socket.getsockname()), flush=True)
httpd.serve_forever()
''',
], cwd=server_dir, stdout=subprocess.PIPE) as proc:
try:
with open_url(
proc.stdout.readline().decode().rstrip('\n') + 'hello'
) as in_f:
self.assertEqual(b'world', in_f.read())
finally:
proc.kill()
Example 30
| Project: fs_image Author: facebookincubator File: subvol_utils.py MIT License | 5 votes |
|
def _path_is_btrfs_subvol(path):
'Ensure that there is a btrfs subvolume at this path. As per @kdave at '
'https://stackoverflow.com/a/32865333'
# You'd think I could just `os.statvfs`, but no, not until Py3.7
# https://bugs.python.org/issue32143
fs_type = subprocess.run(
['stat', '-f', '--format=%T', path],
stdout=subprocess.PIPE,
).stdout.decode().strip()
ino = os.stat(path).st_ino
return fs_type == 'btrfs' and ino == 256
Example 31
| Project: fs_image Author: facebookincubator File: subvol_utils.py MIT License | 5 votes |
|
def run_as_root(
self, args, timeout=None, input=None, _subvol_exists=True,
check=True, **kwargs,
):
'''
Run a command against an image. IMPORTANT: You MUST wrap all image
paths with `Subvol.path`, see that function's docblock.
Mostly API-compatible with subprocess.run, except that:
- `check` defaults to True instead of False,
- `stdout` is redirected to stderr by default,
- `cwd` is prohibited.
'''
# IMPORTANT: Any logic that CAN go in popen_as_root, MUST go there.
if input:
assert 'stdin' not in kwargs
kwargs['stdin'] = subprocess.PIPE
with self.popen_as_root(
args, _subvol_exists=_subvol_exists, check=check, **kwargs,
) as proc:
stdout, stderr = proc.communicate(timeout=timeout, input=input)
return subprocess.CompletedProcess(
args=proc.args,
returncode=proc.returncode,
stdout=stdout,
stderr=stderr,
)
# Future: run_in_image()
# From here on out, every public method directly maps to the btrfs API.
# For now, we shell out, but in the future, we may talk to a privileged
# `btrfsutil` helper, or use `guestfs`.
Example 32
| Project: fs_image Author: facebookincubator File: test_subvol_utils.py MIT License | 5 votes |
|
def test_run_as_root_return(self):
args = ['bash', '-c', 'echo -n my out; echo -n my err >&2']
r = Subvol('/dev/null/no-such-dir').run_as_root(
args,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
_subvol_exists=False,
)
self.assertEqual(['sudo', 'TMP=', '--'] + args, r.args)
self.assertEqual(0, r.returncode)
self.assertEqual(b'my out', r.stdout)
self.assertEqual(b'my err', r.stderr)
Example 33
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_redirects(self):
cmd = ['--', 'sh', '-c', 'echo ohai && echo abracadabra >&2']
ret = self._nspawn_in(
'host', cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
)
self.assertEqual(b'ohai\n' + self.maybe_extra_ending, ret.stdout)
# stderr is not just a clean `abracadabra\n` because we don't
# suppress nspawn's debugging output, hence the 'assertIn'.
self.assertIn(b'abracadabra\n', ret.stderr)
# The same test with `--quiet` is much simpler.
ret = self._nspawn_in(
'host', ['--quiet'] + cmd,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
)
self.assertEqual(b'ohai\n', ret.stdout)
# Nspawn as of version 242 started dumping a message to stderr when
# trying to set capabilities that are not currently in the bounding
# set. In FB production, we drop `cap_sys_boot` and because we do that
# nspawn (as of version 242) will inform us of that this capability
# cannot be set. Since we don't drop `cap_sys_boot` in normal cases
# we need the 'assertIn' so that test can pass when not run in a
# container that drops `cap_sys_boot`.
# T48760757
self.assertIn(b'abracadabra\n', ret.stderr)
Example 34
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_logs_directory(self):
# The log directory is on by default.
ret = self._nspawn_in('host', [
'--', 'sh', '-c',
'touch /logs/foo && stat --format="%U %G %a" /logs && whoami',
], stdout=subprocess.PIPE)
self.assertEqual(0, ret.returncode)
self.assertEqual(
b'nobody nobody 755\nnobody\n' + self.maybe_extra_ending,
ret.stdout
)
# And the option prevents it from being created.
self.assertEqual(0, self._nspawn_in('host', [
'--no-logs-tmpfs', '--', 'test', '!', '-e', '/logs',
]).returncode)
Example 35
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_hostname(self):
ret = self._nspawn_in('host', [
'--hostname=test-host.com',
'--',
'/bin/hostname',
], stdout=subprocess.PIPE, check=True)
self.assertEqual(b'test-host.com\n', ret.stdout)
Example 36
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_tls_environment(self):
ret = self._nspawn_in('host', [
'--forward-tls-env', '--',
'printenv', 'THRIFT_TLS_KITTEH', 'UNENCRYPTED_KITTEH',
], stdout=subprocess.PIPE, check=False)
self.assertNotEqual(0, ret.returncode) # UNENCRYPTED_KITTEH is unset
self.assertEqual(b'meow\n' + self.maybe_extra_ending, ret.stdout)
Example 37
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_xar(self):
'Make sure that XAR binaries work in vanilla `buck run` containers'
ret = self._nspawn_in('host-hello-xar', [
'--', '/hello.xar',
], stdout=subprocess.PIPE, check=True)
self.assertEqual(b'hello world\n' + self.maybe_extra_ending, ret.stdout)
Example 38
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_mknod(self):
'CAP_MKNOD is dropped by our runtime.'
ret = self._nspawn_in('host', [
'--user', 'root', '--quiet', '--', 'mknod', '/foo', 'c', '1', '3',
], stderr=subprocess.PIPE, check=False)
self.assertNotEqual(0, ret.returncode)
# Note this should be `assertEquals`, but T48760757
self.assertIn(
b"mknod: '/foo': Operation not permitted\n", ret.stderr,
)
Example 39
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_boot_forward_fd(self):
with tempfile.TemporaryFile() as tf:
tf.write(b'hello')
tf.seek(0)
ret = self._nspawn_in('bootable-systemd-os', [
'--boot',
'--forward-fd', str(tf.fileno()),
'--',
'/usr/bin/sh',
'-c',
'/usr/bin/cat <&3 && /usr/bin/echo goodbye >&3',
], stdout=subprocess.PIPE, check=True)
self.assertEqual(b'hello', ret.stdout)
tf.seek(0)
self.assertEqual(b'hellogoodbye\n', tf.read())
Example 40
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_boot_unprivileged_user(self):
ret = self._nspawn_in('bootable-systemd-os', [
'--boot',
'--',
'/bin/whoami',
], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
self.assertEqual(0, ret.returncode)
self.assertEqual(b'nobody\n', ret.stdout)
self.assertEqual(b'', ret.stderr)
Example 41
| Project: fs_image Author: facebookincubator File: test_nspawn_in_subvol.py MIT License | 5 votes |
|
def test_boot_proc_results(self):
ret = self._nspawn_in('bootable-systemd-os', [
'--boot',
'--',
'/bin/true',
], stdout=subprocess.PIPE, check=True)
self.assertEqual(0, ret.returncode)
self.assertIsNotNone(ret.boot)
self.assertIsNotNone(ret.boot.returncode)
self.assertEqual(0, ret.boot.returncode)
self.assertIn(b'Welcome to', ret.boot.stdout)
self.assertIn(b'Reached target', ret.boot.stdout)
self.assertIn(b'Stopped target', ret.boot.stdout)
Example 42
| Project: fs_image Author: facebookincubator File: test_fs_utils.py MIT License | 5 votes |
|
def test_path_from_argparse(self):
res = subprocess.run([
sys.executable, '-c', 'import sys;print(repr(sys.argv[1]))',
_BAD_UTF,
], stdout=subprocess.PIPE)
# Demangle non-UTF bytes in the same way that `sys.argv` mangles them.
self.assertEqual(_BAD_UTF, Path.from_argparse(
ast.literal_eval(res.stdout.rstrip(b'\n').decode())
))
Example 43
| Project: fs_image Author: facebookincubator File: test_fs_utils.py MIT License | 5 votes |
|
def test_open_for_read_decompress(self):
# The goal is that our stream should be bigger than any buffers
# involved (so we get to test edge effects), but not so big that the
# test takes more than 1-2 seconds.
n_bytes = 12 << 20 # 12MiB
my_line = b'kitteh' * 700 + b'\n' # ~ 4KiB
for compress, ext in [('gzip', 'gz'), ('zstd', 'zst')]:
filename = 'kitteh.' + ext
with temp_dir() as td, open(td / filename, 'wb') as outf:
with subprocess.Popen(
[compress, '-'], stdin=subprocess.PIPE, stdout=outf,
) as proc:
for _ in range(n_bytes // len(my_line)):
proc.stdin.write(my_line)
check_popen_returncode(proc)
with open_for_read_decompress(td / filename) as infile:
for l in infile:
self.assertEqual(my_line, l)
# Test uncompressed
with temp_dir() as td:
with open(td / 'kitteh', 'wb') as outfile:
outfile.write(my_line + b'meow')
with open_for_read_decompress(td / 'kitteh') as infile:
self.assertEqual(my_line + b'meow', infile.read())
# Test decompression error
with temp_dir() as td:
with open(td / 'kitteh.gz', 'wb') as outfile:
outfile.write(my_line)
with self.assertRaises(subprocess.CalledProcessError), \
open_for_read_decompress(td / 'kitteh.gz') as infile:
infile.read()
Example 44
| Project: fs_image Author: facebookincubator File: test_send_fds_and_run.py MIT License | 5 votes |
|
def _run(argv):
env = os.environ
env.pop('SUDO_COMMAND', None) # So we can assert whether `sudo` was used
with send_fds_and_popen(
parse_opts(argv),
env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
) as proc:
stdout, stderr = proc.communicate()
return proc.returncode, stdout.decode(), stderr.decode()
Example 45
| Project: fs_image Author: facebookincubator File: package_image.py MIT License | 5 votes |
|
def package_full(self, subvol: Subvol, output_path: str, opts: _Opts):
with create_ro(output_path, 'wb') as outfile, subprocess.Popen(
['zstd', '--stdout'], stdin=subprocess.PIPE, stdout=outfile
) as zst, subvol.mark_readonly_and_write_sendstream_to_file(zst.stdin):
pass
check_popen_returncode(zst)
Example 46
| Project: PEAKachu Author: tbischler File: adaptive.py ISC License | 5 votes |
|
def _blockbuster_worker(self, blockbuster_path, replicon):
p = Popen(
["blockbuster.x", "-minBlockHeight", "10", "-print", "1",
"-distance", "1",
"{}/{}_sorted_reads_for_blockbuster.bed".format(
self._blockbuster_input_folder, replicon)], stdout=PIPE,
stderr=PIPE, universal_newlines=True)
output, error = p.communicate()
returncode = p.returncode
return {"output": output, "error": error, "returncode": returncode}
Example 47
| Project: incubator-spot Author: apache File: utils.py Apache License 2.0 | 5 votes |
|
def popen(cls, cmd, cwd=None, raises=False):
'''
Execute the given command string in a new process. Send data to stdin and
read data from stdout and stderr, until end-of-file is reached.
:param cls : The class as implicit first argument.
:param cwd : If it is set, then the child's current directory will be change
to `cwd` before it is executed.
:param raises : If ``True`` and stderr has data, it raises an ``OSError`` exception.
:returns : The output of the given command; pair of (stdout, stderr).
:rtype : ``tuple``
:raises OSError: If `raises` and stderr has data.
'''
parser = lambda x: [] if x == '' else [y.strip() for y in x.strip().split('\n')]
process = subprocess.Popen(cmd, shell=True, universal_newlines=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = process.communicate()
# .............................trim lines and remove the empty ones
_stdout = [x for x in parser(out) if bool(x)]
_stderr = [x for x in parser(err) if bool(x)]
if _stderr and raises:
raise OSError('\n'.join(_stderr))
return _stdout, _stderr
Example 48
| Project: godot-mono-builds Author: godotengine File: os_utils.py MIT License | 5 votes |
|
def source(script: str, cwd=None) -> dict:
popen_args = {}
if cwd is not None:
popen_args['cwd'] = cwd
import subprocess
proc = subprocess.Popen('bash -c \'source %s; env -0\'' % script, stdout=subprocess.PIPE, shell=True, **popen_args)
output = proc.communicate()[0]
return dict(line.split('=', 1) for line in output.decode().split('\x00') if line)
# Creates the directory if no other file or directory with the same path exists
Example 49
| Project: autofff Author: ChiefGokhlayeh File: scanner.py MIT License | 5 votes |
|
def _read_symbols(self, pathToObj: str) -> SymbolTable:
path_list = ['objdump', '-t']
path_list += [pathToObj]
try:
pipe = subprocess.Popen(path_list,
stdout=subprocess.PIPE,
universal_newlines=True)
text = pipe.communicate()[0]
matches = re.finditer(
r"(?P<object>.*):\s+file format.*\s+SYMBOL TABLE:\n(?P<symbols>(?:.+(\n|$))*)", text, re.MULTILINE)
tables = list()
for match in matches:
print(match)
objectFile = match.group('object') or pathToObj
symbols = match.group('symbols')
symMatch = re.search(
r"\*ABS\*\s+[0-9a-fA-F]*\s+(?P<source>.*)", symbols, re.MULTILINE)
sourceFile = symMatch.group('source')
fuNMatches = re.finditer(r"", symbols, re.MULTILINE)
tables.append(SymbolTable(objectFile, None))
print(objectFile)
print(sourceFile)
print(symbols)
except OSError as e:
raise RuntimeError("Unable to invoke 'readelf'. " +
'Make sure its path was passed correctly\n' +
('Original error: %s' % e))
Example 50
| Project: alfred-yubikey-otp Author: robertoriv File: yubi.py MIT License | 5 votes |
|
def execute(cmd_list):
new_env = os.environ.copy()
new_env['PATH'] = '/usr/local/bin:%s' % new_env['PATH']
cmd, err = subprocess.Popen(cmd_list,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=new_env).communicate()
if err:
return err
return cmd
Example 51
| Project: alfred-yubikey-otp Author: robertoriv File: yubi.py MIT License | 5 votes |
|
def touch(name):
new_env = os.environ.copy()
new_env['PATH'] = '/usr/local/bin:%s' % new_env['PATH']
process = subprocess.Popen(['ykman', 'oath', 'code', name], stdout=subprocess.PIPE, env=new_env)
counter = 0
for i in iter(process.stdout.readline,'b'):
code_search = re.search('(.*)((\d{6,8}))', i, re.IGNORECASE)
if code_search:
wf.add_item(
name,
'Copy %s to clipboard' % code_search.group(2).strip(),
arg=code_search.group(2).strip(),
icon=get_icon_for_service(name),
valid=True,
)
wf.send_feedback()
break
counter += 1
if counter == 3:
wf.add_item(
name,
'Timeout',
arg=name,
icon=get_icon_for_service(name),
valid=True,
)
wf.send_feedback()
break
process.kill()
Example 52
| Project: alfred-yubikey-otp Author: robertoriv File: workflow.py MIT License | 5 votes |
|
def _call_security(self, action, service, account, *args):
"""Call ``security`` CLI program that provides access to keychains.
May raise `PasswordNotFound`, `PasswordExists` or `KeychainError`
exceptions (the first two are subclasses of `KeychainError`).
:param action: The ``security`` action to call, e.g.
``add-generic-password``
:type action: ``unicode``
:param service: Name of the service.
:type service: ``unicode``
:param account: name of the account the password is for, e.g.
"Pinboard"
:type account: ``unicode``
:param password: the password to secure
:type password: ``unicode``
:param *args: list of command line arguments to be passed to
``security``
:type *args: `list` or `tuple`
:returns: ``(retcode, output)``. ``retcode`` is an `int`, ``output`` a
``unicode`` string.
:rtype: `tuple` (`int`, ``unicode``)
"""
cmd = ['security', action, '-s', service, '-a', account] + list(args)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, _ = p.communicate()
if p.returncode == 44: # password does not exist
raise PasswordNotFound()
elif p.returncode == 45: # password already exists
raise PasswordExists()
elif p.returncode > 0:
err = KeychainError('Unknown Keychain error : %s' % stdout)
err.retcode = p.returncode
raise err
return stdout.strip().decode('utf-8')
Example 53
| Project: phrydy Author: Josef-Friedrich File: versioneer.py MIT License | 5 votes |
|
def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
env=None):
"""Call the given command(s)."""
assert isinstance(commands, list)
p = None
for c in commands:
try:
dispcmd = str([c] + args)
# remember shell=False, so use git.cmd on windows, not just git
p = subprocess.Popen([c] + args, cwd=cwd, env=env,
stdout=subprocess.PIPE,
stderr=(subprocess.PIPE if hide_stderr
else None))
break
except EnvironmentError:
e = sys.exc_info()[1]
if e.errno == errno.ENOENT:
continue
if verbose:
print("unable to run %s" % dispcmd)
print(e)
return None, None
else:
if verbose:
print("unable to find command, tried %s" % (commands,))
return None, None
stdout = p.communicate()[0].strip()
if sys.version_info[0] >= 3:
stdout = stdout.decode()
if p.returncode != 0:
if verbose:
print("unable to run %s (error)" % dispcmd)
print("stdout was %s" % stdout)
return None, p.returncode
return stdout, p.returncode
Example 54
| Project: phrydy Author: Josef-Friedrich File: _version.py MIT License | 5 votes |
|
def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
env=None):
"""Call the given command(s)."""
assert isinstance(commands, list)
p = None
for c in commands:
try:
dispcmd = str([c] + args)
# remember shell=False, so use git.cmd on windows, not just git
p = subprocess.Popen([c] + args, cwd=cwd, env=env,
stdout=subprocess.PIPE,
stderr=(subprocess.PIPE if hide_stderr
else None))
break
except EnvironmentError:
e = sys.exc_info()[1]
if e.errno == errno.ENOENT:
continue
if verbose:
print("unable to run %s" % dispcmd)
print(e)
return None, None
else:
if verbose:
print("unable to find command, tried %s" % (commands,))
return None, None
stdout = p.communicate()[0].strip()
if sys.version_info[0] >= 3:
stdout = stdout.decode()
if p.returncode != 0:
if verbose:
print("unable to run %s (error)" % dispcmd)
print("stdout was %s" % stdout)
return None, p.returncode
return stdout, p.returncode
Example 55
| Project: pyblish-win Author: pyblish File: _launcher.py GNU Lesser General Public License v3.0 | 5 votes |
|
def main(root, program, args=None):
"""Command-line entry point
Arguments:
root (str): Directory from which executable is launched
program (str): Name of program, e.g. pyblish-qml
async (bool, optional): Run asynchronously, default is False
console (bool, optional): Run with console, default is False
args (list, optional): Additional arguments passed to program
"""
setup(root)
args = [sys.executable,
"-u", # Unbuffered, for outputting to stdout below
"-m", program] + args or []
CREATE_NO_WINDOW = 0x08000000
popen = subprocess.Popen(args,
creationflags=CREATE_NO_WINDOW,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
for line in iter(popen.stdout.readline, b""):
sys.stdout.write(line)
popen.communicate() # Block until done
Example 56
| Project: pyblish-win Author: pyblish File: patchcheck.py GNU Lesser General Public License v3.0 | 5 votes |
|
def mq_patches_applied():
"""Check if there are any applied MQ patches."""
cmd = 'hg qapplied'
st = subprocess.Popen(cmd.split(),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
try:
bstdout, _ = st.communicate()
return st.returncode == 0 and bstdout
finally:
st.stdout.close()
st.stderr.close()
Example 57
| Project: pyblish-win Author: pyblish File: imaplib.py GNU Lesser General Public License v3.0 | 5 votes |
|
def open(self, host = None, port = None):
"""Setup a stream connection.
This connection will be used by the routines:
read, readline, send, shutdown.
"""
self.host = None # For compatibility with parent class
self.port = None
self.sock = None
self.file = None
self.process = subprocess.Popen(self.command,
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
shell=True, close_fds=True)
self.writefile = self.process.stdin
self.readfile = self.process.stdout
Example 58
| Project: pyblish-win Author: pyblish File: os.py GNU Lesser General Public License v3.0 | 5 votes |
|
def popen2(cmd, mode="t", bufsize=-1):
"""Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
may be a sequence, in which case arguments will be passed directly to
the program without shell intervention (as with os.spawnv()). If 'cmd'
is a string it will be passed to the shell (as with os.system()). If
'bufsize' is specified, it sets the buffer size for the I/O pipes. The
file objects (child_stdin, child_stdout) are returned."""
import warnings
msg = "os.popen2 is deprecated. Use the subprocess module."
warnings.warn(msg, DeprecationWarning, stacklevel=2)
import subprocess
PIPE = subprocess.PIPE
p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
bufsize=bufsize, stdin=PIPE, stdout=PIPE,
close_fds=True)
return p.stdin, p.stdout
Example 59
| Project: pyblish-win Author: pyblish File: _pssunos.py GNU Lesser General Public License v3.0 | 5 votes |
|
def swap_memory():
sin, sout = cext.swap_mem()
# XXX
# we are supposed to get total/free by doing so:
# http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
# usr/src/cmd/swap/swap.c
# ...nevertheless I can't manage to obtain the same numbers as 'swap'
# cmdline utility, so let's parse its output (sigh!)
p = subprocess.Popen(['/usr/bin/env', 'PATH=/usr/sbin:/sbin:%s' %
os.environ['PATH'], 'swap', '-l', '-k'],
stdout=subprocess.PIPE)
stdout, stderr = p.communicate()
if PY3:
stdout = stdout.decode(sys.stdout.encoding)
if p.returncode != 0:
raise RuntimeError("'swap -l -k' failed (retcode=%s)" % p.returncode)
lines = stdout.strip().split('\n')[1:]
if not lines:
raise RuntimeError('no swap device(s) configured')
total = free = 0
for line in lines:
line = line.split()
t, f = line[-2:]
t = t.replace('K', '')
f = f.replace('K', '')
total += int(int(t) * 1024)
free += int(int(f) * 1024)
used = total - free
percent = usage_percent(used, total, _round=1)
return _common.sswap(total, used, free, percent,
sin * PAGE_SIZE, sout * PAGE_SIZE)
Example 60
| Project: pyblish-win Author: pyblish File: _pssunos.py GNU Lesser General Public License v3.0 | 5 votes |
|
def _get_unix_sockets(self, pid):
"""Get UNIX sockets used by process by parsing 'pfiles' output."""
# TODO: rewrite this in C (...but the damn netstat source code
# does not include this part! Argh!!)
cmd = "pfiles %s" % pid
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
if PY3:
stdout, stderr = [x.decode(sys.stdout.encoding)
for x in (stdout, stderr)]
if p.returncode != 0:
if 'permission denied' in stderr.lower():
raise AccessDenied(self.pid, self._name)
if 'no such process' in stderr.lower():
raise NoSuchProcess(self.pid, self._name)
raise RuntimeError("%r command error\n%s" % (cmd, stderr))
lines = stdout.split('\n')[2:]
for i, line in enumerate(lines):
line = line.lstrip()
if line.startswith('sockname: AF_UNIX'):
path = line.split(' ', 2)[2]
type = lines[i - 2].strip()
if type == 'SOCK_STREAM':
type = socket.SOCK_STREAM
elif type == 'SOCK_DGRAM':
type = socket.SOCK_DGRAM
else:
type = -1
yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
Example 61
| Project: pyblish-win Author: pyblish File: msvc9compiler.py GNU Lesser General Public License v3.0 | 5 votes |
|
def query_vcvarsall(version, arch="x86"):
"""Launch vcvarsall.bat and read the settings from its environment
"""
vcvarsall = find_vcvarsall(version)
interesting = set(("include", "lib", "libpath", "path"))
result = {}
if vcvarsall is None:
raise DistutilsPlatformError("Unable to find vcvarsall.bat")
log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
try:
stdout, stderr = popen.communicate()
if popen.wait() != 0:
raise DistutilsPlatformError(stderr.decode("mbcs"))
stdout = stdout.decode("mbcs")
for line in stdout.split("\n"):
line = Reg.convert_mbcs(line)
if '=' not in line:
continue
line = line.strip()
key, value = line.split('=', 1)
key = key.lower()
if key in interesting:
if value.endswith(os.pathsep):
value = value[:-1]
result[key] = removeDuplicates(value)
finally:
popen.stdout.close()
popen.stderr.close()
if len(result) != len(interesting):
raise ValueError(str(list(result.keys())))
return result
# More globals
Example 62
| Project: pyblish-win Author: pyblish File: regrtest.py GNU Lesser General Public License v3.0 | 5 votes |
|
def work():
# A worker thread.
try:
while True:
try:
test, args_tuple = next(pending)
except StopIteration:
output.put((None, None, None, None))
return
# -E is needed by some tests, e.g. test_import
popen = Popen(base_cmd + ['--slaveargs', json.dumps(args_tuple)],
stdout=PIPE, stderr=PIPE,
universal_newlines=True,
close_fds=(os.name != 'nt'))
stdout, stderr = popen.communicate()
# Strip last refcount output line if it exists, since it
# comes from the shutdown of the interpreter in the subcommand.
stderr = debug_output_pat.sub("", stderr)
stdout, _, result = stdout.strip().rpartition("\n")
if not result:
output.put((None, None, None, None))
return
result = json.loads(result)
output.put((test, stdout.rstrip(), stderr.rstrip(), result))
except BaseException:
output.put((None, None, None, None))
raise
Example 63
| Project: pyblish-win Author: pyblish File: test_threading.py GNU Lesser General Public License v3.0 | 5 votes |
|
def test_finalize_with_trace(self):
# Issue1733757
# Avoid a deadlock when sys.settrace steps into threading._shutdown
p = subprocess.Popen([sys.executable, "-c", """if 1:
import sys, threading
# A deadlock-killer, to prevent the
# testsuite to hang forever
def killer():
import os, time
time.sleep(2)
print 'program blocked; aborting'
os._exit(2)
t = threading.Thread(target=killer)
t.daemon = True
t.start()
# This is the trace function
def func(frame, event, arg):
threading.current_thread()
return func
sys.settrace(func)
"""],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self.addCleanup(p.stdout.close)
self.addCleanup(p.stderr.close)
stdout, stderr = p.communicate()
rc = p.returncode
self.assertFalse(rc == 2, "interpreted was blocked")
self.assertTrue(rc == 0,
"Unexpected error: " + repr(stderr))
Example 64
| Project: pyblish-win Author: pyblish File: test_threading.py GNU Lesser General Public License v3.0 | 5 votes |
|
def assertScriptHasOutput(self, script, expected_output):
p = subprocess.Popen([sys.executable, "-c", script],
stdout=subprocess.PIPE)
rc = p.wait()
data = p.stdout.read().decode().replace('\r', '')
self.assertEqual(rc, 0, "Unexpected error")
self.assertEqual(data, expected_output)
Example 65
| Project: pyblish-win Author: pyblish File: test_threading.py GNU Lesser General Public License v3.0 | 5 votes |
|
def test_recursion_limit(self):
# Issue 9670
# test that excessive recursion within a non-main thread causes
# an exception rather than crashing the interpreter on platforms
# like Mac OS X or FreeBSD which have small default stack sizes
# for threads
script = """if True:
import threading
def recurse():
return recurse()
def outer():
try:
recurse()
except RuntimeError:
pass
w = threading.Thread(target=outer)
w.start()
w.join()
print('end of main thread')
"""
expected_output = "end of main thread\n"
p = subprocess.Popen([sys.executable, "-c", script],
stdout=subprocess.PIPE)
stdout, stderr = p.communicate()
data = stdout.decode().replace('\r', '')
self.assertEqual(p.returncode, 0, "Unexpected error")
self.assertEqual(data, expected_output)
Example 66
| Project: pyblish-win Author: pyblish File: test_hash.py GNU Lesser General Public License v3.0 | 5 votes |
|
def get_hash(self, repr_, seed=None):
env = os.environ.copy()
if seed is not None:
env['PYTHONHASHSEED'] = str(seed)
else:
env.pop('PYTHONHASHSEED', None)
cmd_line = [sys.executable, '-c', self.get_hash_command(repr_)]
p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
env=env)
out, err = p.communicate()
out = test_support.strip_python_stderr(out)
return int(out.strip())
Example 67
| Project: pyblish-win Author: pyblish File: test_warnings.py GNU Lesser General Public License v3.0 | 5 votes |
|
def test_single_warning(self):
newenv = os.environ.copy()
newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
p = subprocess.Popen([sys.executable,
"-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
stdout=subprocess.PIPE, env=newenv)
self.assertEqual(p.communicate()[0], "['ignore::DeprecationWarning']")
self.assertEqual(p.wait(), 0)
Example 68
| Project: pyblish-win Author: pyblish File: test_warnings.py GNU Lesser General Public License v3.0 | 5 votes |
|
def test_comma_separated_warnings(self):
newenv = os.environ.copy()
newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning,"
"ignore::UnicodeWarning")
p = subprocess.Popen([sys.executable,
"-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
stdout=subprocess.PIPE, env=newenv)
self.assertEqual(p.communicate()[0],
"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
self.assertEqual(p.wait(), 0)
Example 69
| Project: pyblish-win Author: pyblish File: test_tcl.py GNU Lesser General Public License v3.0 | 5 votes |
|
def testLoadWithUNC(self):
# Build a UNC path from the regular path.
# Something like
# \\%COMPUTERNAME%\c$\python27\python.exe
fullname = os.path.abspath(sys.executable)
if fullname[1] != ':':
self.skipTest('unusable path: %r' % fullname)
unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'],
fullname[0],
fullname[3:])
with test_support.EnvironmentVarGuard() as env:
env.unset("TCL_LIBRARY")
cmd = '%s -c "import Tkinter; print Tkinter"' % (unc_name,)
try:
p = Popen(cmd, stdout=PIPE, stderr=PIPE)
except WindowsError as e:
if e.winerror == 5:
self.skipTest('Not permitted to start the child process')
else:
raise
out_data, err_data = p.communicate()
msg = '\n\n'.join(['"Tkinter.py" not in output',
'Command:', cmd,
'stdout:', out_data,
'stderr:', err_data])
self.assertIn('Tkinter.py', out_data, msg)
self.assertEqual(p.wait(), 0, 'Non-zero exit code')
Example 70
| Project: pyblish-win Author: pyblish File: script_helper.py GNU Lesser General Public License v3.0 | 5 votes |
|
def spawn_python(*args, **kwargs):
cmd_line = [sys.executable, '-E']
cmd_line.extend(args)
return subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
**kwargs)
Example 71
| Project: pyblish-win Author: pyblish File: test_xpickle.py GNU Lesser General Public License v3.0 | 5 votes |
|
def send_to_worker(self, python, obj, proto):
"""Bounce a pickled object through another version of Python.
This will pickle the object, send it to a child process where it will be
unpickled, then repickled and sent back to the parent process.
Args:
python: the name of the Python binary to start.
obj: object to pickle.
proto: pickle protocol number to use.
Returns:
The pickled data received from the child process.
"""
# Prevent the subprocess from picking up invalid .pyc files.
target = __file__
if target[-1] in ("c", "o"):
target = target[:-1]
data = self.module.dumps((proto, obj), proto)
worker = subprocess.Popen([python, target, "worker"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = worker.communicate(data)
if worker.returncode != 0:
raise RuntimeError(stderr)
return stdout
Example 72
| Project: pyblish-win Author: pyblish File: test_file2k.py GNU Lesser General Public License v3.0 | 5 votes |
|
def test_unicode(self):
import subprocess
def get_message(encoding, *code):
code = '\n'.join(code)
env = os.environ.copy()
env['PYTHONIOENCODING'] = encoding
process = subprocess.Popen([sys.executable, "-c", code],
stdout=subprocess.PIPE, env=env)
stdout, stderr = process.communicate()
self.assertEqual(process.returncode, 0)
return stdout
def check_message(text, encoding, expected):
stdout = get_message(encoding,
"import sys",
"sys.stdout.write(%r)" % text,
"sys.stdout.flush()")
self.assertEqual(stdout, expected)
# test the encoding
check_message(u'15\u20ac', "iso-8859-15", "15\xa4")
check_message(u'15\u20ac', "utf-8", '15\xe2\x82\xac')
check_message(u'15\u20ac', "utf-16-le", '1\x005\x00\xac\x20')
# test the error handler
check_message(u'15\u20ac', "iso-8859-1:ignore", "15")
check_message(u'15\u20ac', "iso-8859-1:replace", "15?")
check_message(u'15\u20ac', "iso-8859-1:backslashreplace", "15\\u20ac")
# test the buffer API
for objtype in ('buffer', 'bytearray'):
stdout = get_message('ascii',
'import sys',
r'sys.stdout.write(%s("\xe9"))' % objtype,
'sys.stdout.flush()')
self.assertEqual(stdout, "\xe9")
Example 73
| Project: pyblish-win Author: pyblish File: test_tools.py GNU Lesser General Public License v3.0 | 5 votes |
|
def pindent(self, source, *args):
proc = subprocess.Popen(
(sys.executable, self.script) + args,
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
universal_newlines=True)
out, err = proc.communicate(source)
self.assertIsNone(err)
return out
Example 74
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 4 votes |
|
def disable_auto_connect(self):
"""
Handles the enabling and disabling of auto-connect depending on UI state
Called everytime the auto-connect box is clicked
"""
self.config.read(self.conf_path)
if not self.auto_connect_box.isChecked() and not self.sudo_password and self.config.getboolean('SETTINGS', 'auto_connect'):
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.text_label.setText("<html><head/><body><p>VPN Network Manager requires <span style=\" font-weight:600;\">sudo</span> permissions in order to remove the auto-connect script from the Network Manager directory. Please input the <span style=\" font-weight:600;\">sudo</span> Password or run the program with elevated priveledges.</p></body></html>")
self.sudo_dialog.exec_()
if not self.sudo_password: # dialog was canceled
return False
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'rm', self.network_manager_path + 'auto_connect'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
self.config['SETTINGS']['auto_connect'] = 'False'
self.write_conf()
except Exception as ex:
print(ex)
elif not self.auto_connect_box.isChecked() and self.sudo_password and self.config.getboolean('SETTINGS', 'auto_connect'):
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'rm', self.network_manager_path + 'auto_connect'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
self.config['SETTINGS']['auto_connect'] = 'False'
self.write_conf()
except Exception as ex:
print(ex)
elif self.auto_connect_box.isChecked() and self.get_active_vpn() and self.sudo_password:
self.set_auto_connect()
elif self.auto_connect_box.isChecked() and self.get_active_vpn() and not self.sudo_password:
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.exec_()
if self.sudo_password:
self.set_auto_connect()
else:
self.auto_connect_box.setChecked(False)
return False
Example 75
| Project: NordVPN-NetworkManager-Gui Author: vfosterm File: nord_nm_gui.py GNU General Public License v3.0 | 4 votes |
|
def disable_kill_switch(self):
"""
Enables or disables Killswitch depending on UI state
Called everytime the Killswitch button is pressed
"""
if not self.killswitch_btn.isChecked() and not self.sudo_password and self.config.getboolean('SETTINGS', 'kill_switch'):
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.text_label.setText("<html><head/><body><p>VPN Network Manager requires <span style=\" font-weight:600;\">sudo</span> permissions in order to remove the kill switch script from the Network Manager directory. Please input the <span style=\" font-weight:600;\">sudo</span> Password or run the program with elevated priveledges.</p></body></html>")
self.sudo_dialog.exec_()
if not self.sudo_password: # dialog was canceled
self.killswitch_btn.setChecked(False)
return False
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'rm', self.network_manager_path + 'kill_switch'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
self.statusbar.showMessage('Kill switch disabled', 2000)
self.repaint()
self.config['SETTINGS']['kill_switch'] = 'False'
self.write_conf()
except subprocess.CalledProcessError:
self.statusbar.showMessage('ERROR disabling kill switch', 2000)
self.repaint()
elif not self.killswitch_btn.isChecked() and self.sudo_password and self.config.getboolean('SETTINGS', 'kill_switch'):
try:
p1 = subprocess.Popen(['echo', self.sudo_password], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
p2 = subprocess.Popen(['sudo', '-S', 'rm', self.network_manager_path + 'kill_switch'], stdin=p1.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p1.stdout.close()
p2.stdout.close()
self.statusbar.showMessage('Kill switch disabled', 2000)
self.repaint()
self.config['SETTINGS']['kill_switch'] = 'False'
self.write_conf()
except subprocess.CalledProcessError:
self.statusbar.showMessage('ERROR disabling kill switch', 2000)
self.repaint()
elif self.killswitch_btn.isChecked() and self.get_active_vpn() and self.sudo_password:
self.set_kill_switch()
elif self.killswitch_btn.isChecked() and self.get_active_vpn() and not self.sudo_password:
self.sudo_dialog = self.get_sudo()
self.sudo_dialog.text_label.setText("<html><head/><body><p>VPN Network Manager requires <span style=\" font-weight:600;\">sudo</span> permissions in order to move the kill switch script to the Network Manager directory. Please input the <span style=\" font-weight:600;\">sudo</span> Password or run the program with elevated priveledges.</p></body></html>")
self.sudo_dialog.exec_()
if self.sudo_password:
self.set_kill_switch()
else:
self.killswitch_btn.setChecked(False)
return False
Example 76
| Project: fs_image Author: facebookincubator File: subvol_utils.py MIT License | 4 votes |
|
def _send_to_loopback_if_fits(
self,
output_path,
fs_size_bytes,
subvol_opts: SubvolOpts
) -> bool:
'''
Creates a loopback of the specified size, and sends the current
subvolume to it. Returns True if the subvolume fits in that space.
'''
open(output_path, 'wb').close()
with pipe() as (r_send, w_send), \
Unshare([Namespace.MOUNT, Namespace.PID]) as ns, \
LoopbackVolume(ns, output_path, fs_size_bytes) as loop_vol, \
self.mark_readonly_and_write_sendstream_to_file(w_send):
w_send.close() # This end is now fully owned by `btrfs send`.
with r_send:
recv_ret = run_stdout_to_err(nsenter_as_root(
ns, 'btrfs', 'receive', loop_vol.dir(),
), stdin=r_send, stderr=subprocess.PIPE)
if recv_ret.returncode != 0:
if recv_ret.stderr.endswith(self._OUT_OF_SPACE_SUFFIX):
return False
# It's pretty lame to rely on `btrfs receive` continuing
# to be unlocalized, and emitting that particular error
# message, so we fall back to checking available bytes.
size_ret = subprocess.run(nsenter_as_user(
ns, 'findmnt', '--noheadings', '--bytes',
'--output', 'AVAIL', loop_vol.dir(),
), stdout=subprocess.PIPE)
# If the `findmnt` fails, don't mask the original error.
if size_ret.returncode == 0 and int(size_ret.stdout) == 0:
return False
# Covering this is hard, so the test plan is "inspection".
log.error( # pragma: no cover
'Unhandled receive stderr:\n\n' +
recv_ret.stderr.decode(errors='surrogateescape'),
)
recv_ret.check_returncode()
if not subvol_opts.readonly:
sub_name = os.path.basename(self.path())
subvol_path = os.path.join(loop_vol.dir(), sub_name)
run_stdout_to_err(nsenter_as_root(
ns, 'btrfs', 'property', 'set', '-ts', subvol_path,
'ro', 'false',
)).check_returncode()
loop_vol.minimize_size()
return True
Example 77
| Project: fs_image Author: facebookincubator File: phases_provide.py MIT License | 4 votes |
|
def provides(self):
protected_paths = protected_path_set(self.subvol)
for prot_path in protected_paths:
yield ProvidesDoNotAccess(path=prot_path)
provided_root = False
# Traverse the subvolume as root, so that we have permission to
# access everything.
for type_and_path in self.subvol.run_as_root([
# -P is the analog of --no-dereference in GNU tools
#
# Filter out the protected paths at traversal time. If one of
# the paths has a very large or very slow mount, traversing it
# would have a devastating effect on build times, so let's avoid
# looking inside protected paths entirely. An alternative would
# be to `send` and to parse the sendstream, but this is ok too.
'find', '-P', self.subvol.path(), '(', *itertools.dropwhile(
lambda x: x == '-o', # Drop the initial `-o`
itertools.chain.from_iterable([
# `normpath` removes the trailing / for protected dirs
'-o', '-path', self.subvol.path(os.path.normpath(p))
] for p in protected_paths),
), ')', '-prune', '-o', '-printf', '%y %p\\0',
], stdout=subprocess.PIPE).stdout.split(b'\0'):
if not type_and_path: # after the trailing \0
continue
filetype, abspath = type_and_path.decode().split(' ', 1)
relpath = os.path.relpath(abspath, self.subvol.path().decode())
# We already "provided" this path above, and it should have been
# filtered out by `find`.
assert not is_path_protected(relpath, protected_paths), relpath
# Future: This provides all symlinks as files, while we should
# probably provide symlinks to valid directories inside the
# image as directories to be consistent with SymlinkToDirItem.
if filetype in ['b', 'c', 'p', 'f', 'l', 's']:
yield ProvidesFile(path=relpath)
elif filetype == 'd':
yield ProvidesDirectory(path=relpath)
else: # pragma: no cover
raise AssertionError(f'Unknown {filetype} for {abspath}')
if relpath == '.':
assert filetype == 'd'
provided_root = True
assert provided_root, 'subvolume {} lacks /'.format(self.subvol.path())
Example 78
| Project: dcos-proxy Author: dparrish File: build-config.py Apache License 2.0 | 4 votes |
|
def main(argv):
try:
old_config = None
while True:
params = {
'vhosts': {},
}
s = requests.Session()
apps = json.loads(s.get('http://master.mesos:8080/v2/apps').text)
for app in apps['apps']:
try:
vhost = app['labels']['VIRTUAL_HOST']
except KeyError:
continue
tasks = json.loads(s.get('http://master.mesos:8080/v2/apps%s/tasks' % app['id'],
headers={'Accept': 'application/json'}).text)
backends = []
for task in tasks['tasks']:
try:
ip = socket.gethostbyname(task['host'])
except socket.gaierror:
print "Can't look up host %s" % task['host']
continue
backends.append('%s:%s' % (ip, task['ports'][0]))
if backends:
params['vhosts'][vhost] = {
'backends': backends,
}
template = Template(TEMPLATE)
new_config = template.render(params)
if new_config != old_config:
with file('/etc/nginx/sites-available/default', 'w') as fh:
fh.write(new_config)
test = subprocess.Popen(['/usr/sbin/nginx', '-t'], stderr=subprocess.PIPE)
output = test.communicate()
if test.returncode != 0:
if old_config:
print 'Error generating new NGINX configuration, not reloading'
return
else:
raise RuntimeError('Error generating NGINX configuration')
subprocess.call(['/usr/sbin/nginx', '-s', 'reload'])
old_config = new_config
time.sleep(10)
except KeyboardInterrupt:
return 1
Example 79
| Project: pyblish-win Author: pyblish File: platform.py GNU Lesser General Public License v3.0 | 4 votes |
|
def _syscmd_file(target,default=''):
""" Interface to the system's file command.
The function uses the -b option of the file command to have it
ommit the filename in its output and if possible the -L option
to have the command follow symlinks. It returns default in
case the command should fail.
"""
# We do the import here to avoid a bootstrap issue.
# See c73b90b6dadd changeset.
#
# [..]
# ranlib libpython2.7.a
# gcc -o python \
# Modules/python.o \
# libpython2.7.a -lsocket -lnsl -ldl -lm
# Traceback (most recent call last):
# File "./setup.py", line 8, in <module>
# from platform import machine as platform_machine
# File "[..]/build/Lib/platform.py", line 116, in <module>
# import sys,string,os,re,subprocess
# File "[..]/build/Lib/subprocess.py", line 429, in <module>
# import select
# ImportError: No module named select
import subprocess
if sys.platform in ('dos','win32','win16','os2'):
# XXX Others too ?
return default
target = _follow_symlinks(target)
try:
proc = subprocess.Popen(['file', target],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except (AttributeError,os.error):
return default
output = proc.communicate()[0]
rc = proc.wait()
if not output or rc:
return default
else:
return output
### Information about the used architecture
# Default values for architecture; non-empty strings override the
# defaults given as parameters
Example 80
| Project: pyblish-win Author: pyblish File: test_sysconfig.py GNU Lesser General Public License v3.0 | 4 votes |
|
def test_platform_in_subprocess(self):
my_platform = sysconfig.get_platform()
# Test without MACOSX_DEPLOYMENT_TARGET in the environment
env = os.environ.copy()
if 'MACOSX_DEPLOYMENT_TARGET' in env:
del env['MACOSX_DEPLOYMENT_TARGET']
with open('/dev/null', 'w') as devnull_fp:
p = subprocess.Popen([
sys.executable, '-c',
'import sysconfig; print(sysconfig.get_platform())',
],
stdout=subprocess.PIPE,
stderr=devnull_fp,
env=env)
test_platform = p.communicate()[0].strip()
test_platform = test_platform.decode('utf-8')
status = p.wait()
self.assertEqual(status, 0)
self.assertEqual(my_platform, test_platform)
# Test with MACOSX_DEPLOYMENT_TARGET in the environment, and
# using a value that is unlikely to be the default one.
env = os.environ.copy()
env['MACOSX_DEPLOYMENT_TARGET'] = '10.1'
p = subprocess.Popen([
sys.executable, '-c',
'import sysconfig; print(sysconfig.get_platform())',
],
stdout=subprocess.PIPE,
stderr=open('/dev/null'),
env=env)
test_platform = p.communicate()[0].strip()
test_platform = test_platform.decode('utf-8')
status = p.wait()
self.assertEqual(status, 0)
self.assertEqual(my_platform, test_platform)
