src/allmydata/scripts/cli.py

   1
   2 import os.path, re, sys
   3 from twisted.python import usage
   4 from allmydata.scripts.common import BaseOptions, get_aliases
   5
   6 NODEURL_RE=re.compile("http://([^:]*)(:([1-9][0-9]*))?")
   7
   8 class VDriveOptions(BaseOptions, usage.Options):
   9     optParameters = [
  10         ["node-directory", "d", "~/.tahoe",
  11          "Look here to find out which Tahoe node should be used for all "
  12          "operations. The directory should either contain a full Tahoe node, "
  13          "or a file named node.url which points to some other Tahoe node. "
  14          "It should also contain a file named private/aliases which contains "
  15          "the mapping from alias name to root dirnode URI."
  16          ],
  17         ["node-url", "u", None,
  18          "URL of the tahoe node to use, a URL like \"http://127.0.0.1:3456\". "
  19          "This overrides the URL found in the --node-directory ."],
  20         ["dir-cap", None, None,
  21          "Which dirnode URI should be used as the 'tahoe' alias."]
  22         ]
  23
  24     def postOptions(self):
  25         # compute a node-url from the existing options, put in self['node-url']
  26         if self['node-directory']:
  27             if sys.platform == 'win32' and self['node-directory'] == '~/.tahoe':
  28                 from allmydata.windows import registry
  29                 self['node-directory'] = registry.get_base_dir_path()
  30             else:
  31                 self['node-directory'] = os.path.expanduser(self['node-directory'])
  32         if self['node-url']:
  33             if (not isinstance(self['node-url'], basestring)
  34                 or not NODEURL_RE.match(self['node-url'])):
  35                 msg = ("--node-url is required to be a string and look like "
  36                        "\"http://HOSTNAMEORADDR:PORT\", not: %r" %
  37                        (self['node-url'],))
  38                 raise usage.UsageError(msg)
  39         else:
  40             node_url_file = os.path.join(self['node-directory'], "node.url")
  41             self['node-url'] = open(node_url_file, "r").read().strip()
  42         if self['node-url'][-1] != "/":
  43             self['node-url'] += "/"
  44
  45         aliases = get_aliases(self['node-directory'])
  46         if self['dir-cap']:
  47             aliases["tahoe"] = self['dir-cap']
  48         self.aliases = aliases # maps alias name to dircap
  49
  50
  51 class MakeDirectoryOptions(VDriveOptions):
  52     def parseArgs(self, where=""):
  53         self.where = where
  54     longdesc = """Create a new directory, either unlinked or as a subdirectory."""
  55
  56 class AddAliasOptions(VDriveOptions):
  57     def parseArgs(self, alias, cap):
  58         self.alias = alias
  59         self.cap = cap
  60
  61 class CreateAliasOptions(VDriveOptions):
  62     def parseArgs(self, alias):
  63         self.alias = alias
  64
  65 class ListAliasOptions(VDriveOptions):
  66     pass
  67
  68 class ListOptions(VDriveOptions):
  69     optFlags = [
  70         ("long", "l", "Use long format: show file sizes, and timestamps"),
  71         ("uri", "u", "Show file/directory URIs"),
  72         ("readonly-uri", None, "Show readonly file/directory URIs"),
  73         ("classify", "F", "Append '/' to directory names, and '*' to mutable"),
  74         ("json", None, "Show the raw JSON output"),
  75         ]
  76     def parseArgs(self, where=""):
  77         self.where = where
  78
  79     longdesc = """List the contents of some portion of the virtual drive."""
  80
  81 class GetOptions(VDriveOptions):
  82     def parseArgs(self, arg1, arg2=None):
  83         # tahoe get FOO |less            # write to stdout
  84         # tahoe get tahoe:FOO |less      # same
  85         # tahoe get FOO bar              # write to local file
  86         # tahoe get tahoe:FOO bar        # same
  87
  88         self.from_file = arg1
  89         self.to_file = arg2
  90         if self.to_file == "-":
  91             self.to_file = None
  92
  93     def getSynopsis(self):
  94         return "%s get VDRIVE_FILE LOCAL_FILE" % (os.path.basename(sys.argv[0]),)
  95
  96     longdesc = """Retrieve a file from the virtual drive and write it to the
  97     local filesystem. If LOCAL_FILE is omitted or '-', the contents of the file
  98     will be written to stdout."""
  99
 100     def getUsage(self, width=None):
 101         t = VDriveOptions.getUsage(self, width)
 102         t += """
 103 Examples:
 104  % tahoe get FOO |less            # write to stdout
 105  % tahoe get tahoe:FOO |less      # same
 106  % tahoe get FOO bar              # write to local file
 107  % tahoe get tahoe:FOO bar        # same
 108 """
 109         return t
 110
 111 class PutOptions(VDriveOptions):
 112     optFlags = [
 113         ("mutable", "m", "Create a mutable file instead of an immutable one."),
 114         ]
 115
 116     def parseArgs(self, arg1=None, arg2=None):
 117         # cat FILE | tahoe put           # create unlinked file from stdin
 118         # cat FILE | tahoe put -         # same
 119         # tahoe put bar                  # create unlinked file from local 'bar'
 120         # cat FILE | tahoe put - FOO     # create tahoe:FOO from stdin
 121         # tahoe put bar FOO              # copy local 'bar' to tahoe:FOO
 122         # tahoe put bar tahoe:FOO        # same
 123
 124         if arg1 is not None and arg2 is not None:
 125             self.from_file = arg1
 126             self.to_file = arg2
 127         elif arg1 is not None and arg2 is None:
 128             self.from_file = arg1 # might be "-"
 129             self.to_file = None
 130         else:
 131             self.from_file = None
 132             self.to_file = None
 133         if self.from_file == "-":
 134             self.from_file = None
 135
 136     def getSynopsis(self):
 137         return "%s put LOCAL_FILE VDRIVE_FILE" % (os.path.basename(sys.argv[0]),)
 138
 139     longdesc = """Put a file into the virtual drive (copying the file's
 140     contents from the local filesystem). If VDRIVE_FILE is missing, upload
 141     the file but do not link it into a directory: prints the new filecap to
 142     stdout. If LOCAL_FILE is missing or '-', data will be copied from stdin.
 143     VDRIVE_FILE is assumed to start with tahoe: unless otherwise specified."""
 144
 145     def getUsage(self, width=None):
 146         t = VDriveOptions.getUsage(self, width)
 147         t += """
 148 Examples:
 149  % cat FILE | tahoe put                # create unlinked file from stdin
 150  % cat FILE | tahoe -                  # same
 151  % tahoe put bar                       # create unlinked file from local 'bar'
 152  % cat FILE | tahoe put - FOO          # create tahoe:FOO from stdin
 153  % tahoe put bar FOO                   # copy local 'bar' to tahoe:FOO
 154  % tahoe put bar tahoe:FOO             # same
 155  % tahoe put bar MUTABLE-FILE-WRITECAP # modify the mutable file in-place
 156 """
 157         return t
 158
 159 class CpOptions(VDriveOptions):
 160     optFlags = [
 161         ("recursive", "r", "Copy source directory recursively."),
 162         ("verbose", "v", "Be noisy about what is happening."),
 163         ]
 164     def parseArgs(self, *args):
 165         if len(args) < 2:
 166             raise usage.UsageError("cp requires at least two arguments")
 167         self.sources = args[:-1]
 168         self.destination = args[-1]
 169
 170 class RmOptions(VDriveOptions):
 171     def parseArgs(self, where):
 172         self.where = where
 173
 174     def getSynopsis(self):
 175         return "%s rm VE_FILE" % (os.path.basename(sys.argv[0]),)
 176
 177 class MvOptions(VDriveOptions):
 178     def parseArgs(self, frompath, topath):
 179         self.from_file = frompath
 180         self.to_file = topath
 181
 182     def getSynopsis(self):
 183         return "%s mv FROM TO" % (os.path.basename(sys.argv[0]),)
 184
 185 class LnOptions(VDriveOptions):
 186     def parseArgs(self, frompath, topath):
 187         self.from_file = frompath
 188         self.to_file = topath
 189
 190     def getSynopsis(self):
 191         return "%s ln FROM TO" % (os.path.basename(sys.argv[0]),)
 192
 193 class BackupOptions(VDriveOptions):
 194     optFlags = [
 195         ("verbose", "v", "Be noisy about what is happening."),
 196         ]
 197
 198     def parseArgs(self, localdir, topath):
 199         self.from_dir = localdir
 200         self.to_dir = topath
 201
 202     def getSynopsis(Self):
 203         return "%s backup FROM ALIAS:TO" % os.path.basename(sys.argv[0])
 204
 205     longdesc = """Add a versioned backup of the local FROM directory to a timestamped subdir of the (tahoe) TO/Archives directory, sharing as many files and directories as possible with the previous backup. Creates TO/Latest as a reference to the latest backup. Behaves somewhat like 'rsync -a --link-dest=TO/Archives/(previous) FROM TO/Archives/(new); ln -sf TO/Archives/(new) TO/Latest'."""
 206
 207 class WebopenOptions(VDriveOptions):
 208     def parseArgs(self, where=''):
 209         self.where = where
 210
 211     def getSynopsis(self):
 212         return "%s webopen [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 213
 214     longdesc = """Opens a webbrowser to the contents of some portion of the virtual drive."""
 215
 216 class ManifestOptions(VDriveOptions):
 217     optFlags = [
 218         ("storage-index", "s", "Only print storage index strings, not pathname+cap"),
 219         ("verify-cap", None, "Only print verifycap, not pathname+cap"),
 220         ("repair-cap", None, "Only print repaircap, not pathname+cap"),
 221         ("raw", "r", "Display raw JSON data instead of parsed"),
 222         ]
 223     def parseArgs(self, where=''):
 224         self.where = where
 225
 226     def getSynopsis(self):
 227         return "%s manifest [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 228
 229     longdesc = """Print a list of all files/directories reachable from the given starting point."""
 230
 231 class StatsOptions(VDriveOptions):
 232     optFlags = [
 233         ("raw", "r", "Display raw JSON data instead of parsed"),
 234         ]
 235     def parseArgs(self, where=''):
 236         self.where = where
 237
 238     def getSynopsis(self):
 239         return "%s stats [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 240
 241     longdesc = """Print statistics about of all files/directories reachable from the given starting point."""
 242
 243 class CheckOptions(VDriveOptions):
 244     optFlags = [
 245         ("raw", "r", "Display raw JSON data instead of parsed"),
 246         ("verify", "v", "Verify all hashes, instead of merely querying share presence"),
 247         ("repair", "r", "Automatically repair any problems found"),
 248         ]
 249     def parseArgs(self, where=''):
 250         self.where = where
 251
 252     def getSynopsis(self):
 253         return "%s check [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 254
 255     longdesc = """Check a single file or directory: count how many shares are available, verify their hashes. Optionally repair the file if any problems were found."""
 256
 257 class DeepCheckOptions(VDriveOptions):
 258     optFlags = [
 259         ("raw", "r", "Display raw JSON data instead of parsed"),
 260         ("verify", "v", "Verify all hashes, instead of merely querying share presence"),
 261         ("repair", "r", "Automatically repair any problems found"),
 262         ]
 263     def parseArgs(self, where=''):
 264         self.where = where
 265
 266     def getSynopsis(self):
 267         return "%s deep-check [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 268
 269     longdesc = """Check all files/directories reachable from the given starting point (which must be a directory), like 'tahoe check' but for multiple files. Optionally repair any problems found."""
 270
 271 subCommands = [
 272     ["mkdir", None, MakeDirectoryOptions, "Create a new directory"],
 273     ["add-alias", None, AddAliasOptions, "Add a new alias cap"],
 274     ["create-alias", None, CreateAliasOptions, "Create a new alias cap"],
 275     ["list-aliases", None, ListAliasOptions, "List all alias caps"],
 276     ["ls", None, ListOptions, "List a directory"],
 277     ["get", None, GetOptions, "Retrieve a file from the virtual drive."],
 278     ["put", None, PutOptions, "Upload a file into the virtual drive."],
 279     ["cp", None, CpOptions, "Copy one or more files."],
 280     ["rm", None, RmOptions, "Unlink a file or directory in the virtual drive."],
 281     ["mv", None, MvOptions, "Move a file within the virtual drive."],
 282     ["ln", None, LnOptions, "Make an additional link to an existing file."],
 283     ["backup", None, BackupOptions, "Make target dir look like local dir."],
 284     ["webopen", None, WebopenOptions, "Open a webbrowser to the root_dir"],
 285     ["manifest", None, ManifestOptions, "List all files/dirs in a subtree"],
 286     ["stats", None, StatsOptions, "Print statistics about all files/dirs in a subtree"],
 287     ["check", None, CheckOptions, "Check a single file or directory"],
 288     ["deep-check", None, DeepCheckOptions, "Check all files/directories reachable from a starting point"],
 289     ]
 290
 291 def mkdir(options):
 292     from allmydata.scripts import tahoe_mkdir
 293     rc = tahoe_mkdir.mkdir(options)
 294     return rc
 295
 296 def add_alias(options):
 297     from allmydata.scripts import tahoe_add_alias
 298     rc = tahoe_add_alias.add_alias(options)
 299     return rc
 300
 301 def create_alias(options):
 302     from allmydata.scripts import tahoe_add_alias
 303     rc = tahoe_add_alias.create_alias(options)
 304     return rc
 305
 306 def list_aliases(options):
 307     from allmydata.scripts import tahoe_add_alias
 308     rc = tahoe_add_alias.list_aliases(options)
 309     return rc
 310
 311 def list(options):
 312     from allmydata.scripts import tahoe_ls
 313     rc = tahoe_ls.list(options)
 314     return rc
 315
 316 def get(options):
 317     from allmydata.scripts import tahoe_get
 318     rc = tahoe_get.get(options)
 319     if rc == 0:
 320         if options.to_file is None:
 321             # be quiet, since the file being written to stdout should be
 322             # proof enough that it worked, unless the user is unlucky
 323             # enough to have picked an empty file
 324             pass
 325         else:
 326             print >>options.stderr, "%s retrieved and written to %s" % \
 327                   (options.from_file, options.to_file)
 328     return rc
 329
 330 def put(options):
 331     from allmydata.scripts import tahoe_put
 332     rc = tahoe_put.put(options)
 333     return rc
 334
 335 def cp(options):
 336     from allmydata.scripts import tahoe_cp
 337     rc = tahoe_cp.copy(options)
 338     return rc
 339
 340 def rm(options):
 341     from allmydata.scripts import tahoe_rm
 342     rc = tahoe_rm.rm(options)
 343     return rc
 344
 345 def mv(options):
 346     from allmydata.scripts import tahoe_mv
 347     rc = tahoe_mv.mv(options, mode="move")
 348     return rc
 349
 350 def ln(options):
 351     from allmydata.scripts import tahoe_mv
 352     rc = tahoe_mv.mv(options, mode="link")
 353     return rc
 354
 355 def backup(options):
 356     from allmydata.scripts import tahoe_backup
 357     rc = tahoe_backup.backup(options)
 358     return rc
 359
 360 def webopen(options, opener=None):
 361     from allmydata.scripts import tahoe_webopen
 362     rc = tahoe_webopen.webopen(options, opener=opener)
 363     return rc
 364
 365 def manifest(options):
 366     from allmydata.scripts import tahoe_manifest
 367     rc = tahoe_manifest.manifest(options)
 368     return rc
 369
 370 def stats(options):
 371     from allmydata.scripts import tahoe_manifest
 372     rc = tahoe_manifest.stats(options)
 373     return rc
 374
 375 def check(options):
 376     from allmydata.scripts import tahoe_check
 377     rc = tahoe_check.check(options)
 378     return rc
 379
 380 def deepcheck(options):
 381     from allmydata.scripts import tahoe_check
 382     rc = tahoe_check.deepcheck(options)
 383     return rc
 384
 385 dispatch = {
 386     "mkdir": mkdir,
 387     "add-alias": add_alias,
 388     "create-alias": create_alias,
 389     "list-aliases": list_aliases,
 390     "ls": list,
 391     "get": get,
 392     "put": put,
 393     "cp": cp,
 394     "rm": rm,
 395     "mv": mv,
 396     "ln": ln,
 397     "backup": backup,
 398     "webopen": webopen,
 399     "manifest": manifest,
 400     "stats": stats,
 401     "check": check,
 402     "deep-check": deepcheck,
 403     }
 404