def test_cwd_downturn():
"""change into directory"""
# setup
d1 = to_path('d1')
mkdir(d1)
# run test
bef = cwd()
with cd(d1):
aft = cwd()
delta = aft.relative_to(bef)
assert str(delta) == 'd1'
# cleanup
rm(d1)
def test_cwd_downturn():
"""change into directory"""
# setup
d1 = to_path("d1")
mkdir(d1)
# run test
bef = cwd()
with cd(d1):
aft = cwd()
delta = aft.relative_to(bef)
assert str(delta) == "d1"
# cleanup
rm(d1)
def run(cls, command, args, settings, options):
# read command line
cmdline = docopt(cls.USAGE, argv=[command] + args)
paths = cmdline['<path>']
archive = cmdline['--archive']
date = cmdline['--date']
# add cwd to paths
paths = [to_path(cwd(), p) for p in paths]
# assure that paths correspond to src_dirs
src_dirs = settings.src_dirs
unknown_path = False
# get the desired archive
if date and not archive:
archive = get_name_of_nearest_archive(settings, date)
if not archive:
archive = get_name_of_latest_archive(settings)
output('Archive:', archive)
# run borg
borg = settings.run_borg(
cmd='extract',
args=[settings.destination(archive)] + paths,
emborg_opts=options,
)
out = borg.stdout
if out:
output(out.rstrip())
def run_borg_raw(self, args):
# prepare the command
os.environ.update(self.publish_passcode())
os.environ["BORG_DISPLAY_PASSPHRASE"] = "no"
executable = self.value("borg_executable", BORG)
remote_path = self.value("remote_path")
remote_path = ["--remote-path", remote_path] if remote_path else []
repository = str(self.repository)
command = ([executable] + remote_path +
[a.replace('@repo', repository) for a in args])
# run the command
narrate("running:\n{}".format(
indent(render_command(command, borg_options_arg_count))))
with cd(self.working_dir):
narrate("running in:", cwd())
starts_at = arrow.now()
log("starts at: {!s}".format(starts_at))
borg = Run(command, modes="soeW", env=os.environ, log=False)
ends_at = arrow.now()
log("ends at: {!s}".format(ends_at))
log("elapsed = {!s}".format(ends_at - starts_at))
if borg.stdout:
narrate("Borg stdout:")
narrate(indent(borg.stdout))
if borg.stderr:
narrate("Borg stderr:")
narrate(indent(borg.stderr))
if borg.status:
narrate("Borg exit status:", borg.status)
return borg
def initialize():
with cd(tests_dir):
rm("configs .config .local repositories configs.symlink".split())
cp("CONFIGS", "configs")
mkdir(".config repositories .local".split())
ln("~/.local/bin", ".local/bin")
ln("~/.local/lib", ".local/lib")
ln("configs", "configs.symlink")
os.environ["HOME"] = str(cwd())
def test_cd_quoit():
"""change into directory"""
# setup
dot = cwd()
d1 = 'd1'
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = 'd1/f1'
touch(d1f1)
f1 = 'f1'
rm(f1)
# run test
with cd(d1):
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
assert str(dot) == str(cwd())
# clean up
rm(d1)
def test_cd_quoit():
"""change into directory"""
# setup
dot = cwd()
d1 = 'd1'
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = 'd1/f1'
touch(d1f1)
f1 = 'f1'
rm(f1)
# run test
with cd(d1):
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
assert str(dot) == str(cwd())
# clean up
rm(d1)
def test_cd_thinner():
"""change into directory"""
# setup
dot = cwd()
d1 = to_path("d1")
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = to_path("d1/f1")
touch(d1f1)
f1 = to_path("f1")
rm(f1)
# run test
with cd(d1):
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
assert str(dot) == str(cwd())
# clean up
rm(d1)
def test_cd_downturn():
"""change into directory"""
# setup
dot = cwd()
d1 = to_path('d1')
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = to_path('d1/f1')
touch(d1f1)
f1 = to_path('f1')
rm(f1)
# run test
cd(d1)
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
cd('..')
assert str(dot) == str(cwd())
# clean up
rm(d1)
def test_cd_downturn():
"""change into directory"""
# setup
dot = cwd()
d1 = to_path('d1')
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = to_path('d1/f1')
touch(d1f1)
f1 = to_path('f1')
rm(f1)
# run test
cd(d1)
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
cd('..')
assert str(dot) == str(cwd())
# clean up
rm(d1)
def test_cd_endorse():
"""change into directory"""
# setup
dot = cwd()
d1 = "d1"
mkdir(d1)
d1p = to_path(d1).resolve()
d1f1 = "d1/f1"
touch(d1f1)
f1 = "f1"
rm(f1)
# run test
cd(d1)
assert to_path(f1).is_file()
assert str(d1p) == str(cwd())
cd("..")
assert str(dot) == str(cwd())
# clean up
rm(d1)
def match(self, data, account, verbose=False):
try:
cwd = cwd()
for directory in self.dirs:
if cwd.samefile(to_path(directory)):
if verbose:
log(' %s: matches.' % self.get_name())
return self.script
except Exception as err:
raise Error(str(err), culprit=err.__class__.__name__)
if verbose:
log(' %s: no match.' % self.get_name())
def run(cls, command, args, settings, options):
# read command line
cmdline = docopt(cls.USAGE, argv=[command] + args)
paths = cmdline["<path>"]
archive = cmdline["--archive"]
date = cmdline["--date"]
borg_opts = []
if cmdline["--list"]:
borg_opts.append("--list")
if not cmdline["--force"]:
if cwd().samefile(settings.working_dir):
raise Error(
"Running from the working directory risks",
"over writing the existing file or files. ",
"Use --force if this is desired.",
wrap=True,
)
# convert absolute paths to paths relative to the working directory
paths = [to_path(p) for p in paths]
try:
paths = [
p.relative_to(settings.working_dir) if p.is_absolute() else p
for p in paths
]
except ValueError as e:
raise Error(e)
# get the desired archive
if date and not archive:
archive = get_name_of_nearest_archive(settings, date)
if not archive:
archive = get_name_of_latest_archive(settings)
output("Archive:", archive)
# run borg
borg = settings.run_borg(
cmd="extract",
borg_opts=borg_opts,
args=[settings.destination(archive)] + paths,
emborg_opts=options,
show_borg_output=bool(borg_opts),
)
out = borg.stdout
if out:
output(out.rstrip())
def run_borg_raw(self, args):
# run the run_before_borg commands
self.run_user_commands('run_before_borg')
# prepare the command
self.publish_passcode()
os.environ["BORG_DISPLAY_PASSPHRASE"] = "no"
executable = self.value("borg_executable", BORG)
remote_path = self.value("remote_path")
remote_path = ["--remote-path", remote_path] if remote_path else []
repository = str(self.repository)
command = ([executable] + remote_path +
[a.replace('@repo', repository) for a in args])
# run the command
narrate("running:\n{}".format(
indent(render_command(command, borg_options_arg_count))))
with cd(self.working_dir):
narrate("running in:", cwd())
starts_at = arrow.now()
log("starts at: {!s}".format(starts_at))
try:
borg = Run(command, modes="soeW1", env=os.environ, log=False)
except Error as e:
self.report_borg_error(e, executable)
ends_at = arrow.now()
log("ends at: {!s}".format(ends_at))
log("elapsed = {!s}".format(ends_at - starts_at))
if borg.status == 1:
warn('Warning emitted by Borg, see logfile for details.')
if borg.stdout:
narrate("Borg stdout:")
narrate(indent(borg.stdout))
if borg.stderr:
narrate("Borg stderr:")
narrate(indent(borg.stderr))
if borg.status:
narrate("Borg exit status:", borg.status)
return borg
def run_borg(
self,
cmd,
args=(),
borg_opts=None,
emborg_opts=(),
strip_prefix=False,
show_borg_output=False,
use_working_dir=False,
):
# prepare the command
os.environ.update(self.publish_passcode())
os.environ["BORG_DISPLAY_PASSPHRASE"] = "no"
if self.ssh_command:
os.environ["BORG_RSH"] = self.ssh_command
executable = self.value("borg_executable", BORG)
borg_opts = self.borg_options(cmd, borg_opts, emborg_opts,
strip_prefix)
command = [executable] + cmd.split() + borg_opts + args
environ = {
k: v
for k, v in os.environ.items() if k.startswith("BORG_")
}
if "BORG_PASSPHRASE" in environ:
environ["BORG_PASSPHRASE"] = "<redacted>"
narrate("Borg-related environment variables:", render(environ))
# check if ssh agent is present
if self.needs_ssh_agent:
if "SSH_AUTH_SOCK" not in os.environ:
warn(
"SSH_AUTH_SOCK environment variable not found.",
"Is ssh-agent running?",
)
# run the command
narrate("running:\n{}".format(
indent(render_command(command, borg_options_arg_count))))
with cd(self.working_dir if use_working_dir else "."):
narrate("running in:", cwd())
starts_at = arrow.now()
log("starts at: {!s}".format(starts_at))
narrating = (show_borg_output or "--verbose" in borg_opts
or "verbose" in emborg_opts or "narrate"
in emborg_opts) and "--json" not in command
if narrating:
modes = "soeW"
display("\nRunning Borg {} command ...".format(cmd))
else:
modes = "sOEW"
try:
borg = Run(command,
modes=modes,
stdin="",
env=os.environ,
log=False)
except Error as e:
e.reraise(culprit=f"borg {cmd}")
ends_at = arrow.now()
log("ends at: {!s}".format(ends_at))
log("elapsed = {!s}".format(ends_at - starts_at))
if borg.stdout:
narrate("Borg stdout:")
narrate(indent(borg.stdout))
if borg.stderr:
narrate("Borg stderr:")
narrate(indent(borg.stderr))
if borg.status:
narrate("Borg exit status:", borg.status)
return borg
def run_borg(
self,
cmd,
args=(),
borg_opts=None,
emborg_opts=(),
strip_prefix=False,
show_borg_output=False,
use_working_dir=False,
):
# run the run_before_borg commands
self.run_user_commands('run_before_borg')
# prepare the command
self.publish_passcode()
if "BORG_PASSPHRASE" in os.environ:
os.environ["BORG_DISPLAY_PASSPHRASE"] = "no"
if self.ssh_command:
os.environ["BORG_RSH"] = self.ssh_command
environ = {
k: v
for k, v in os.environ.items() if k.startswith("BORG_")
}
if "BORG_PASSPHRASE" in environ:
environ["BORG_PASSPHRASE"] = "<redacted>"
executable = self.value("borg_executable", BORG)
borg_opts = self.borg_options(cmd, borg_opts, emborg_opts,
strip_prefix)
command = [executable] + cmd.split() + borg_opts + args
narrate("Borg-related environment variables:", render(environ))
# check if ssh agent is present
if self.needs_ssh_agent:
if "SSH_AUTH_SOCK" not in os.environ:
warn(
"SSH_AUTH_SOCK environment variable not found.",
"Is ssh-agent running?",
)
# run the command
narrate("running:\n{}".format(
indent(render_command(command, borg_options_arg_count))))
with cd(self.working_dir if use_working_dir else "."):
narrate("running in:", cwd())
if "--json" in command or "--json-lines" in command:
narrating = False
else:
narrating = (show_borg_output or "--verbose" in borg_opts
or "--progress" in borg_opts
or "verbose" in emborg_opts
or "narrate" in emborg_opts)
if narrating:
modes = "soeW1"
display("\nRunning Borg {} command ...".format(cmd))
else:
modes = "sOEW1"
starts_at = arrow.now()
log("starts at: {!s}".format(starts_at))
try:
borg = Run(command,
modes=modes,
stdin="",
env=os.environ,
log=False)
except Error as e:
self.report_borg_error(e, cmd)
finally:
# remove passcode env variables created by emborg
if self.borg_passcode_env_var_set_by_emborg:
narrate(
f"Unsetting {self.borg_passcode_env_var_set_by_emborg}."
)
del os.environ[self.borg_passcode_env_var_set_by_emborg]
ends_at = arrow.now()
log("ends at: {!s}".format(ends_at))
log("elapsed = {!s}".format(ends_at - starts_at))
if borg.status:
narrate("Borg exit status:", borg.status)
if borg.status == 1 and borg.stderr:
warnings = borg.stderr.partition(72 * '-')[0]
warn('Warning emitted by Borg:', codicil=warnings)
if borg.stdout:
narrate("Borg stdout:")
narrate(indent(borg.stdout))
if borg.stderr:
narrate("Borg stderr:")
narrate(indent(borg.stderr))
return borg
