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 VDRIVE_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         ("no-backupdb", None, "Do not use the SQLite-based backup-database (always upload all files)."),
 197         ("ignore-timestamps", None, "Do not use backupdb timestamps to decide if a local file is unchanged."),
 198         ]
 199
 200     def parseArgs(self, localdir, topath):
 201         self.from_dir = localdir
 202         self.to_dir = topath
 203
 204     def getSynopsis(Self):
 205         return "%s backup FROM ALIAS:TO" % os.path.basename(sys.argv[0])
 206
 207     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'."""
 208
 209 class WebopenOptions(VDriveOptions):
 210     def parseArgs(self, where=''):
 211         self.where = where
 212
 213     def getSynopsis(self):
 214         return "%s webopen [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 215
 216     longdesc = """Opens a webbrowser to the contents of some portion of the virtual drive."""
 217
 218 class ManifestOptions(VDriveOptions):
 219     optFlags = [
 220         ("storage-index", "s", "Only print storage index strings, not pathname+cap"),
 221         ("verify-cap", None, "Only print verifycap, not pathname+cap"),
 222         ("repair-cap", None, "Only print repaircap, not pathname+cap"),
 223         ("raw", "r", "Display raw JSON data instead of parsed"),
 224         ]
 225     def parseArgs(self, where=''):
 226         self.where = where
 227
 228     def getSynopsis(self):
 229         return "%s manifest [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 230
 231     longdesc = """Print a list of all files/directories reachable from the given starting point."""
 232
 233 class StatsOptions(VDriveOptions):
 234     optFlags = [
 235         ("raw", "r", "Display raw JSON data instead of parsed"),
 236         ]
 237     def parseArgs(self, where=''):
 238         self.where = where
 239
 240     def getSynopsis(self):
 241         return "%s stats [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 242
 243     longdesc = """Print statistics about of all files/directories reachable from the given starting point."""
 244
 245 class CheckOptions(VDriveOptions):
 246     optFlags = [
 247         ("raw", None, "Display raw JSON data instead of parsed"),
 248         ("verify", None, "Verify all hashes, instead of merely querying share presence"),
 249         ("repair", None, "Automatically repair any problems found"),
 250         ]
 251     def parseArgs(self, where=''):
 252         self.where = where
 253
 254     def getSynopsis(self):
 255         return "%s check [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 256
 257     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."""
 258
 259 class DeepCheckOptions(VDriveOptions):
 260     optFlags = [
 261         ("raw", None, "Display raw JSON data instead of parsed"),
 262         ("verify", None, "Verify all hashes, instead of merely querying share presence"),
 263         ("repair", None, "Automatically repair any problems found"),
 264         ("verbose", "v", "Be noisy about what is happening."),
 265         ]
 266     def parseArgs(self, where=''):
 267         self.where = where
 268
 269     def getSynopsis(self):
 270         return "%s deep-check [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 271
 272     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."""
 273
 274 subCommands = [
 275     ["mkdir", None, MakeDirectoryOptions, "Create a new directory"],
 276     ["add-alias", None, AddAliasOptions, "Add a new alias cap"],
 277     ["create-alias", None, CreateAliasOptions, "Create a new alias cap"],
 278     ["list-aliases", None, ListAliasOptions, "List all alias caps"],
 279     ["ls", None, ListOptions, "List a directory"],
 280     ["get", None, GetOptions, "Retrieve a file from the virtual drive."],
 281     ["put", None, PutOptions, "Upload a file into the virtual drive."],
 282     ["cp", None, CpOptions, "Copy one or more files."],
 283     ["rm", None, RmOptions, "Unlink a file or directory in the virtual drive."],
 284     ["mv", None, MvOptions, "Move a file within the virtual drive."],
 285     ["ln", None, LnOptions, "Make an additional link to an existing file."],
 286     ["backup", None, BackupOptions, "Make target dir look like local dir."],
 287     ["webopen", None, WebopenOptions, "Open a webbrowser to the root_dir"],
 288     ["manifest", None, ManifestOptions, "List all files/dirs in a subtree"],
 289     ["stats", None, StatsOptions, "Print statistics about all files/dirs in a subtree"],
 290     ["check", None, CheckOptions, "Check a single file or directory"],
 291     ["deep-check", None, DeepCheckOptions, "Check all files/directories reachable from a starting point"],
 292     ]
 293
 294 def mkdir(options):
 295     from allmydata.scripts import tahoe_mkdir
 296     rc = tahoe_mkdir.mkdir(options)
 297     return rc
 298
 299 def add_alias(options):
 300     from allmydata.scripts import tahoe_add_alias
 301     rc = tahoe_add_alias.add_alias(options)
 302     return rc
 303
 304 def create_alias(options):
 305     from allmydata.scripts import tahoe_add_alias
 306     rc = tahoe_add_alias.create_alias(options)
 307     return rc
 308
 309 def list_aliases(options):
 310     from allmydata.scripts import tahoe_add_alias
 311     rc = tahoe_add_alias.list_aliases(options)
 312     return rc
 313
 314 def list(options):
 315     from allmydata.scripts import tahoe_ls
 316     rc = tahoe_ls.list(options)
 317     return rc
 318
 319 def get(options):
 320     from allmydata.scripts import tahoe_get
 321     rc = tahoe_get.get(options)
 322     if rc == 0:
 323         if options.to_file is None:
 324             # be quiet, since the file being written to stdout should be
 325             # proof enough that it worked, unless the user is unlucky
 326             # enough to have picked an empty file
 327             pass
 328         else:
 329             print >>options.stderr, "%s retrieved and written to %s" % \
 330                   (options.from_file, options.to_file)
 331     return rc
 332
 333 def put(options):
 334     from allmydata.scripts import tahoe_put
 335     rc = tahoe_put.put(options)
 336     return rc
 337
 338 def cp(options):
 339     from allmydata.scripts import tahoe_cp
 340     rc = tahoe_cp.copy(options)
 341     return rc
 342
 343 def rm(options):
 344     from allmydata.scripts import tahoe_rm
 345     rc = tahoe_rm.rm(options)
 346     return rc
 347
 348 def mv(options):
 349     from allmydata.scripts import tahoe_mv
 350     rc = tahoe_mv.mv(options, mode="move")
 351     return rc
 352
 353 def ln(options):
 354     from allmydata.scripts import tahoe_mv
 355     rc = tahoe_mv.mv(options, mode="link")
 356     return rc
 357
 358 def backup(options):
 359     from allmydata.scripts import tahoe_backup
 360     rc = tahoe_backup.backup(options)
 361     return rc
 362
 363 def webopen(options, opener=None):
 364     from allmydata.scripts import tahoe_webopen
 365     rc = tahoe_webopen.webopen(options, opener=opener)
 366     return rc
 367
 368 def manifest(options):
 369     from allmydata.scripts import tahoe_manifest
 370     rc = tahoe_manifest.manifest(options)
 371     return rc
 372
 373 def stats(options):
 374     from allmydata.scripts import tahoe_manifest
 375     rc = tahoe_manifest.stats(options)
 376     return rc
 377
 378 def check(options):
 379     from allmydata.scripts import tahoe_check
 380     rc = tahoe_check.check(options)
 381     return rc
 382
 383 def deepcheck(options):
 384     from allmydata.scripts import tahoe_check
 385     rc = tahoe_check.deepcheck(options)
 386     return rc
 387
 388 dispatch = {
 389     "mkdir": mkdir,
 390     "add-alias": add_alias,
 391     "create-alias": create_alias,
 392     "list-aliases": list_aliases,
 393     "ls": list,
 394     "get": get,
 395     "put": put,
 396     "cp": cp,
 397     "rm": rm,
 398     "mv": mv,
 399     "ln": ln,
 400     "backup": backup,
 401     "webopen": webopen,
 402     "manifest": manifest,
 403     "stats": stats,
 404     "check": check,
 405     "deep-check": deepcheck,
 406     }
 407