def test_create_remove_user(self):
user = User("foo-user", "password")
user.create(self.connection)
the_user = User.lookup(self.connection, "foo-user")
assert the_user is not None
the_user.delete(self.connection)
the_user = User.lookup(self.connection, "foo-user")
assert the_user is None
def test_create_remove_user(self):
connection = Connection.make_connection(tc.hostname, tc.admin, tc.password)
user = User("foo-user", "password")
user.create(connection)
the_user = User.lookup(connection, "foo-user")
self.assertIsNotNone(the_user)
the_user.delete(connection)
the_user = User.lookup(connection, "foo-user")
self.assertIsNone(the_user)
def test_create_remove_user(self):
connection = Connection.make_connection(tc.hostname, tc.admin,
tc.password)
user = User("foo-user", "password")
user.create(connection)
the_user = User.lookup(connection, "foo-user")
self.assertIsNotNone(the_user)
the_user.delete(connection)
the_user = User.lookup(connection, "foo-user")
self.assertIsNone(the_user)
def delete(self, args, config, connection):
user = User.lookup(connection, args['name'])
if user is None:
return
print("Delete user {0}...".format(args['name']))
user.delete(connection)
def delete(self, args, config, connection):
user = User.lookup(connection, args['name'])
if user is None:
return
print("Delete user {0}...".format(args['name']))
user.delete(connection)
def test_lookup(self):
connection = Connection.make_connection(tc.hostname, tc.admin, tc.password)
user = User.lookup(connection, "nobody")
self.assertIsNotNone(user)
self.assertEqual(user.user_name(), "nobody")
def test_lookup(self):
connection = Connection.make_connection(tc.hostname, tc.admin,
tc.password)
user = User.lookup(connection, "nobody")
self.assertIsNotNone(user)
self.assertEqual(user.user_name(), "nobody")
def test_save_user(self):
user = User("foo-user", "password")
assert user.create(self.connection).description() is None
user.set_description("This is the foo user")
user.update(self.connection)
user = User.lookup(self.connection, "foo-user")
assert "This is the foo user" == user.description()
user.delete(self.connection)
def test_save_user(self):
connection = Connection.make_connection(tc.hostname, tc.admin, tc.password)
user = User("foo-user", "password")
self.assertIsNone(user.create(connection).description())
user.set_description("This is the foo user")
user.update(connection)
user = User.lookup(connection, "foo-user")
self.assertEqual("This is the foo user", user.description())
user.delete(connection)
def test_save_user(self):
connection = Connection.make_connection(tc.hostname, tc.admin,
tc.password)
user = User("foo-user", "password")
self.assertIsNone(user.create(connection).description())
user.set_description("This is the foo user")
user.update(connection)
user = User.lookup(connection, "foo-user")
self.assertEqual("This is the foo user", user.description())
user.delete(connection)
priv = Privilege.lookup(conn, name, kind)
if priv is None:
verb = "Creating"
priv = Privilege.unmarshal(config)
print("{0} privilege: {1}".format(verb, name))
priv.create(conn)
else:
verb = "Updating"
priv = Privilege.unmarshal(config)
print("{0} {1} privilege: {2}".format(verb, kind, name))
priv.update(conn)
# Update users
for config in data['users']:
name = config['user-name']
user = User.lookup(conn, name)
if user is None:
verb = "Creating"
user = User.unmarshal(config)
# Must assign some sort of password
user.set_password(base64.urlsafe_b64encode(os.urandom(32)).decode('utf-8'))
print("{0} user: {1}".format(verb, name))
user.create(conn)
else:
verb = "Updating"
user = User.unmarshal(config)
print("{0} user: {1}".format(verb, name))
user.update(conn)
# Create forests
for config in data['forests']:
def test_lookup(self):
user = User.lookup(self.connection, "nobody")
assert user is not None
assert "nobody" == user.user_name()
def close(self, conn, group='Default'):
closed = False
while not closed:
closed = True
newitems = []
for key in self.servers:
item = self.servers[key]
if item is None:
closed = False
newitems.append(Server.lookup(conn, key, group))
for server in newitems:
self._close_over_server(server)
newitems = []
for key in self.databases:
item = self.databases[key]
if item is None:
closed = False
newitems.append(Database.lookup(conn, key))
for database in newitems:
self._close_over_database(database)
newitems = []
for key in self.forests:
item = self.forests[key]
if item is None:
closed = False
newitems.append(Forest.lookup(conn, key))
for forest in newitems:
self._close_over_forest(forest)
newitems = []
for key in self.users:
item = self.users[key]
if item is None:
closed = False
newitems.append(User.lookup(conn, key))
for user in newitems:
self._close_over_user(user)
newitems = []
for key in self.roles:
item = self.roles[key]
if item is None:
closed = False
newitems.append(Role.lookup(conn, key))
for role in newitems:
self._close_over_role(role)
delitems = []
newitems = []
for key in self.privileges:
item = self.privileges[key]
parts = key.split("|")
kind = parts[0]
name = parts[1]
if isinstance(item, str):
closed = False
if "//" in key:
# Assume it's an action
priv = Privilege.lookup(conn, action=name, kind=kind)
delitems.append(key)
else:
priv = Privilege.lookup(conn, name, kind)
newitems.append(priv)
for item in delitems:
del self.privileges[item]
for priv in newitems:
self._close_over_privilege(priv)
def close(self, conn, group='Default'):
closed = False
while not closed:
closed = True
newitems = []
for key in self.servers:
item = self.servers[key]
if item is None:
closed = False
newitems.append(Server.lookup(conn, key, group))
for server in newitems:
self._close_over_server(server)
newitems = []
for key in self.databases:
item = self.databases[key]
if item is None:
closed = False
newitems.append(Database.lookup(conn, key))
for database in newitems:
self._close_over_database(database)
newitems = []
for key in self.users:
item = self.users[key]
if item is None:
closed = False
newitems.append(User.lookup(conn, key))
for user in newitems:
self._close_over_user(user)
newitems = []
for key in self.roles:
item = self.roles[key]
if item is None:
closed = False
newitems.append(Role.lookup(conn, key))
for role in newitems:
self._close_over_role(role)
delitems = []
newitems = []
for key in self.privileges:
item = self.privileges[key]
parts = key.split("|")
kind = parts[0]
name = parts[1]
if isinstance(item, str):
closed = False
if self.PRIVILEGES is None:
self.PRIVILEGES = Privilege.list(conn)
for priv in self.PRIVILEGES:
parts = priv.split("|")
if parts[0] == kind and parts[2] == name:
delitems.append(key)
name = parts[1]
newitems.append(Privilege.lookup(conn, name, kind))
for item in delitems:
del self.privileges[item]
for priv in newitems:
self._close_over_privilege(priv)
