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