def project_rename(pid, new_name):
if not project_exists(pid):
run_utils.exit_fail("Project not found")
new_name = cleanup_project_name(new_name)
if new_name in all_project_names():
run_utils.exit_fail('name already used')
# remove users from the project
[admin_users, power_users, member_users] = [
project_members(pid, MembershipRoles.ADMIN),
project_members(pid, MembershipRoles.POWERUSER),
project_members(pid, MembershipRoles.MEMBER)
]
for uid in admin_users:
project_user_remove(pid, uid)
for uid in power_users:
feed_utils.info(uid)
for uid in member_users:
feed_utils.info(uid)
# set the new name of project
set_project_name(project_home(pid), new_name)
# add users back to the project
for uid in admin_users:
project_user_add(pid, uid, MembershipRoles.ADMIN)
for uid in power_users:
project_user_add(pid, uid, MembershipRoles.POWERUSER)
for uid in member_users:
project_user_add(pid, uid, MembershipRoles.MEMBER)
print("project renamed successfully")
def project_add(pid, name):
if project_exists(pid):
run_utils.exit_fail("Project with same project pid exists")
project_name = project_id_to_name(pid)
for role in ("", "-a", "-p"):
grp = "%s%s" % (project_name, role)
run_utils.launch_cmd("/usr/sbin/pw groupadd -n %s " % grp)
phome = project_home(pid)
run_utils.launch_cmd("/bin/mkdir %s " % phome)
admin_group = "%s-a" % project_name
run_utils.launch_cmd("/usr/sbin/chown -R root:%s %s" %
(admin_group, phome))
set_project_name(phome, cleanup_project_name(name))
storage_facade.permissions_strict_owner_only(phome)
run_utils.launch_cmd("/bin/chflags -h nosunlink %s" % phome)
acls = [
'everyone@:------a-R-c--s:------:allow',
'group@:r-xp--a-R-c--s:fd----:allow',
'owner@:rwxp-daARWcC-s:fd----:allow',
'group:%s:rwxp--a-R-cC-s:-d----:allow' % project_name,
'group:%s:r-x---a-R-cC-s:f-----:allow' % project_name,
'group:%s:----D---------:-d----:deny' % project_name,
'group:%s-p:rwxpD-aAR-cC-s:fd----:allow' % project_name,
'group:%s-a:rwxpD-aARWcCos:fd----:allow' % project_name
]
for acl in acls:
flag = ('-m' if ('@' in acl) else '-a0')
run_utils.launch_cmd("/bin/setfacl -h %s %s %s " % (flag, acl, phome))
print("project added successfully")
def project_del(pid):
if not project_exists(pid):
run_utils.exit_fail("Project not found")
for role in ("", "-a", "-p"):
grp = "%s%s" % (project_id_to_name(pid), role)
if not storage_facade.group_exists(grp):
continue
for nels_id in storage_facade.member_nels_ids(grp):
project_user_remove(pid, nels_id)
run_utils.launch_cmd("/usr/sbin/pw groupdel -n %s -q " % grp)
# caution, this deletes all files of the project
run_utils.launch_cmd("/bin/rm -rf %s" % project_home(pid))
print("project removed successfully")
def configure():
global PORT, ENCRYPTION_KEY, PORTAL_URL, CLIENT_CREDENTIAL_CLIENTS, IMPLICIT_CLIENTS
config_pth = path.join(ROOT_DIR, "config.json")
if not path.exists(config_pth):
run_utils.exit_fail("missing configuration file")
config_json = json.loads(file_utils.read_file_content(config_pth))
feed_utils.info(config_json)
PORT = int(config_json[ConfigKeys.port])
ENCRYPTION_KEY = config_json[ConfigKeys.encrytion_key]
PORTAL_URL = config_json[ConfigKeys.portal_url]
CLIENT_CREDENTIAL_CLIENTS = config_json[
ConfigKeys.oauth2_client_credentail_clients]
IMPLICIT_CLIENTS = config_json[ConfigKeys.oauth2_implicit_clients]
def project_user_remove(pid, uid):
if not is_user_member(pid, uid):
run_utils.exit_fail("User is not a member of the project")
proot = path.join(storage_facade.USERS_ROOT_DIR,
user_facade.nels_id_to_username(uid), "Projects")
plink = project_link_path(pid, uid)
for role in ["member", "poweruser", "admin"]:
run_utils.launch_cmd(
"/usr/sbin/pw groupmod -n %s -d %s " %
(role_to_group(pid, role), user_facade.nels_id_to_username(uid)))
if path.exists(plink):
run_utils.launch_cmd("/bin/chflags -h nosimmutable,nosunlink %s" %
proot)
run_utils.launch_cmd("/bin/rm -f %s " % plink)
run_utils.launch_cmd("/bin/chflags -h simmutable,sunlink %s" % proot)
def run_for_children(folder_path):
try:
ret = {}
for child in os.listdir(folder_path):
pth = path.join(folder_path, child)
if path.isdir(pth):
ret[child] = file_utils.get_tree_size(pth)
run_utils.exit_ok(json.dumps(ret, ensure_ascii=False, encoding='utf8'))
'''
cmd = "du -d 1 %s " % folder_path
(status, output) = run_utils.launch_cmd(cmd)
if not status == 0:
run_utils.exit_fail(output[0])
for line in output[0].split("\n"):
if "\t" not in line:
continue
[size, pth] = line.split("\t")
if not pth == folder_path:
ret[pth.replace(folder_path, "").replace("/","")] = int(size)
run_utils.exit_ok(json.dumps(ret, ensure_ascii=False, encoding='utf8'))
'''
except Exception as ex:
run_utils.exit_fail(ex)
from project import test_projects_list
from api import users, project
from utils import feed_utils, args_utils, mail_utils, run_utils
if __name__ == "__main__":
parser = OptionParser(usage='usage: %prog [-v] email project_name')
parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help='turn verbosity on', default=False)
parser.add_option('-n', '--notify', dest="notify", action="store_true", help='turn notification on', default=False)
(options, args) = parser.parse_args()
config.VERBOSE = options.verbose
feed_utils.NOTIFY = options.notify
args_utils.require_args_length(parser, args, 2)
email = str(args[0])
if not mail_utils.is_valid_email(email):
run_utils.exit_fail("invalid e-mail")
project_name = str(args[1])
nels_id = users.register_user(users.NELS_IDP, email, "Test-added-user", email, users.NORMAL_USER, True, "TEST")
if not nels_id:
run_utils.exit_fail("user registration failed")
test_users_list.test_user_display(nels_id)
project_id = project.add_project(project_name, 'added from integration test')
if not project_id:
feed_utils.failed("project creation failed")
else:
test_projects_list.test_project_display(project_id)
default_membership_type = 1
from optparse import OptionParser
import config
import test_projects_list
from api import project
from utils import args_utils, run_utils
if __name__ == "__main__":
parser = OptionParser(usage='usage: %prog name')
parser.add_option('-v',
'--verbose',
dest="verbose",
action="store_true",
help='turn verbosity on',
default=False)
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 1)
name = str(args[0])
project_id = project.add_project(name, 'added from integration test')
if not project_id:
run_utils.exit_fail("project creation failed")
test_projects_list.test_project_display(project_id)
if not project.delete_project(project_id):
run_utils.exit_fail("unable to delete project")
run_utils.exit_ok("project deleted successfully")
action="store_true",
help='turn verbosity on',
default=False)
# get options and arguments
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 1)
args_utils.require_arg_number(parser, args, 0, "project_id")
pid = args[0]
config.init()
feed_utils.heading("project info")
if not project_facade.project_exists(pid):
run_utils.exit_fail("project not found")
feed_utils.ok("project found\nname:\t%s\nhome folder:\t%s" %
(project_facade.project_name_by_id(pid),
project_facade.project_home(pid)))
feed_utils.push_in()
for role in [
project_facade.MembershipRoles.ADMIN,
project_facade.MembershipRoles.POWERUSER,
project_facade.MembershipRoles.MEMBER
]:
feed_utils.push_in()
members = project_facade.project_members(pid, role)
feed_utils.info("role:\t%s (members count: %s)" % (role, len(members)))
for uid in members:
for proj in result:
test_projects_list.test_project_display(proj['id'])
if __name__ == "__main__":
parser = OptionParser(
usage='usage: %prog [-v] [-i project_id] [-n name] : Note - at least one of the filters should be provided')
parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help='turn verbosity on', default=False)
parser.add_option('-i', '--nels_id', dest="project_id", help='the project id')
parser.add_option('-n', '--name', dest="name", help='project name')
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
project_id = None
name = None
if options.project_id:
if not string_utils.is_number(options.project_id):
run_utils.exit_fail("project_id should be number")
project_id = int(options.project_id)
if options.name:
name = options.name
if not project_id and not name:
parser.print_usage()
run_utils.exit_fail("at least one search parameter should be provided")
test_project_search(project_id=project_id, name=name)
from optparse import OptionParser
import config
from facades import user_facade
from utils import feed_utils, args_utils, run_utils
if __name__ == "__main__":
usage = 'usage: %prog [options] nels_id'
version = '%prog 1.0'
parser = OptionParser(usage=usage, version=version)
parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help='turn verbosity on', default=False)
# get options and arguments
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 1)
args_utils.require_arg_number(parser, args, 0, "nels_id")
nels_id = args[0]
config.init()
feed_utils.heading("user info")
if not user_facade.user_exists(nels_id):
run_utils.exit_fail("user not found")
feed_utils.ok("user found\nnels-id:\t%s\nusername:\t%s\nhome folder:\t%s" % (
nels_id, user_facade.nels_id_to_username(nels_id), user_facade.user_home(nels_id)))
from optparse import OptionParser
import test_users_list
from api import users
from utils import feed_utils, args_utils, mail_utils, run_utils
def test_user_registration(idp_number, federated_id, name, email, user_type_id, is_active, affiliation):
feed_utils.heading("Trying user registration")
new_id = users.register_user(idp_number, federated_id, name, email, user_type_id, is_active, affiliation)
if not new_id:
feed_utils.failed("user registration failed")
else:
feed_utils.ok("new user registered. nels_id: %s " % new_id)
test_users_list.test_user_display(new_id)
if __name__ == "__main__":
parser = OptionParser(usage='usage: %prog email')
parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help='turn verbosity on', default=False)
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 1)
email = str(args[0])
if not mail_utils.is_valid_email(email):
run_utils.exit_fail("invalid e-mail")
test_user_registration(users.NELS_IDP, email, "Test-added-user", email, users.NORMAL_USER, True, "TEST")
feed_utils.ok("recompute success")
return success
if __name__ == "__main__":
parser = OptionParser(usage='usage: %prog [-v] [-n] ')
parser.add_option('-v',
'--verbose',
dest="verbose",
action="store_true",
help='turn verbosity on',
default=False)
parser.add_option('-n',
'--notify',
dest="notify",
action="store_true",
help='turn notification on',
default=False)
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
feed_utils.NOTIFY = options.notify
success = test_recompute_disc_usage()
if success:
run_utils.exit_ok(
"", "sbi recompute project disc usage integration test: ok")
run_utils.exit_fail(
"", "sbi recompute project disc usage integration test: failed")
if __name__ == "__main__":
usage = 'usage: %prog [options] nels_id link_to_clean'
version = '%prog 1.0'
parser = OptionParser(usage=usage, version=version)
parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help='turn verbosity on', default=False)
# get options and arguments
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 2)
args_utils.require_arg_number(parser, args, 0, "nels_id")
config.init()
proot = path.join(storage_facade.USERS_ROOT_DIR, user_facade.nels_id_to_username(int(args[0])), "Projects")
plink = path.join(proot, args[1])
if not path.exists(plink):
run_utils.exit_fail("symbolic link not found")
# unlock folder, remove link and lock folder again
run_utils.launch_cmd("/bin/chflags -h nosimmutable,nosunlink %s" % proot)
run_utils.launch_cmd("/bin/rm -f %s " % plink)
run_utils.launch_cmd("/bin/chflags -h simmutable,sunlink %s" % proot)
#verify
if path.exists(plink):
feed_utils.failed("link still exists")
else:
feed_utils.ok("link removed successfully")
parser.add_option('-v',
'--verbose',
dest="verbose",
action="store_true",
help='turn verbosity on',
default=False)
parser.add_option('-c',
'--children',
dest="children",
action="store_true",
help='return size of children folders',
default=False)
# get options and arguments
(options, args) = parser.parse_args()
feed_utils.VERBOSE = options.verbose
args_utils.require_args_length(parser, args, 1)
folder_path = args[0]
config.init()
if not path.exists(folder_path):
run_utils.exit_fail("folder not found: %s" % folder_path)
if not path.isdir(folder_path):
run_utils.exit_fail("path not a folder: %s" % folder_path)
if options.children:
run_for_children(folder_path)
else:
run_for_self(folder_path)
