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         ("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", "r", "Display raw JSON data instead of parsed"),
 248         ("verify", "v", "Verify all hashes, instead of merely querying share presence"),
 249         ("repair", "r", "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", "r", "Display raw JSON data instead of parsed"),
 262         ("verify", "v", "Verify all hashes, instead of merely querying share presence"),
 263         ("repair", "r", "Automatically repair any problems found"),
 264         ]
 265     def parseArgs(self, where=''):
 266         self.where = where
 267
 268     def getSynopsis(self):
 269         return "%s deep-check [ALIAS:PATH]" % (os.path.basename(sys.argv[0]),)
 270
 271     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."""
 272
 273 subCommands = [
 274     ["mkdir", None, MakeDirectoryOptions, "Create a new directory"],
 275     ["add-alias", None, AddAliasOptions, "Add a new alias cap"],
 276     ["create-alias", None, CreateAliasOptions, "Create a new alias cap"],
 277     ["list-aliases", None, ListAliasOptions, "List all alias caps"],
 278     ["ls", None, ListOptions, "List a directory"],
 279     ["get", None, GetOptions, "Retrieve a file from the virtual drive."],
 280     ["put", None, PutOptions, "Upload a file into the virtual drive."],
 281     ["cp", None, CpOptions, "Copy one or more files."],
 282     ["rm", None, RmOptions, "Unlink a file or directory in the virtual drive."],
 283     ["mv", None, MvOptions, "Move a file within the virtual drive."],
 284     ["ln", None, LnOptions, "Make an additional link to an existing file."],
 285     ["backup", None, BackupOptions, "Make target dir look like local dir."],
 286     ["webopen", None, WebopenOptions, "Open a webbrowser to the root_dir"],
 287     ["manifest", None, ManifestOptions, "List all files/dirs in a subtree"],
 288     ["stats", None, StatsOptions, "Print statistics about all files/dirs in a subtree"],
 289     ["check", None, CheckOptions, "Check a single file or directory"],
 290     ["deep-check", None, DeepCheckOptions, "Check all files/directories reachable from a starting point"],
 291     ]
 292
 293 def mkdir(options):
 294     from allmydata.scripts import tahoe_mkdir
 295     rc = tahoe_mkdir.mkdir(options)
 296     return rc
 297
 298 def add_alias(options):
 299     from allmydata.scripts import tahoe_add_alias
 300     rc = tahoe_add_alias.add_alias(options)
 301     return rc
 302
 303 def create_alias(options):
 304     from allmydata.scripts import tahoe_add_alias
 305     rc = tahoe_add_alias.create_alias(options)
 306     return rc
 307
 308 def list_aliases(options):
 309     from allmydata.scripts import tahoe_add_alias
 310     rc = tahoe_add_alias.list_aliases(options)
 311     return rc
 312
 313 def list(options):
 314     from allmydata.scripts import tahoe_ls
 315     rc = tahoe_ls.list(options)
 316     return rc
 317
 318 def get(options):
 319     from allmydata.scripts import tahoe_get
 320     rc = tahoe_get.get(options)
 321     if rc == 0:
 322         if options.to_file is None:
 323             # be quiet, since the file being written to stdout should be
 324             # proof enough that it worked, unless the user is unlucky
 325             # enough to have picked an empty file
 326             pass
 327         else:
 328             print >>options.stderr, "%s retrieved and written to %s" % \
 329                   (options.from_file, options.to_file)
 330     return rc
 331
 332 def put(options):
 333     from allmydata.scripts import tahoe_put
 334     rc = tahoe_put.put(options)
 335     return rc
 336
 337 def cp(options):
 338     from allmydata.scripts import tahoe_cp
 339     rc = tahoe_cp.copy(options)
 340     return rc
 341
 342 def rm(options):
 343     from allmydata.scripts import tahoe_rm
 344     rc = tahoe_rm.rm(options)
 345     return rc
 346
 347 def mv(options):
 348     from allmydata.scripts import tahoe_mv
 349     rc = tahoe_mv.mv(options, mode="move")
 350     return rc
 351
 352 def ln(options):
 353     from allmydata.scripts import tahoe_mv
 354     rc = tahoe_mv.mv(options, mode="link")
 355     return rc
 356
 357 def backup(options):
 358     from allmydata.scripts import tahoe_backup
 359     rc = tahoe_backup.backup(options)
 360     return rc
 361
 362 def webopen(options, opener=None):
 363     from allmydata.scripts import tahoe_webopen
 364     rc = tahoe_webopen.webopen(options, opener=opener)
 365     return rc
 366
 367 def manifest(options):
 368     from allmydata.scripts import tahoe_manifest
 369     rc = tahoe_manifest.manifest(options)
 370     return rc
 371
 372 def stats(options):
 373     from allmydata.scripts import tahoe_manifest
 374     rc = tahoe_manifest.stats(options)
 375     return rc
 376
 377 def check(options):
 378     from allmydata.scripts import tahoe_check
 379     rc = tahoe_check.check(options)
 380     return rc
 381
 382 def deepcheck(options):
 383     from allmydata.scripts import tahoe_check
 384     rc = tahoe_check.deepcheck(options)
 385     return rc
 386
 387 dispatch = {
 388     "mkdir": mkdir,
 389     "add-alias": add_alias,
 390     "create-alias": create_alias,
 391     "list-aliases": list_aliases,
 392     "ls": list,
 393     "get": get,
 394     "put": put,
 395     "cp": cp,
 396     "rm": rm,
 397     "mv": mv,
 398     "ln": ln,
 399     "backup": backup,
 400     "webopen": webopen,
 401     "manifest": manifest,
 402     "stats": stats,
 403     "check": check,
 404     "deep-check": deepcheck,
 405     }
 406