lib/bup/cmd/ftp.py

   1
   2 # For now, this completely relies on the assumption that the current
   3 # encoding (LC_CTYPE, etc.) is ASCII compatible, and that it returns
   4 # the exact same bytes from a decode/encode round-trip (or the reverse
   5 # (e.g. ISO-8859-1).
   6
   7 from __future__ import absolute_import, print_function
   8 import os, fnmatch, stat, sys
   9
  10 from bup import _helpers, options, git, shquote, ls, vfs
  11 from bup.compat import argv_bytes
  12 from bup.helpers import chunkyreader, log
  13 from bup.io import byte_stream, path_msg
  14 from bup.repo import LocalRepo
  15
  16
  17 repo = None
  18
  19 class OptionError(Exception):
  20     pass
  21
  22
  23 def do_ls(repo, pwd, args, out):
  24     pwd_str = b'/'.join(name for name, item in pwd) or b'/'
  25     try:
  26         opt = ls.opts_from_cmdline(args, onabort=OptionError, pwd=pwd_str)
  27     except OptionError as e:
  28         log('error: %s' % e)
  29         return None
  30     return ls.within_repo(repo, opt, out, pwd_str)
  31
  32
  33 def write_to_file(inf, outf):
  34     for blob in chunkyreader(inf):
  35         outf.write(blob)
  36
  37
  38 def _completer_get_subs(repo, line):
  39     (qtype, lastword) = shquote.unfinished_word(line)
  40     dir, name = os.path.split(lastword)
  41     dir_path = vfs.resolve(repo, dir or b'/')
  42     _, dir_item = dir_path[-1]
  43     if not dir_item:
  44         subs = tuple()
  45     else:
  46         subs = tuple(dir_path + (entry,)
  47                      for entry in vfs.contents(repo, dir_item)
  48                      if (entry[0] != b'.' and entry[0].startswith(name)))
  49     return qtype, lastword, subs
  50
  51
  52 _attempt_start = None
  53 _attempt_end = None
  54 def attempt_completion(text, start, end):
  55     global _attempt_start, _attempt_end
  56     _attempt_start = start
  57     _attempt_end = end
  58
  59 _last_line = None
  60 _last_res = None
  61 def enter_completion(text, iteration):
  62     global repo
  63     global _attempt_end
  64     global _last_line
  65     global _last_res
  66     try:
  67         line = _helpers.get_line_buffer()[:_attempt_end]
  68         if _last_line != line:
  69             _last_res = _completer_get_subs(repo, line)
  70             _last_line = line
  71         qtype, lastword, subs = _last_res
  72         if iteration < len(subs):
  73             path = subs[iteration]
  74             leaf_name, leaf_item = path[-1]
  75             res = vfs.try_resolve(repo, leaf_name, parent=path[:-1])
  76             leaf_name, leaf_item = res[-1]
  77             fullname = os.path.join(*(name for name, item in res))
  78             if stat.S_ISDIR(vfs.item_mode(leaf_item)):
  79                 ret = shquote.what_to_add(qtype, lastword, fullname + b'/',
  80                                           terminate=False)
  81             else:
  82                 ret = shquote.what_to_add(qtype, lastword, fullname,
  83                                           terminate=True) + b' '
  84             return text + ret
  85     except Exception as e:
  86         log('\n')
  87         try:
  88             import traceback
  89             traceback.print_tb(sys.exc_traceback)
  90         except Exception as e2:
  91             log('Error printing traceback: %s\n' % e2)
  92         log('\nError in completion: %s\n' % e)
  93     return None
  94
  95
  96 optspec = """
  97 bup ftp [commands...]
  98 """
  99
 100 def main(argv):
 101     o = options.Options(optspec)
 102     opt, flags, extra = o.parse_bytes(argv[1:])
 103
 104     git.check_repo_or_die()
 105
 106     global repo
 107
 108     sys.stdout.flush()
 109     out = byte_stream(sys.stdout)
 110     stdin = byte_stream(sys.stdin)
 111     repo = LocalRepo()
 112     pwd = vfs.resolve(repo, b'/')
 113     rv = 0
 114
 115     def inputiter(f):
 116         if os.isatty(f.fileno()):
 117             while 1:
 118                 prompt = b'bup %s> ' % (b'/'.join(name for name, item in pwd) or b'/', )
 119                 if hasattr(_helpers, 'readline'):
 120                     try:
 121                         yield _helpers.readline(prompt)
 122                     except EOFError:
 123                         print()  # Clear the line for the terminal's next prompt
 124                         break
 125                 else:
 126                     out.write(prompt)
 127                     out.flush()
 128                     read_line = f.readline()
 129                     if not read_line:
 130                         print('')
 131                         break
 132                     yield read_line
 133         else:
 134             for line in f:
 135                 yield line
 136
 137
 138     if extra:
 139         lines = (argv_bytes(arg) for arg in extra)
 140     else:
 141         if hasattr(_helpers, 'readline'):
 142             _helpers.set_completer_word_break_characters(b' \t\n\r/')
 143             _helpers.set_attempted_completion_function(attempt_completion)
 144             _helpers.set_completion_entry_function(enter_completion)
 145             if sys.platform.startswith('darwin'):
 146                 # MacOS uses a slightly incompatible clone of libreadline
 147                 _helpers.parse_and_bind(b'bind ^I rl_complete')
 148             _helpers.parse_and_bind(b'tab: complete')
 149         lines = inputiter(stdin)
 150
 151     for line in lines:
 152         if not line.strip():
 153             continue
 154         words = [word for (wordstart,word) in shquote.quotesplit(line)]
 155         cmd = words[0].lower()
 156         #log('execute: %r %r\n' % (cmd, parm))
 157         try:
 158             if cmd == b'ls':
 159                 do_ls(repo, pwd, words[1:], out)
 160                 out.flush()
 161             elif cmd == b'cd':
 162                 np = pwd
 163                 for parm in words[1:]:
 164                     res = vfs.resolve(repo, parm, parent=np)
 165                     _, leaf_item = res[-1]
 166                     if not leaf_item:
 167                         raise Exception('%s does not exist'
 168                                         % path_msg(b'/'.join(name for name, item
 169                                                              in res)))
 170                     if not stat.S_ISDIR(vfs.item_mode(leaf_item)):
 171                         raise Exception('%s is not a directory' % path_msg(parm))
 172                     np = res
 173                 pwd = np
 174             elif cmd == b'pwd':
 175                 if len(pwd) == 1:
 176                     out.write(b'/')
 177                 out.write(b'/'.join(name for name, item in pwd) + b'\n')
 178                 out.flush()
 179             elif cmd == b'cat':
 180                 for parm in words[1:]:
 181                     res = vfs.resolve(repo, parm, parent=pwd)
 182                     _, leaf_item = res[-1]
 183                     if not leaf_item:
 184                         raise Exception('%s does not exist' %
 185                                         path_msg(b'/'.join(name for name, item
 186                                                            in res)))
 187                     with vfs.fopen(repo, leaf_item) as srcfile:
 188                         write_to_file(srcfile, out)
 189                 out.flush()
 190             elif cmd == b'get':
 191                 if len(words) not in [2,3]:
 192                     rv = 1
 193                     raise Exception('Usage: get <filename> [localname]')
 194                 rname = words[1]
 195                 (dir,base) = os.path.split(rname)
 196                 lname = len(words) > 2 and words[2] or base
 197                 res = vfs.resolve(repo, rname, parent=pwd)
 198                 _, leaf_item = res[-1]
 199                 if not leaf_item:
 200                     raise Exception('%s does not exist' %
 201                                     path_msg(b'/'.join(name for name, item in res)))
 202                 with vfs.fopen(repo, leaf_item) as srcfile:
 203                     with open(lname, 'wb') as destfile:
 204                         log('Saving %s\n' % path_msg(lname))
 205                         write_to_file(srcfile, destfile)
 206             elif cmd == b'mget':
 207                 for parm in words[1:]:
 208                     dir, base = os.path.split(parm)
 209
 210                     res = vfs.resolve(repo, dir, parent=pwd)
 211                     _, dir_item = res[-1]
 212                     if not dir_item:
 213                         raise Exception('%s does not exist' % path_msg(dir))
 214                     for name, item in vfs.contents(repo, dir_item):
 215                         if name == b'.':
 216                             continue
 217                         if fnmatch.fnmatch(name, base):
 218                             if stat.S_ISLNK(vfs.item_mode(item)):
 219                                 deref = vfs.resolve(repo, name, parent=res)
 220                                 deref_name, deref_item = deref[-1]
 221                                 if not deref_item:
 222                                     raise Exception('%s does not exist' %
 223                                                     path_msg('/'.join(name for name, item
 224                                                                       in deref)))
 225                                 item = deref_item
 226                             with vfs.fopen(repo, item) as srcfile:
 227                                 with open(name, 'wb') as destfile:
 228                                     log('Saving %s\n' % path_msg(name))
 229                                     write_to_file(srcfile, destfile)
 230             elif cmd in (b'help', b'?'):
 231                 out.write(b'Commands: ls cd pwd cat get mget help quit\n')
 232                 out.flush()
 233             elif cmd in (b'quit', b'exit', b'bye'):
 234                 break
 235             else:
 236                 rv = 1
 237                 raise Exception('no such command %r' % cmd)
 238         except Exception as e:
 239             rv = 1
 240             log('error: %s\n' % e)
 241             raise
 242
 243     sys.exit(rv)