def magic_folder_invite(node_directory, alias, nickname, treq): """ Invite a user identified by the nickname to a folder owned by the alias :param unicode node_directory: The root of the Tahoe-LAFS node. :param unicode alias: The alias of the folder to which the invitation is being generated. :param unicode nickname: The nickname of the invitee. :param HTTPClient treq: An ``HTTPClient`` or similar object to use to make the queries. :return Deferred[unicode]: A secret invitation code. """ aliases = get_aliases(node_directory)[alias] nodeurl = get_node_url(node_directory) node_url = DecodedURL.from_text(unicode(nodeurl, 'utf-8')) # create an unlinked directory and get the dmd write-cap dmd_write_cap = yield tahoe_mkdir(node_url, treq) # derive a dmd read-only cap from it. dmd_readonly_cap = uri.from_string( dmd_write_cap).get_readonly().to_string() if dmd_readonly_cap is None: raise Exception("failed to diminish dmd write cap") # Now, we need to create a link to the nickname from inside the # collective to this read-cap. For that we will need to know # the write-cap of the collective (which is stored by the private/aliases # file in the node_directory) so that a link can be created inside it # to the . # To do that, we use tahoe ln dmd_read_cap <collective-write-cap>/<alias> magic_write_cap = get_aliases(node_directory)[alias] magic_readonly_cap = uri.from_string( magic_write_cap).get_readonly().to_string() # tahoe ln CLIENT_READCAP COLLECTIVE_WRITECAP/NICKNAME from_file = unicode(dmd_readonly_cap, 'utf-8') to_file = u"%s/%s" % (unicode(magic_write_cap, 'utf-8'), nickname) try: yield tahoe_mv(node_url, aliases, from_file, to_file, treq) except Exception: raise # return invite code, which is: # magic_readonly_cap + INVITE_SEPARATOR + dmd_write_cap invite_code = "{}{}{}".format(magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap) returnValue(invite_code)
def _done((rc,stdout,stderr)): self.failUnlessEqual(rc, 0, stdout + stderr) self.failUnlessIn("Alias 'magic' created", stdout) self.failUnlessEqual(stderr, "") aliases = get_aliases(self.get_clientdir(i=client_num)) self.failUnlessIn("magic", aliases) self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
def postOptions(self): self["quiet"] = self.parent["quiet"] if self.parent['node-directory']: self['node-directory'] = argv_to_abspath(self.parent['node-directory']) else: self['node-directory'] = _default_nodedir # compute a node-url from the existing options, put in self['node-url'] if self['node-url']: if (not isinstance(self['node-url'], basestring) or not NODEURL_RE.match(self['node-url'])): msg = ("--node-url is required to be a string and look like " "\"http://HOSTNAMEORADDR:PORT\", not: %r" % (self['node-url'],)) raise usage.UsageError(msg) else: node_url_file = os.path.join(self['node-directory'], "node.url") self['node-url'] = open(node_url_file, "r").read().strip() if self['node-url'][-1] != "/": self['node-url'] += "/" aliases = get_aliases(self['node-directory']) if self['dir-cap']: aliases[DEFAULT_ALIAS] = self['dir-cap'] self.aliases = aliases # maps alias name to dircap
def _done(args): (rc, stdout, stderr) = args self.assertEqual(stderr, "") self.assertIn("Alias 'tahoe' created", stdout) aliases = get_aliases(self.get_clientdir()) self.failUnless("tahoe" in aliases) self.failUnless(aliases["tahoe"].startswith("URI:DIR2:"))
def __init__(self, app_cont): self.app_cont = app_cont self.nodedir = app_cont.nodedir self.load_config() self.mounted_filesystems = {} self.aliases = get_aliases(self.nodedir) wx.App.__init__(self)
def test_list_unicode_mismatch_json(self): """ pretty hack-y test, but we want to cover the 'except' on Unicode errors paths and I can't come up with a nicer way to trigger this """ self.basedir = "cli/ListAlias/test_list_unicode_mismatch_json" skip_if_cannot_represent_argv(u"tahoe\u263A") self.set_up_grid(oneshare=True) rc, stdout, stderr = yield self.do_cli( "create-alias", unicode_to_argv(u"tahoe\u263A"), ) self.failUnless(unicode_to_argv(u"Alias 'tahoe\u263A' created") in stdout) self.failIf(stderr) booms = [] def boom(out, indent=4): if not len(booms): booms.append(out) raise UnicodeEncodeError("foo", u"foo", 3, 5, "foo") return str(out) with patch("allmydata.scripts.tahoe_add_alias.json.dumps", boom): aliases = get_aliases(self.get_clientdir()) self.failUnless(u"tahoe\u263A" in aliases) self.failUnless(aliases[u"tahoe\u263A"].startswith("URI:DIR2:")) rc, stdout, stderr = yield self.do_cli("list-aliases", "--json") self.assertEqual(1, rc) self.assertIn("could not be converted", stderr)
def test_list_unicode_mismatch(self): self.basedir = "cli/ListAlias/test_list_unicode_mismatch" skip_if_cannot_represent_argv(u"tahoe\u263A") self.set_up_grid(oneshare=True) rc, stdout, stderr = yield self.do_cli( "create-alias", unicode_to_argv(u"tahoe\u263A"), ) def boom(out): print("boom {}".format(out)) return out raise UnicodeEncodeError("foo", u"foo", 3, 5, "foo") with patch("allmydata.scripts.tahoe_add_alias.unicode_to_output", boom): self.failUnless(unicode_to_argv(u"Alias 'tahoe\u263A' created") in stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless(u"tahoe\u263A" in aliases) self.failUnless(aliases[u"tahoe\u263A"].startswith("URI:DIR2:")) rc, stdout, stderr = yield self.do_cli("list-aliases") self.assertEqual(1, rc) self.assertIn("could not be converted", stderr)
def _check_create_unicode((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessIn("Alias %s created" % quote_output(u"\u00E9tudes"), out) aliases = get_aliases(self.get_clientdir()) self.failUnless(aliases[u"\u00E9tudes"].startswith("URI:DIR2:"))
def add_alias(options): nodedir = options['node-directory'] alias = options.alias precondition(isinstance(alias, unicode), alias=alias) cap = options.cap stdout = options.stdout stderr = options.stderr if u":" in alias: # a single trailing colon will already have been stripped if present print >>stderr, "Alias names cannot contain colons." return 1 if u" " in alias: print >>stderr, "Alias names cannot contain spaces." return 1 old_aliases = get_aliases(nodedir) if alias in old_aliases: print >>stderr, "Alias %s already exists!" % quote_output(alias) return 1 aliasfile = os.path.join(nodedir, "private", "aliases") cap = uri.from_string_dirnode(cap).to_string() add_line_to_aliasfile(aliasfile, alias, cap) print >>stdout, "Alias %s added" % quote_output(alias) return 0
def postOptions(self): self["quiet"] = self.parent["quiet"] if self.parent['node-directory']: self['node-directory'] = argv_to_abspath( self.parent['node-directory']) else: self['node-directory'] = _default_nodedir # compute a node-url from the existing options, put in self['node-url'] if self['node-url']: if (not isinstance(self['node-url'], basestring) or not NODEURL_RE.match(self['node-url'])): msg = ("--node-url is required to be a string and look like " "\"http://HOSTNAMEORADDR:PORT\", not: %r" % (self['node-url'], )) raise usage.UsageError(msg) else: node_url_file = os.path.join(self['node-directory'], "node.url") self['node-url'] = open(node_url_file, "r").read().strip() if self['node-url'][-1] != "/": self['node-url'] += "/" aliases = get_aliases(self['node-directory']) if self['dir-cap']: aliases[DEFAULT_ALIAS] = self['dir-cap'] self.aliases = aliases # maps alias name to dircap
def create_alias(options): # mkdir+add_alias nodedir = options['node-directory'] alias = options.alias stdout = options.stdout stderr = options.stderr assert ":" not in alias assert " " not in alias old_aliases = get_aliases(nodedir) if alias in old_aliases: print >>stderr, "Alias %s already exists!" % quote_output(alias) return 1 aliasfile = os.path.join(nodedir, "private", "aliases") nodeurl = options['node-url'] if not nodeurl.endswith("/"): nodeurl += "/" url = nodeurl + "uri?t=mkdir" resp = do_http("POST", url) rc = check_http_error(resp, stderr) if rc: return rc new_uri = resp.read().strip() # probably check for others.. add_line_to_aliasfile(aliasfile, alias, new_uri) print >>stdout, "Alias %s created" % (quote_output(alias),) return 0
def _done(args): (rc, stdout, stderr) = args self.assertEqual(rc, 0, stdout + stderr) self.assertIn("Alias 'magic' created", stdout) self.assertEqual(stderr, "") aliases = get_aliases(self.get_clientdir(i=client_num)) self.assertIn("magic", aliases) self.assertTrue(aliases["magic"].startswith("URI:DIR2:"))
def _delegate_options(source_options, target_options): target_options.aliases = get_aliases(source_options['node-directory']) target_options["node-url"] = source_options["node-url"] target_options["node-directory"] = source_options["node-directory"] target_options["name"] = source_options["name"] target_options.stdin = StringIO("") target_options.stdout = StringIO() target_options.stderr = StringIO() return target_options
def parseArgs(self, alias, nickname=None): super(InviteOptions, self).parseArgs() alias = argv_to_unicode(alias) if not alias.endswith(u':'): raise usage.UsageError("An alias must end with a ':' character.") self.alias = alias[:-1] self.nickname = argv_to_unicode(nickname) aliases = get_aliases(self.parent.node_directory) self.aliases = aliases
def _check_not_corrupted((rc,stdout,stderr)): self.failUnless("Alias 'un-corrupted2' added" in stdout, stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless("un-corrupted1" in aliases) self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:")) self.failIfIn("un-corrupted2:", aliases["un-corrupted1"]) self.failUnless("un-corrupted2" in aliases) self.failUnless(aliases["un-corrupted2"].startswith("URI:DIR2:"))
def test_create_unicode(self): self.basedir = "cli/CreateAlias/create_unicode" self.set_up_grid(oneshare=True) try: etudes_arg = u"\u00E9tudes".encode(get_io_encoding()) lumiere_arg = u"lumi\u00E8re.txt".encode(get_io_encoding()) except UnicodeEncodeError: raise unittest.SkipTest("A non-ASCII command argument could not be encoded on this platform.") d = self.do_cli("create-alias", etudes_arg) def _check_create_unicode((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessIn("Alias %s created" % quote_output(u"\u00E9tudes"), out) aliases = get_aliases(self.get_clientdir()) self.failUnless(aliases[u"\u00E9tudes"].startswith("URI:DIR2:")) d.addCallback(_check_create_unicode) d.addCallback(lambda res: self.do_cli("ls", etudes_arg + ":")) def _check_ls1((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessReallyEqual(out, "") d.addCallback(_check_ls1) d.addCallback(lambda res: self.do_cli("put", "-", etudes_arg + ":uploaded.txt", stdin="Blah blah blah")) d.addCallback(lambda res: self.do_cli("ls", etudes_arg + ":")) def _check_ls2((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessReallyEqual(out, "uploaded.txt\n") d.addCallback(_check_ls2) d.addCallback(lambda res: self.do_cli("get", etudes_arg + ":uploaded.txt")) def _check_get((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessReallyEqual(out, "Blah blah blah") d.addCallback(_check_get) # Ensure that an Unicode filename in an Unicode alias works as expected d.addCallback(lambda res: self.do_cli("put", "-", etudes_arg + ":" + lumiere_arg, stdin="Let the sunshine In!")) d.addCallback(lambda res: self.do_cli("get", get_aliases(self.get_clientdir())[u"\u00E9tudes"] + "/" + lumiere_arg)) def _check_get2((rc, out, err)): self.failUnlessReallyEqual(rc, 0) self.failUnlessReallyEqual(err, "") self.failUnlessReallyEqual(out, "Let the sunshine In!") d.addCallback(_check_get2) return d
def _check_create_unicode(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.failUnlessIn( u"Alias %s created" % (quote_output_u(etudes_arg), ), out) aliases = get_aliases(self.get_clientdir()) self.failUnless(aliases[u"\u00E9tudes"].startswith(b"URI:DIR2:"))
def _done((rc, stdout, stderr)): self.failUnlessEqual(rc, 0, stdout + stderr) self.assertIn("Alias 'magic' created", stdout) # self.failUnlessIn("joined new magic-folder", stdout) # self.failUnlessIn("Successfully created magic-folder", stdout) self.failUnlessEqual(stderr, "") aliases = get_aliases(self.get_clientdir(i=client_num)) self.assertIn("magic", aliases) self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
def _check_not_corrupted((rc, stdout, stderr)): self.failUnless("Alias 'un-corrupted2' added" in stdout, stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless("un-corrupted1" in aliases) self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:")) self.failIfIn("un-corrupted2:", aliases["un-corrupted1"]) self.failUnless("un-corrupted2" in aliases) self.failUnless(aliases["un-corrupted2"].startswith("URI:DIR2:"))
def _stash_urls(res): aliases = get_aliases(self.get_clientdir()) node_url_file = os.path.join(self.get_clientdir(), "node.url") nodeurl = fileutil.read(node_url_file).strip() self.welcome_url = nodeurl uribase = nodeurl + "uri/" self.tahoe_url = uribase + urllib.quote(aliases["tahoe"]) self.tahoe_subdir_url = self.tahoe_url + "/subdir" self.two_url = uribase + urllib.quote(aliases["two"]) self.two_uri = aliases["two"]
def _done(args): (rc, stdout, stderr) = args self.failUnlessEqual(rc, 0, stdout + stderr) self.assertIn("Alias 'magic' created", stdout) # self.failUnlessIn("joined new magic-folder", stdout) # self.failUnlessIn("Successfully created magic-folder", stdout) self.failUnlessEqual(stderr, "") aliases = get_aliases(self.get_clientdir(i=client_num)) self.assertIn("magic", aliases) self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
def _get_alias_details(nodedir): aliases = get_aliases(nodedir) alias_names = sorted(aliases.keys()) data = {} for name in alias_names: dircap = uri.from_string(aliases[name]) data[name] = { "readwrite": dircap.to_string(), "readonly": dircap.get_readonly().to_string(), } return data
def parseArgs(self, alias, nickname=None): BasedirOptions.parseArgs(self) alias = argv_to_unicode(alias) if not alias.endswith(u':'): raise usage.UsageError("An alias must end with a ':' character.") self.alias = alias[:-1] self.nickname = argv_to_unicode(nickname) node_url_file = os.path.join(self['node-directory'], u"node.url") self['node-url'] = open(node_url_file, "r").read().strip() aliases = get_aliases(self['node-directory']) self.aliases = aliases
def _check_not_corrupted1((rc,stdout,stderr)): self.failUnless("Alias 'un-corrupted1' created" in stdout, stdout) self.failIf(stderr) # the old behavior was to simply append the new record, causing a # line that looked like "NAME1: CAP1NAME2: CAP2". This won't look # like a valid dircap, so get_aliases() will raise an exception. aliases = get_aliases(self.get_clientdir()) self.failUnless("added" in aliases) self.failUnless(aliases["added"].startswith("URI:DIR2:")) # to be safe, let's confirm that we don't see "NAME2:" in CAP1. # No chance of a false-negative, because the hyphen in # "un-corrupted1" is not a valid base32 character. self.failIfIn("un-corrupted1:", aliases["added"]) self.failUnless("un-corrupted1" in aliases) self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:"))
def _check_not_corrupted1((rc, stdout, stderr)): self.failUnless("Alias 'un-corrupted1' created" in stdout, stdout) self.failIf(stderr) # the old behavior was to simply append the new record, causing a # line that looked like "NAME1: CAP1NAME2: CAP2". This won't look # like a valid dircap, so get_aliases() will raise an exception. aliases = get_aliases(self.get_clientdir()) self.failUnless("added" in aliases) self.failUnless(aliases["added"].startswith("URI:DIR2:")) # to be safe, let's confirm that we don't see "NAME2:" in CAP1. # No chance of a false-negative, because the hyphen in # "un-corrupted1" is not a valid base32 character. self.failIfIn("un-corrupted1:", aliases["added"]) self.failUnless("un-corrupted1" in aliases) self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:"))
def _add_alias(node_directory, alias, cap): if u":" in alias: raise Exception("Alias names cannot contain colons.") if u" " in alias: raise Exception("Alias names cannot contain spaces.") old_aliases = get_aliases(node_directory) if alias in old_aliases: raise Exception("Alias {} already exists!".format(quote_output(alias))) aliasfile = os.path.join(node_directory, "private", "aliases") cap = uri.from_string_dirnode(cap).to_string() add_line_to_aliasfile(aliasfile, alias, cap) return 0
def list_aliases(options): nodedir = options['node-directory'] stdout = options.stdout stderr = options.stderr aliases = get_aliases(nodedir) alias_names = sorted(aliases.keys()) max_width = max([len(quote_output(name)) for name in alias_names] + [0]) fmt = "%" + str(max_width) + "s: %s" rc = 0 for name in alias_names: try: print >>stdout, fmt % (unicode_to_output(name), unicode_to_output(aliases[name].decode('utf-8'))) except (UnicodeEncodeError, UnicodeDecodeError): print >>stderr, fmt % (quote_output(name), quote_output(aliases[name])) rc = 1 if rc == 1: print >>stderr, "\nThis listing included aliases or caps that could not be converted to the terminal" \ "\noutput encoding. These are shown using backslash escapes and in quotes." return rc
def add_alias(options): nodedir = options['node-directory'] alias = options.alias cap = options.cap stdout = options.stdout stderr = options.stderr assert ":" not in alias assert " " not in alias old_aliases = get_aliases(nodedir) if alias in old_aliases: print >>stderr, "Alias %s already exists!" % quote_output(alias) return 1 aliasfile = os.path.join(nodedir, "private", "aliases") cap = uri.from_string_dirnode(cap).to_string() add_line_to_aliasfile(aliasfile, alias, cap) print >>stdout, "Alias %s added" % quote_output(alias) return 0
def invite(options): precondition(isinstance(options.alias, unicode), alias=options.alias) precondition(isinstance(options.nickname, unicode), nickname=options.nickname) mkdir_options = _delegate_options(options, MakeDirectoryOptions()) mkdir_options.where = None rc = tahoe_mkdir.mkdir(mkdir_options) if rc != 0: print("magic-folder: failed to mkdir\n", file=options.stderr) return rc # FIXME this assumes caps are ASCII. dmd_write_cap = mkdir_options.stdout.getvalue().strip() dmd_readonly_cap = uri.from_string( dmd_write_cap).get_readonly().to_string() if dmd_readonly_cap is None: print("magic-folder: failed to diminish dmd write cap\n", file=options.stderr) return 1 magic_write_cap = get_aliases(options["node-directory"])[options.alias] magic_readonly_cap = uri.from_string( magic_write_cap).get_readonly().to_string() # tahoe ln CLIENT_READCAP COLLECTIVE_WRITECAP/NICKNAME ln_options = _delegate_options(options, LnOptions()) ln_options.from_file = unicode(dmd_readonly_cap, 'utf-8') ln_options.to_file = u"%s/%s" % (unicode(magic_write_cap, 'utf-8'), options.nickname) rc = tahoe_mv.mv(ln_options, mode="link") if rc != 0: print("magic-folder: failed to create link\n", file=options.stderr) print(ln_options.stderr.getvalue(), file=options.stderr) return rc # FIXME: this assumes caps are ASCII. print("%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap), file=options.stdout) return 0
def create_alias(options): # mkdir+add_alias nodedir = options['node-directory'] alias = options.alias precondition(isinstance(alias, unicode), alias=alias) stdout = options.stdout stderr = options.stderr if u":" in alias: # a single trailing colon will already have been stripped if present print >>stderr, "Alias names cannot contain colons." return 1 if u" " in alias: print >>stderr, "Alias names cannot contain spaces." return 1 old_aliases = get_aliases(nodedir) if alias in old_aliases: print >>stderr, "Alias %s already exists!" % quote_output(alias) return 1 aliasfile = os.path.join(nodedir, "private", "aliases") nodeurl = options['node-url'] if not nodeurl.endswith("/"): nodeurl += "/" url = nodeurl + "uri?t=mkdir" resp = do_http("POST", url) rc = check_http_error(resp, stderr) if rc: return rc new_uri = resp.read().strip() # probably check for others.. add_line_to_aliasfile(aliasfile, alias, new_uri) print >>stdout, "Alias %s created" % (quote_output(alias),) return 0
def list_aliases(options): nodedir = options['node-directory'] stdout = options.stdout stderr = options.stderr aliases = get_aliases(nodedir) alias_names = sorted(aliases.keys()) max_width = max([len(quote_output(name)) for name in alias_names] + [0]) fmt = "%" + str(max_width) + "s: %s" rc = 0 for name in alias_names: dircap = uri.from_string(aliases[name]) if options['readonly-uri']: dircap = dircap.get_readonly() try: print >>stdout, fmt % (unicode_to_output(name), unicode_to_output(dircap.to_string().decode('utf-8'))) except (UnicodeEncodeError, UnicodeDecodeError): print >>stderr, fmt % (quote_output(name), quote_output(aliases[name])) rc = 1 if rc == 1: print >>stderr, "\nThis listing included aliases or caps that could not be converted to the terminal" \ "\noutput encoding. These are shown using backslash escapes and in quotes." return rc
def test_list(self): self.basedir = "cli/ListAlias/test_list" self.set_up_grid(oneshare=True) rc, stdout, stderr = yield self.do_cli( "create-alias", unicode_to_argv(u"tahoe"), ) self.failUnless(unicode_to_argv(u"Alias 'tahoe' created") in stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless(u"tahoe" in aliases) self.failUnless(aliases[u"tahoe"].startswith("URI:DIR2:")) rc, stdout, stderr = yield self.do_cli("list-aliases", "--json") self.assertEqual(0, rc) data = json.loads(stdout) self.assertIn(u"tahoe", data) data = data[u"tahoe"] self.assertIn("readwrite", data) self.assertIn("readonly", data)
def _check_add_duplicate(args): (rc, stdout, stderr) = args self.failIfEqual(rc, 0) self.failUnless("Alias 'two' already exists!" in stderr) aliases = get_aliases(self.get_clientdir()) self.failUnlessReallyEqual(aliases["two"], self.two_uri)
def _check_add_duplicate((rc,stdout,stderr)): self.failIfEqual(rc, 0) self.failUnless("Alias 'two' already exists!" in stderr) aliases = get_aliases(self.get_clientdir()) self.failUnlessReallyEqual(aliases["two"], self.two_uri)
def test_create_unicode(self): self.basedir = "cli/CreateAlias/create_unicode" self.set_up_grid(oneshare=True) etudes_arg = u"\u00E9tudes" lumiere_arg = u"lumi\u00E8re.txt" d = self.do_cli("create-alias", etudes_arg) def _check_create_unicode(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.failUnlessIn( u"Alias %s created" % (quote_output_u(etudes_arg), ), out) aliases = get_aliases(self.get_clientdir()) self.failUnless(aliases[u"\u00E9tudes"].startswith(b"URI:DIR2:")) d.addCallback(_check_create_unicode) d.addCallback(lambda res: self.do_cli("ls", etudes_arg + ":")) def _check_ls1(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.assertEqual(len(out), 0, out) d.addCallback(_check_ls1) DATA = b"Blah blah blah \xff blah \x00 blah" d.addCallback(lambda res: self.do_cli( "put", "-", etudes_arg + ":uploaded.txt", stdin=DATA)) d.addCallback(lambda res: self.do_cli("ls", etudes_arg + ":")) def _check_ls2(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.assertEqual(out, "uploaded.txt\n") d.addCallback(_check_ls2) d.addCallback(lambda res: self.do_cli( "get", etudes_arg + ":uploaded.txt", return_bytes=True)) def _check_get(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.failUnlessReallyEqual(out, DATA) d.addCallback(_check_get) # Ensure that an Unicode filename in an Unicode alias works as expected d.addCallback(lambda res: self.do_cli("put", "-", etudes_arg + ":" + lumiere_arg, stdin=b"Let the sunshine In!")) d.addCallback(lambda res: self.do_cli( "get", str(get_aliases(self.get_clientdir())[u"\u00E9tudes"], "ascii" ) + "/" + lumiere_arg, return_bytes=True)) def _check_get2(args): (rc, out, err) = args self.failUnlessReallyEqual(rc, 0) self.assertEqual(len(err), 0, err) self.failUnlessReallyEqual(out, b"Let the sunshine In!") d.addCallback(_check_get2) return d
def _get_dircap(res): self.dircap = str( get_aliases(self.get_clientdir())["tahoe"], "ascii")
def _get_dircap(res): self.dircap = get_aliases(self.get_clientdir())["tahoe"]
def data_list_aliases(self, ctx, data): aliases = get_aliases(get_default_nodedir()) return sorted(aliases.items())
def _done((rc, stdout, stderr)): self.failUnless("Alias 'tahoe' created" in stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless("tahoe" in aliases) self.failUnless(aliases["tahoe"].startswith("URI:DIR2:"))
def _check_create_alias(self, alias, encoding): """ Verify that ``tahoe create-alias`` can be used to create an alias named ``alias`` when argv is encoded using ``encoding``. :param unicode alias: The alias to try to create. :param NoneType|str encoding: The name of an encoding to force the ``create-alias`` implementation to use. This simulates the effects of setting LANG and doing other locale-foolishness without actually having to mess with this process's global locale state. If this is ``None`` then the encoding used will be ascii but the stdio objects given to the code under test will not declare any encoding (this is like Python 2 when stdio is not a tty). :return Deferred: A Deferred that fires with success if the alias can be created and that creation is reported on stdout appropriately encoded or with failure if something goes wrong. """ self.basedir = self.mktemp() self.set_up_grid(oneshare=True) # We can pass an encoding into the test utilities to invoke the code # under test but we can't pass such a parameter directly to the code # under test. Instead, that code looks at io_encoding. So, # monkey-patch that value to our desired value here. This is the code # that most directly takes the place of messing with LANG or the # locale module. self.patch(encodingutil, "io_encoding", encoding or "ascii") rc, stdout, stderr = yield self.do_cli_unicode( u"create-alias", [alias], encoding=encoding, ) # Make sure the result of the create-alias command is as we want it to # be. self.assertEqual(u"Alias '{}' created\n".format(alias), stdout) self.assertEqual("", stderr) self.assertEqual(0, rc) # Make sure it had the intended side-effect, too - an alias created in # the node filesystem state. aliases = get_aliases(self.get_clientdir()) self.assertIn(alias, aliases) self.assertTrue(aliases[alias].startswith(b"URI:DIR2:")) # And inspect the state via the user interface list-aliases command # too. rc, stdout, stderr = yield self.do_cli_unicode( u"list-aliases", [u"--json"], encoding=encoding, ) self.assertEqual(0, rc) data = json.loads(stdout) self.assertIn(alias, data) data = data[alias] self.assertIn(u"readwrite", data) self.assertIn(u"readonly", data)
def _done((rc,stdout,stderr)): self.failUnless("Alias 'tahoe' created" in stdout) self.failIf(stderr) aliases = get_aliases(self.get_clientdir()) self.failUnless("tahoe" in aliases) self.failUnless(aliases["tahoe"].startswith("URI:DIR2:"))