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)