def create_user(self, display_name, id, pw, opts):
pycb.log(logging.INFO, "===== def create_user of cbAuthzSecurity.py")
db_obj = DB(con_str=self.con_str)
user = User(db_obj, friendly=display_name)
user_alias = user.create_alias(id, "s3", display_name, alias_data=pw)
db_obj.commit()
db_obj.close()
def main(argv=sys.argv[1:]):
try:
con_str = pynimbusauthz.get_db_connection_string()
db_obj = DB(con_str=con_str)
(opts,args) = setup_options(argv)
if len(args) > 0:
u_pattern = args[0]
else:
u_pattern = ""
if opts.bya:
usa = User.find_alias(db_obj, u_pattern)
users = []
for ua in usa:
users.append(ua.get_canonical_user())
else:
users = User.find_user(db_obj, u_pattern)
if users == None:
pynimbusauthz.print_msg(opts, 0, "No users in list")
return 1
for u in users:
list_user(opts, u)
except AuthzException, ae:
print ae
return ae.get_rc()
class TestTouchCli(unittest.TestCase):
def setUp(self):
(osf, self.fname) = tempfile.mkstemp()
os.close(osf)
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
os.environ['NIMBUS_AUTHZ_DB'] = self.fname
pynimbusauthz.db.make_test_database(self.fname)
self.db = DB(con_str=self.fname)
self.user1 = User(self.db)
self.db.commit()
def tearDown(self):
self.db.close()
os.remove(self.fname)
def test_basic_touch(self):
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertEqual(f, None)
rc = pynimbusauthz.touch.main([self.user1.get_id(), fname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertNotEqual(f, None)
def test_bucket_touch(self):
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main(["-t", pynimbusauthz.object_type_s3, self.user1.get_id(), fname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertNotEqual(f, None)
def test_under_bucket_touch(self):
bname = str(uuid.uuid1())
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main(["-t", pynimbusauthz.object_type_s3, self.user1.get_id(), bname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
rc = pynimbusauthz.touch.main(["-p", bname, self.user1.get_id(), fname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
b1 = File.get_file(self.db, bname, pynimbusauthz.object_type_s3)
f1 = File.get_file(self.db, fname, pynimbusauthz.object_type_s3, parent=b1)
self.assertNotEqual(b1, None)
self.assertNotEqual(f1, None)
def test_bad_opts(self):
bname = str(uuid.uuid1())
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main([bname, data])
self.assertEqual(rc, 32, "CLI should return failure %d" % (rc))
rc = pynimbusauthz.touch.main(["-p", bname, self.user1.get_id(), fname, data])
self.assertEqual(rc, 33, "CLI should return failure %d" % (rc))
def test_alias_lookup_simple(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "name1@")
alias2 = user1.get_alias("/name/", pynimbusauthz.alias_type_s3)
self.assertEqual(alias1.get_name(), alias2.get_name(), "Alias names should be the same")
self.assertEqual(alias1.get_type(), alias2.get_type(), "Alias types should be the same")
self.assertEqual(alias1.get_data(), alias2.get_data(), "Alias data should be the same")
def test_create_same_alias(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "name@")
try:
alias2 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "name@")
self.fail("This should have caused an conflict on insert")
except:
pass
def remove_user(self, force=False):
try:
if force:
uc = User(self.db_obj, uu=self.get_canonical_id(), create=False)
uc.destroy_brutally()
else:
self.alias.remove()
finally:
self.db_obj.commit()
def test_destroy_user(self):
user1 = User(self.db)
uu = user1.get_id()
user1.destroy_brutally()
try:
user1 = User(self.db, uu)
self.fail("The uuid should have been deleted %s" % (uu))
except:
pass
def remove_user(self, force=False):
pycb.log(logging.INFO, "===== def remove_user of cbAuthzSecurity.py")
try:
if force:
uc = User(self.db_obj, uu=self.get_canonical_id(), create=False)
uc.destroy_brutally()
else:
self.alias.remove()
finally:
self.db_obj.commit()
def test_basic_stat(self):
user2 = User(self.db)
self.db.commit()
rc = pynimbusauthz.chmod.main([user2.get_id(), self.name, "Rrw"])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
rc = pynimbusauthz.stat.main([self.name])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
rc = pynimbusauthz.stat.main(["-a", self.name])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
def test_create_alias_simple(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "testname@")
user2 = alias1.get_canonical_user()
self.assertEqual(user1.get_id(), user2.get_id(), "User IDs should be equal")
alias1 = user1.create_alias("/name2", pynimbusauthz.alias_type_s3, "name2@", "pooP")
user2 = alias1.get_canonical_user()
self.assertEqual(user1.get_id(), user2.get_id(), "User IDs should be equal")
print alias1
def test_set_alias_data(self):
user1 = User(self.db)
self.db.commit()
alias_name = "helloname"
alias1 = user1.create_alias(alias_name, pynimbusauthz.alias_type_s3, alias_name)
key = "helloworld"
alias1.set_data(key)
self.db.commit()
alias2 = user1.get_alias(alias_name, pynimbusauthz.alias_type_s3)
self.assertEqual(alias1.get_data(), alias2.get_data(), "alias not equal")
self.assertEqual(key, alias2.get_data(), "alias not equal")
def test_basic_alias(self):
user = User(self.db)
uu = user.get_id()
aname = "alias1"
self.db.commit()
rc = pynimbusauthz.add_user.main(["-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
self.assertNotEqual(ua, None, "alias not found")
rc = pynimbusauthz.add_user.main(["-x", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
self.assertEqual(ua, None, "alias should not be found")
def test_set_key(self):
aname = str(uuid.uuid1())
uu = str(uuid.uuid1())
rc = pynimbusauthz.add_user.main(["-n", "-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
rc = pynimbusauthz.add_user.main(["-g", "-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
key = str(uuid.uuid1())
rc = pynimbusauthz.add_user.main(["-k", key, "-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
user = User(self.db, uu)
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
self.db.commit()
k2 = ua.get_data()
self.assertEqual(k2, key)
class TestUser(unittest.TestCase):
def setUp(self):
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
con = pynimbusauthz.db.make_test_database()
self.db = DB(con=con)
self.user = User(self.db)
def tearDown(self):
self.user.destroy_brutally()
self.db.close()
def test_get_no_quota(self):
q = self.user.get_quota()
self.assertEqual(q, User.UNLIMITED)
def test_set_quota(self):
q = 100
self.user.set_quota(q)
qrc = self.user.get_quota()
self.assertEqual(q, qrc)
def test_get_no_usage(self):
u = self.user.get_quota_usage()
self.assertEqual(u, 0)
def test_add_file_usage_one_file(self):
size1 = 100
name = "/file/name"
data = "/etc/group"
file1 = File.create_file(self.db, name, self.user, data, pynimbusauthz.object_type_s3, size=size1)
self.db.commit()
u = self.user.get_quota_usage()
self.assertEqual(u, size1)
def test_add_file_usage_many_files(self):
size1 = 100
name = "/file/name"
data = "/etc/group"
total = 0
for i in range(0, 10):
file1 = File.create_file(self.db, name+str(i), self.user, data, pynimbusauthz.object_type_s3, size=size1)
total = total + size1
self.db.commit()
u = self.user.get_quota_usage()
self.assertEqual(u, total)
def __init__(self, alias_name, con_str):
self.db_obj = DB(con_str=con_str)
alias = User.find_alias(self.db_obj, alias_name, pynimbusauthz.alias_type_s3)
a_list = list(alias)
if len(a_list) < 1:
raise cbException('AccessDenied')
# pick the first one, hmmm XXX
self.alias = a_list[0]
self.user = self.alias.get_canonical_user()
def setUp(self):
(osf, self.fname) = tempfile.mkstemp()
os.close(osf)
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
os.environ['NIMBUS_AUTHZ_DB'] = self.fname
pynimbusauthz.db.make_test_database(self.fname)
self.db = DB(con_str=self.fname)
self.user1 = User(self.db)
self.db.commit()
def main(argv=sys.argv[1:]):
try:
con_str = pynimbusauthz.get_db_connection_string()
db_obj = DB(con_str=con_str)
(opts, args) = setup_options(argv)
user = User(db_obj, args[0], create=False)
if opts.quota != None:
q = opts.quota
if opts.quota == "UNLIMITED":
q = User.UNLIMITED
user.set_quota(q, object_type=opts.type)
if opts.report:
q = user.get_quota(object_type=opts.type)
u = user.get_quota_usage(object_type=opts.type)
if q != User.UNLIMITED:
r = q - u
rstr = pynimbusauthz.pretty_number(r)
qstr = pynimbusauthz.pretty_number(q)
ustr = pynimbusauthz.pretty_number(u)
pynimbusauthz.print_msg(opts, 0, "%-10s %s" % ("Quota", qstr))
pynimbusauthz.print_msg(opts, 0, "%-10s %s" % ("Usage", ustr))
pynimbusauthz.print_msg(opts, 0, "%-10s %s" % ("Remaining", rstr))
if r < 0:
pynimbusauthz.print_msg(opts, 0, "OVER LIMIT!")
elif r == 0:
pynimbusauthz.print_msg(opts, 0, "At Limit")
else:
p = (float(r) / float(q)) * 100.0
pynimbusauthz.print_msg(opts, 0, "%-10s %5.1f%%" % ("Available", p))
else:
pynimbusauthz.print_msg(opts, 0, "Quota UNLIMITED")
db_obj.commit()
except AuthzException, ae:
print ae
return ae.get_rc()
def test_alias_lookup(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "1")
aliasX = user1.create_alias("/name2", pynimbusauthz.alias_type_s3, "2")
aliasX = user1.create_alias("/name3", pynimbusauthz.alias_type_s3, "3")
aliasX = user1.create_alias("/name4", pynimbusauthz.alias_type_s3, "4")
all_alias = user1.get_all_alias()
found = False
for a in all_alias:
if a.get_name() == alias1.get_name() and a.get_type() == alias1.get_type():
found = True
self.assertTrue(found, "We should have found the alias")
all_alias = user1.get_alias_by_type(pynimbusauthz.alias_type_s3)
found = False
for a in all_alias:
if a.get_name() == alias1.get_name() and a.get_type() == alias1.get_type():
found = True
self.assertTrue(found, "We should have found the alias")
def get_user_object_by_access_id(self, access_id):
"""Get a new connection every time this is called to make sure it is cleaned up"""
db = DB(self._cumulus_db)
user_alias = User.find_alias(db, access_id)
if not user_alias:
raise PhantomAWSException('InvalidClientTokenId')
l = list(user_alias)
db.close()
if l < 1:
raise PhantomAWSException('InvalidClientTokenId')
return PhantomUserObject(access_id, l[0].get_data(), l[0].get_friendly_name())
def grant(self, user_id, bucketName, objectName=None, perms="Rr"):
try:
uf = self.get_uf(bucketName, objectName)
new_alias_iter = User.find_alias(self.db_obj, user_id, pynimbusauthz.alias_type_s3)
new_alias_list = list(new_alias_iter)
new_alias = new_alias_list[0]
new_user = new_alias.get_canonical_user()
uf.chmod(perms, user=new_user)
finally:
self.db_obj.commit()
def grant(self, user_id, bucketName, objectName=None, perms="Rr"):
pycb.log(logging.INFO, "===== def grant of cbAuthzSecurity.py")
try:
uf = self.get_uf(bucketName, objectName)
new_alias_iter = User.find_alias(self.db_obj, user_id, pynimbusauthz.alias_type_s3)
new_alias_list = list(new_alias_iter)
new_alias = new_alias_list[0]
new_user = new_alias.get_canonical_user()
uf.chmod(perms, user=new_user)
finally:
self.db_obj.commit()
def test_user_alias_remove(self):
aname = str(uuid.uuid1())
uu = str(uuid.uuid1())
rc = pynimbusauthz.add_user.main(["-n", "-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
user = User(self.db, uu)
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
rc = pynimbusauthz.add_user.main(["-x", aname, "-r", uu])
self.assertEqual(rc, 0, "CLI should return success")
try:
user = User(self.db, uu)
self.fail("should have had an exception loading user")
except:
pass
try:
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
self.fail("should have had an exception loading user")
except:
pass
def setUp(self):
(osf, self.fname) = tempfile.mkstemp()
os.close(osf)
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
os.environ['NIMBUS_AUTHZ_DB'] = self.fname
pynimbusauthz.db.make_test_database(self.fname)
self.db = DB(con_str=self.fname)
self.user1 = User(self.db)
self.name = "/file/name"
self.data = "/etc/group"
self.file1 = File.create_file(self.db, self.name, self.user1, self.data, pynimbusauthz.object_type_s3)
self.uf = UserFile(self.file1)
self.db.commit()
def reset_users(nh, clean_pattern='%'):
dbobj = pynimbusauthz.get_db_connection_string()
users_to_delete = User.find_user_by_friendly(dbobj, clean_pattern)
for user in users_to_delete:
files = File.get_user_files(dbobj, user)
for f in files:
name = f.get_data_key()
f.delete()
# commit every file delete before removing the actual file
dbobj.commit()
pycb.config.bucket.delete_object(name)
user.destroy_brutally()
# commit after every user because otherwise the file delete inner
# loop will commit in less obvious ways
dbobj.commit()
def test_find_user_alias(self):
user1 = User(self.db)
self.db.commit()
alias_name = "helloname"
alias1 = user1.create_alias(alias_name, pynimbusauthz.alias_type_s3, alias_name)
self.db.commit()
fid = "%%" + alias_name[1:]
lid = alias_name[:-1] + "%%"
mid = "%%" + alias_name[1:-1] + "%%"
# find by exact id
u_all = UserAlias.find_alias(self.db, alias_name)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(alias1, u_all))
# find by exact partial 1
u_all = UserAlias.find_alias(self.db, fid)
self.assertTrue(self.find_user_id(alias1, u_all))
# find by exact partial 1
u_all = UserAlias.find_alias(self.db, lid)
self.assertTrue(self.find_user_id(alias1, u_all))
# find by exact partial 1
u_all = UserAlias.find_alias(self.db, mid)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(alias1, u_all))
def test_list_alias(self):
uu = str(uuid.uuid1())
user = User(self.db, uu, create=True)
# add a few alias
self.db.commit()
alias_a = []
for i in range(0, 10):
aname = str(uuid.uuid1())
alias_a.append(aname)
rc = pynimbusauthz.add_user.main(["-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
rc = pynimbusauthz.list_user.main(["-a", "-O", self.outFileName])
self.assertEqual(rc, 0, "CLI should return success")
rc = self.find_out_string(uu)
self.assertTrue(rc, "Username not found")
for a in alias_a:
rc = self.find_out_string(a)
self.assertTrue(rc, "Username not found")
def main(argv=sys.argv[1:]):
try:
repo_dir = argv[0]
repo_dir = str(repo_dir).strip()
con_str = pynimbusauthz.get_db_connection_string()
db_obj = DB(con_str=con_str)
user = User(db_obj, uu="CumulusPublicUser")
if user == None:
raise Exception("No public user")
File.create_file(db_obj, repo_dir, user, repo_dir,
pynimbusauthz.alias_type_s3)
db_obj.commit()
except:
raise
return 0
def test_create_alias_simple(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3,
"testname@")
user2 = alias1.get_canonical_user()
self.assertEqual(user1.get_id(), user2.get_id(),
"User IDs should be equal")
alias1 = user1.create_alias("/name2", pynimbusauthz.alias_type_s3,
"name2@", "pooP")
user2 = alias1.get_canonical_user()
self.assertEqual(user1.get_id(), user2.get_id(),
"User IDs should be equal")
print alias1
def test_change_key(self):
user1 = User(self.db)
name = "/file/name"
old_base = "/old/path/base"
fname = "/etc/group"
new_base = "/new/base/location/dir"
f = File.create_file(self.db, name, user1, old_base + fname, pynimbusauthz.object_type_s3)
self.assertEqual(old_base + fname, f.get_data_key(), "old value not euqal")
new_key = new_base + fname
f.set_data_key(new_key)
self.db.commit()
tst_new_key = f.get_data_key()
self.assertEqual(tst_new_key, new_key, "%s should equal %s" % (tst_new_key, new_key))
f2 = File.get_file(self.db, name, pynimbusauthz.object_type_s3)
tst_new_key = f2.get_data_key()
self.assertEqual(tst_new_key, new_key, "%s should equal %s" % (tst_new_key, new_key))
def main(argv=sys.argv[1:]):
try:
con_str = pynimbusauthz.get_db_connection_string()
db_obj = DB(con_str=con_str)
(opts, args) = setup_options(argv)
if len(args) != 3:
raise AuthzException(
'CLI_PARAMETER',
"You must specify a username filename permssions")
user_name = args[0]
object_name = args[1]
requested_perms = args[2]
parent = None
if opts.parent != None:
parent = File.get_file(db_obj, opts.parent, opts.type)
if parent == None:
raise AuthzException('FILE_EXISTS',
"parent %s not found" % (opts.parent))
file1 = File.get_file(db_obj, object_name, opts.type, parent=parent)
if file1 == None:
raise AuthzException(
'FILE_EXISTS',
"file %s:%s not found" % (opts.type, object_name))
user = User(db_obj, uu=user_name)
uf = UserFile(file1) # create a uesrfile with owner so we can chmod
uf.chmod(requested_perms, user=user)
pynimbusauthz.print_msg(
opts, 0, "changed %s to %s for %s" %
(str(file1), requested_perms, str(user)))
db_obj.commit()
except AuthzException, ae:
print ae
return ae.get_rc()
def test_file_children(self):
user1 = User(self.db)
name = "/file/name"
data = "/etc/group"
file1 = File.create_file(self.db, name, user1, data, pynimbusauthz.object_type_s3)
self.db.commit()
child1 = File.create_file(self.db, "kid", user1, data, pynimbusauthz.object_type_s3, parent=file1)
self.db.commit()
p2 = child1.get_parent()
self.assertEqual(p2, file1, "parent not set properly")
x = child1.get_all_children()
self.assertEqual(len(list(x)), 0, "The file should have no children")
x = file1.get_all_children()
found = False
for f in x:
if f == child1:
found = True
self.assertTrue(found, "We should have found that kid!")
def test_find_user(self):
user1 = User(self.db)
self.db.commit()
id = user1.get_id()
fid = id[1:]
lid = id[:-1]
mid = id[1:-1]
# find by exact id
u_all = User.find_user(self.db, id)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, fid)
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, lid)
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, mid)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(user1, u_all))
def test_alias_lookup(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "1")
aliasX = user1.create_alias("/name2", pynimbusauthz.alias_type_s3, "2")
aliasX = user1.create_alias("/name3", pynimbusauthz.alias_type_s3, "3")
aliasX = user1.create_alias("/name4", pynimbusauthz.alias_type_s3, "4")
all_alias = user1.get_all_alias()
found = False
for a in all_alias:
if a.get_name() == alias1.get_name() and a.get_type(
) == alias1.get_type():
found = True
self.assertTrue(found, "We should have found the alias")
all_alias = user1.get_alias_by_type(pynimbusauthz.alias_type_s3)
found = False
for a in all_alias:
if a.get_name() == alias1.get_name() and a.get_type(
) == alias1.get_type():
found = True
self.assertTrue(found, "We should have found the alias")
def test_find_user(self):
user1 = User(self.db)
self.db.commit()
id = user1.get_id()
fid = id[1:]
lid = id[:-1]
mid = id[1:-1]
# find by exact id
u_all = User.find_user(self.db, id)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, fid)
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, lid)
self.assertTrue(self.find_user_id(user1, u_all))
# find by exact partial 1
u_all = User.find_user(self.db, mid)
self.assertNotEqual(u_all, None, "we should have found somethings")
self.assertTrue(self.find_user_id(user1, u_all))
def test_user_alias_remove(self):
aname = str(uuid.uuid1())
uu = str(uuid.uuid1())
rc = pynimbusauthz.add_user.main(["-n", "-a", aname, uu])
self.assertEqual(rc, 0, "CLI should return success")
user = User(self.db, uu)
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
rc = pynimbusauthz.add_user.main(["-x", aname, "-r", uu])
self.assertEqual(rc, 0, "CLI should return success")
try:
user = User(self.db, uu)
self.fail("should have had an exception loading user")
except:
pass
try:
ua = user.get_alias(aname, pynimbusauthz.alias_type_s3)
self.fail("should have had an exception loading user")
except:
pass
def setUp(self):
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
con = pynimbusauthz.db.make_test_database()
self.db = DB(con=con)
self.user = User(self.db)
def test_basic_user(self):
user1 = User(self.db)
user2 = User(self.db, user1.get_id())
self.assertEqual(user1.get_id(), user2.get_id(),
"User IDs should be equal")
def test_delete_alias(self):
user1 = User(self.db)
alias1 = user1.create_alias("/name/", pynimbusauthz.alias_type_s3, "name@")
alias1.remove()
alias2 = user1.get_alias("/name/", pynimbusauthz.alias_type_s3)
self.assertEqual(alias2, None, "The alias should be gone")
def test_user_to_string(self):
user1 = User(self.db)
uu = user1.get_id()
self.assertEqual(str(user1), uu,
"toString function not working for user")
def create_user(self, display_name, id, pw, opts):
db_obj = DB(con_str=self.con_str)
user = User(db_obj, friendly=display_name)
user_alias = user.create_alias(id, "s3", display_name, alias_data=pw)
db_obj.commit()
db_obj.close()
def _convert_object_row_to_UserFile(db, row, args):
user_id = str(row[0])
f = args[0]
u = User(db, user_id)
return UserFile(f, u)
def create_user(self, display_name, id, pw, opts):
db_obj = DB(con_str=self.con_str)
user = User(db_obj, friendly=display_name)
user_alias = user.create_alias(id, "s3", display_name, alias_data=pw)
db_obj.commit()
db_obj.close()
class TestTouchCli(unittest.TestCase):
def setUp(self):
(osf, self.fname) = tempfile.mkstemp()
os.close(osf)
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
os.environ['NIMBUS_AUTHZ_DB'] = self.fname
pynimbusauthz.db.make_test_database(self.fname)
self.db = DB(con_str=self.fname)
self.user1 = User(self.db)
self.db.commit()
def tearDown(self):
self.db.close()
os.remove(self.fname)
def test_basic_touch(self):
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertEqual(f, None)
rc = pynimbusauthz.touch.main([self.user1.get_id(), fname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertNotEqual(f, None)
def test_bucket_touch(self):
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main([
"-t", pynimbusauthz.object_type_s3,
self.user1.get_id(), fname, data
])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
f = File.get_file(self.db, fname, pynimbusauthz.object_type_s3)
self.assertNotEqual(f, None)
def test_under_bucket_touch(self):
bname = str(uuid.uuid1())
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main([
"-t", pynimbusauthz.object_type_s3,
self.user1.get_id(), bname, data
])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
rc = pynimbusauthz.touch.main(
["-p", bname, self.user1.get_id(), fname, data])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
b1 = File.get_file(self.db, bname, pynimbusauthz.object_type_s3)
f1 = File.get_file(self.db,
fname,
pynimbusauthz.object_type_s3,
parent=b1)
self.assertNotEqual(b1, None)
self.assertNotEqual(f1, None)
def test_bad_opts(self):
bname = str(uuid.uuid1())
fname = str(uuid.uuid1())
data = str(uuid.uuid1())
rc = pynimbusauthz.touch.main([bname, data])
self.assertEqual(rc, 32, "CLI should return failure %d" % (rc))
rc = pynimbusauthz.touch.main(
["-p", bname, self.user1.get_id(), fname, data])
self.assertEqual(rc, 33, "CLI should return failure %d" % (rc))
def test_null_alias(self):
user1 = User(self.db)
all_alias = user1.get_all_alias()
self.assertEqual(len(list(all_alias)), 0, "No alias should be in DB for new user")
all_alias = user1.get_alias_by_type(pynimbusauthz.alias_type_s3)
self.assertEqual(len(list(all_alias)), 0, "No alias should be in DB for new user")
class TestChmodCli(unittest.TestCase):
def setUp(self):
(osf, self.fname) = tempfile.mkstemp()
os.close(osf)
# os.environ['CUMULUS_AUTHZ_DDL'] = "/home/bresnaha/Dev/Nimbus/nimbus/cumulus/authz/etc/acl.sql"
os.environ['NIMBUS_AUTHZ_DB'] = self.fname
pynimbusauthz.db.make_test_database(self.fname)
self.db = DB(con_str=self.fname)
self.user1 = User(self.db)
self.name = "/file/name"
self.data = "/etc/group"
self.file1 = File.create_file(self.db, self.name, self.user1,
self.data, pynimbusauthz.object_type_s3)
self.uf = UserFile(self.file1)
self.db.commit()
def tearDown(self):
self.db.close()
os.remove(self.fname)
def validate_perms(self, new):
f = File.get_file_from_db_id(self.db, self.file1.get_id())
uf = UserFile(f, self.user1)
perms = uf.get_perms(force=True)
for p in new:
self.assertTrue(p in perms,
"bad perms set %s != %s" % (new, perms))
self.assertEqual(len(perms), len(new),
"perms dont match %s != %s" % (new, perms))
def test_basic_chmod(self):
uu = str(uuid.uuid1())
new_perms = "WR"
rc = pynimbusauthz.chmod.main(
[self.user1.get_id(),
self.file1.get_name(), new_perms])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
self.validate_perms(new_perms)
def test_type_chmod(self):
uu = str(uuid.uuid1())
new_perms = "WRr"
rc = pynimbusauthz.chmod.main([
"-t",
self.file1.get_object_type(),
self.user1.get_id(),
self.file1.get_name(), new_perms
])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
self.validate_perms(new_perms)
def test_badopts(self):
new_perms = "WR"
rc = pynimbusauthz.chmod.main(
["-t", self.file1.get_object_type(),
self.user1.get_id()])
self.assertEqual(rc, 32, "CLI should return success %d" % (rc))
rc = pynimbusauthz.chmod.main(
[self.user1.get_id(), "notafile", new_perms])
self.assertEqual(rc, 33, "CLI should return success %d" % (rc))
rc = pynimbusauthz.chmod.main([
"-t",
self.file1.get_object_type(), "-p", "nobucket",
self.user1.get_id(),
self.file1.get_name(), new_perms
])
self.assertEqual(rc, 33, "CLI should return success %d" % (rc))
def test_bucket(self):
# create a file and a bucket
b1 = File.create_file(self.db, "bucket", self.user1, self.data,
pynimbusauthz.object_type_s3)
f2 = File.create_file(self.db,
self.name,
self.user1,
self.data,
pynimbusauthz.object_type_s3,
parent=b1)
self.db.commit()
new_perms = "WR"
rc = pynimbusauthz.chmod.main([
"-t",
f2.get_object_type(), "-p",
b1.get_name(),
self.user1.get_id(),
f2.get_name(), new_perms
])
self.assertEqual(rc, 0, "CLI should return success %d" % (rc))
def test_basic(self):
id = uuid.uuid1()
user1 = User(self.db, id, create=True)
self.db.rollback()
user1 = User(self.db, id, create=True)
def main(argv=sys.argv[1:]):
try:
con_str = pynimbusauthz.get_db_connection_string()
db_obj = DB(con_str=con_str)
(opts, args) = setup_options(argv)
user_uu = None
if len(args) == 1:
user_uu = args[0]
if opts.new:
user = User(db_obj,
user_uu,
friendly=opts.friendlyname,
create=True)
pynimbusauthz.print_msg(opts, 0, "User %s added" % (user.get_id()))
else:
user = User(db_obj, user_uu)
pynimbusauthz.print_msg(opts, 0, "User %s" % (user.get_id()))
if opts.alias != None:
user_alias = user.get_alias(opts.alias, opts.type)
if user_alias == None:
user_alias = user.create_alias(opts.alias, opts.type,
opts.friendlyname)
pynimbusauthz.print_msg(
opts, 0,
"Creating new alias %s:%s" % (opts.type, opts.alias))
if opts.genkey:
data = pynimbusauthz.random_string_gen(42)
pynimbusauthz.print_msg(opts, 0, "Key generated %s" % (data))
user_alias.set_data(data)
elif opts.setkey != None:
data = opts.setkey
user_alias.set_data(data)
pynimbusauthz.print_msg(opts, 0, "updated the alias key")
if opts.remove_alias != None:
user_alias = user.get_alias(opts.remove_alias, opts.type)
user_alias.remove()
if opts.remove:
pynimbusauthz.print_msg(opts, 1,
"Removing user %s" % (user.get_id()))
if opts.force:
pynimbusauthz.print_msg(opts, 1, "Removing all references")
user.destroy_brutally()
else:
user.destroy()
db_obj.commit()
except AuthzException, ae:
print ae
return ae.get_rc()
