Beispiel #1
0
def user_apply():

    form = UserRegistrationForm(request.form)

    if request.method == 'POST': #and form.validate():
        data = dict(request.form)
        action = str(data['button'][0])

        for key in data:
            data[key] = data[key][0]
        del data['button']

        if action == 'save':
            users = Users()
            user = MongoUser()
            del data['confirm']
            for d in data:
                user[d] = data[d]

            users.add(user)

        flash('Thanks for registering')
        return redirect('/')

    user_config = ConfigDict(filename=config_file("/cloudmesh_user_intf.yaml"))
    user_fields = user_config.get("cloudmesh.user")
    return render_template('management/user_apply.html',
                           title="User Application",
                           states=['save', 'cancel'],
                           fields=user_fields,
                           countries_list=[c for c in country_list()],
                           roles_list=roles)
Beispiel #2
0
    def setup_inventory(self):
        banner("Read Dicts")
        self.sample_user = ConfigDict(filename=config_file("/me.yaml"))
        self.portalname = self.sample_user.get("portalname")
        print("PORTALNAME", self.portalname)
        print("SAMPLE USER", self.sample_user)

        banner("create user from template, duplicates cm init generate me")
        t = cm_template(config_file("/etc/cloudmesh.yaml"))
        pprint(set(t.variables()))

        self.config = t.replace(kind="dict", values=self.sample_user)

        print(type(self.config))
        print(self.config)

        #
        # BUG?
        #
        self.idp = cm_userLDAP()
        self.idp.connect("fg-ldap", "ldap")
        self.idp.refresh()

        ldap_info = self.idp.get(self.portalname)
        print(ldap_info)
        print(type(self.config))

        self.config['cloudmesh']['projects'] = ldap_info['projects']
        self.config['cloudmesh']['keys'] = ldap_info['keys']
        try:
            self.config['cloudmesh']['projects'][
                'deafult'] = ldap_info['projects']['active'][0]
        except:
            print("ERROR: you have no projects")
Beispiel #3
0
    def create_user_from_file(cls, file_path):
        try:
            filename = path_expand(file_path)
            file_config = ConfigDict(filename=filename)
        except:
            Console.error("Could not load file, please check filename and its path")
            return

        try:
            user_config = file_config.get("cloudmesh", "user")
            user_name = user_config['username']
            user = User()
            update_document(user, user_config)
        except:
            Console.error("Could not get user information from yaml file, "
                          "please check you yaml file, users information must be "
                          "under 'cloudmesh' -> 'users' -> user1...")
            return

        try:
            if cls.check_exists(user_name) is False:
                cls.add(user)
                Console.info("User created in the database.")
            else:
                Console.error("User with user name " + user_name + " already exists.")
                return
        except:
            Console.error("User creation in database failed, " + str(sys.exc_info()))
            return
Beispiel #4
0
    def create_project_from_file(cls, file_path):
        # implement()
        # return
        try:
            filename = path_expand(file_path)
            file_config = ConfigDict(filename=filename)
        except:
            Console.error("Could not load file, please check filename and its path")
            return

        try:
            project_config = file_config.get("cloudmesh", "project")
            project = Project()
            project_id = uuid.uuid4()
            project_config.update({'project_id': project_id})
            update_document(project, project_config)
        except:
            Console.error("Could not get project information from yaml file, "
                          "please check you yaml file, users information must be "
                          "under 'cloudmesh' -> 'project' -> project1..." + str(sys.exc_info()[0]))
            return

        try:
            cls.add(project)
            Console.info("Project created in the database.")
        except:
            Console.error("Project creation in database failed, " + str(sys.exc_info()))
        return
Beispiel #5
0
def user_apply():

    form = UserRegistrationForm(request.form)

    if request.method == 'POST':  #and form.validate():
        data = dict(request.form)
        action = str(data['button'][0])

        for key in data:
            data[key] = data[key][0]
        del data['button']

        if action == 'save':
            users = Users()
            user = MongoUser()
            del data['confirm']
            for d in data:
                user[d] = data[d]

            users.add(user)

        flash('Thanks for registering')
        return redirect('/')

    user_config = ConfigDict(filename=config_file("/cloudmesh_user_intf.yaml"))
    user_fields = user_config.get("cloudmesh.user")
    return render_template('management/user_apply.html',
                           title="User Application",
                           states=['save', 'cancel'],
                           fields=user_fields,
                           countries_list=[c for c in country_list()],
                           roles_list=roles)
    def readRackConfig(self, name, dir_yaml, dir_diag):
        rack_config = ConfigDict(filename=dir_yaml + "/" +
                                 self.default_rack_yaml)
        self.dict_rack_config = rack_config.get("cloudmesh.rack")

        lname = name.lower()
        # the rack name in cloudmesh_rack.yaml MUST be valid/predefined in
        # clouldmesh_cluster.yaml
        self.cluster_name = lname if lname in self.cluster_name_list else self.cluster_name_unknown

        # diag filename and temporary diag filename
        self.filename_diag = dir_diag + "/" + \
            self.dict_rack_config["cluster"][self.cluster_name]["diag"]
        self.rack_count = self.dict_rack_config["cluster"][
            self.cluster_name]["count"]
        self.filename_diag_temp = self.filename_diag + ".temp"

        # additional process for 'all'
        # its count equals the sum of all other cluster exclude 'all' and
        # 'unknown'
        if name == "all":
            raw_set = set(self.dict_rack_config["cluster"].keys())
            exclude_set = set(["all", "unknown"])
            all_set = raw_set - exclude_set
            self.rack_count = 0
            for rack in all_set:
                self.rack_count += self.dict_rack_config["cluster"][rack][
                    "count"]
Beispiel #7
0
    def readRackConfig(self, name, dir_yaml, dir_diag):
        rack_config = ConfigDict(
            filename=dir_yaml + "/" + self.default_rack_yaml)
        self.dict_rack_config = rack_config.get("cloudmesh.rack")

        lname = name.lower()
        # the rack name in cloudmesh_rack.yaml MUST be valid/predefined in
        # clouldmesh_cluster.yaml
        self.cluster_name = lname if lname in self.cluster_name_list else self.cluster_name_unknown

        # diag filename and temporary diag filename
        self.filename_diag = dir_diag + "/" + \
            self.dict_rack_config["cluster"][self.cluster_name]["diag"]
        self.rack_count = self.dict_rack_config[
            "cluster"][self.cluster_name]["count"]
        self.filename_diag_temp = self.filename_diag + ".temp"

        # additional process for 'all'
        # its count equals the sum of all other cluster exclude 'all' and
        # 'unknown'
        if name == "all":
            raw_set = set(self.dict_rack_config["cluster"].keys())
            exclude_set = set(["all", "unknown"])
            all_set = raw_set - exclude_set
            self.rack_count = 0
            for rack in all_set:
                self.rack_count += self.dict_rack_config[
                    "cluster"][rack]["count"]
Beispiel #8
0
def get_ldap_user_from_yaml():
    me = ConfigDict(filename=config_file("/me.yaml"))
    d = {}
    for element in ["firstname",
                    "lastname",
                    "email",
                    "phone",
                    "address"]:
        d[element] = me.get("profile.{0}".format(element))
    d["cm_user_id"] = me.get("portalname")
    d["gidNumber"] = 0
    d["uidNumber"] = 0

    if "gidNumber" in me.keys():
        d["gidNumber"] = me.get("gidNumber")

    if "uidNumber" in me.keys():
        d["uidNumber"] = me.get("uidNumber")

    d["projects"] = me.get("projects")

    #
    # copy the keys
    #
    d['keys'] = me.get("keys.keylist")
    return d
Beispiel #9
0
 def test_getitem_server(self):
     HEADING()
     filename = config_file("/cloudmesh_server.yaml")
     config = ConfigDict(filename=filename)
     print(config)
     existing = config.get("cloudmesh.server.mongo.db")
     test1 = existing is not None
     print("QUERY", existing)
     print("Port", config.get("cloudmesh.server.mongo.port"))
Beispiel #10
0
    def set_debug(self, on):
        filename = path_expand("~/.cloudmesh/cmd3.yaml")
        config = ConfigDict(filename=filename)
        if type(on) == bool:
            self.debug = on
        else:
            self.debug = on.lower() in ['on', 'true']

        config["cmd3"]["properties"]["debug"] = self.debug
        Console.ok("Debug mode is {:}".format(self.debug))
        config.write(filename=filename, output="yaml", attribute_indent="    ")
Beispiel #11
0
 def __init__(self, username, filename, Credential, style=2.0, password=None):
     config = ConfigDict(filename=filename)
     self.password = password
     self[username] = {}
     for cloud in config.get("cloudmesh.clouds").keys():
         self[username][cloud] = Credential(username,
                                            cloud,
                                            filename,
                                            style=style,
                                            password=self.password)
         self.encrypt(username, cloud, style)
Beispiel #12
0
    def set_debug(self, on):
        filename = path_expand("~/.cloudmesh/cmd3.yaml")
        config = ConfigDict(filename=filename)
        if type(on) == bool:
            self.debug = on
        else:
            self.debug = on.lower() in ['on', 'true']

        config["cmd3"]["properties"]["debug"] = self.debug
        Console.ok("Debug mode is {:}".format(self.debug))
        config.write(filename=filename, output="yaml", attribute_indent="    ")
Beispiel #13
0
def view(link=""):
    """run the browser"""
    from cloudmesh_base.ConfigDict import ConfigDict

    server_config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))

    host = server_config.get("cloudmesh.server.webui.host")
    port = server_config.get("cloudmesh.server.webui.port")

    url_link = "http://{0}:{1}/{2}".format(host, port, link)

    local("%s %s" % (web_browser, url_link))
Beispiel #14
0
def view(link=""):
    """run the browser"""
    from cloudmesh_base.ConfigDict import ConfigDict

    server_config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))

    host = server_config.get("cloudmesh.server.webui.host")
    port = server_config.get("cloudmesh.server.webui.port")

    url_link = "http://{0}:{1}/{2}".format(host, port, link)

    local("%s %s" % (web_browser, url_link))
Beispiel #15
0
def project_apply():

    form = ProjectRegistrationForm(request.form)
    if request.method == 'POST' and form.validate():
        data = dict(request.form)
        action = str(data['button'][0])

        print "Project Data"
        print data

        for key in data:
            if key in [
                    'agreement_use', 'agreement_slides', 'agreement_support',
                    'agreement_software', 'agreement_documentation',
                    'join_open', 'join_notification'
            ]:
                if str(data[key][0]) == 'y':
                    data[key] = True
                elif str(data[key][0]) == 'n':
                    data[key] = False
            elif key in [
                    'category', 'managers', 'resources_clusters', 'alumni',
                    'resources_provision', 'resources_services', 'members',
                    'keywords'
            ]:
                print data[key][0]
            else:
                data[key] = data[key][0]
            print str(key) + " - " + str(data[key]) + "\n"

        del data['button']

        if action == 'save':
            projects = Projects()
            project = MongoProject()
            for d in data:
                project[d] = data[d]
            print project
            projects.add(project)

        flash('Thanks for registering')
        return redirect('/')
    project_config = ConfigDict(
        filename=config_file("/cloudmesh_project_intf.yaml"))
    project_fields = project_config.get("cloudmesh.project")
    return render_template('management/project_apply.html',
                           title="Project Application",
                           states=['save', 'cancel'],
                           fields=project_fields,
                           countries_list=[c for c in country_list()],
                           states_list=[c for c in states_list()],
                           disciplines_list=[c for c in disciplines_list()])
Beispiel #16
0
    def load(self, yaml_filename=None):
        """
        Loads the cloudmesh pbs yaml file.

        :param yaml_filename: The filename of the yaml file
        """
        log.debug("PBS yaml filename: {0}".format(self.yaml_filename))
        if yaml_filename is None:
            yaml_filename = self.yaml_filename
        else:
            self.yaml_filename = config_file(yaml_filename)
        self.data = ConfigDict(filename=self.yaml_filename)
        self.hosts = ssh_config()
Beispiel #17
0
def display_launch_table():
    """ To satisfy Pylint. Will update with proper comments """
    if request.method == 'POST':
        print "HHHHHH", request.form.keys()
        for key in request.form.keys():
            print key, ":", request.form[key]
    else:
        print "HEY JUDE"

    launcher_config = ConfigDict(
        filename=config_file("/cloudmesh_launcher.yaml"))
    launch_recipies = launcher_config.get("cloudmesh.launcher.recipies")
    return render_template('mesh/mesh_launch.html', recipies=launch_recipies)
Beispiel #18
0
 def __init__(self, quiet=False):
     self.quiet = quiet
     try:
         self.filename = config_file("/cmd3.yaml")
         if not self.quiet:
             Console.ok("Reading " + self.filename + ". ok.")
     except:
         Console.error("problem loading cmd3.yaml file")
     try:
         self.config = ConfigDict(filename=self.filename)
         # print(self.config)
     except Exception as e:
         Console.error("problem with ConfigDict")
         print(e)
Beispiel #19
0
def display_launch_table():
    """ To satisfy Pylint. Will update with proper comments """
    if request.method == 'POST':
        print "HHHHHH", request.form.keys()
        for key in request.form.keys():
            print key, ":", request.form[key]
    else:
        print "HEY JUDE"

    launcher_config = ConfigDict(
        filename=config_file("/cloudmesh_launcher.yaml"))
    launch_recipies = launcher_config.get("cloudmesh.launcher.recipies")
    return render_template('mesh/mesh_launch.html',
                           recipies=launch_recipies)
Beispiel #20
0
 def test_launcher(self):
     HEADING()
     filename = config_file("/cloudmesh_launcher.yaml")
     config = ConfigDict(filename=filename)
     print(config)
     existing = config.get("cloudmesh.launcher.recipies")
     test1 = existing is not None
     print(existing)
     try:
         none_existing = config.get("cloudmesh.launcher.recipies.xyz")
         test2 = False
     except:
         print("Error")
         test2 = True
     assert test1 and test2
Beispiel #21
0
 def test_server(self):
     HEADING()
     filename = config_file("/cloudmesh_server.yaml")
     config = ConfigDict(filename=filename)
     # print config
     existing = config.get("cloudmesh.server.mongo.db")
     test1 = existing is not None
     print("mongo.db =", existing)
     try:
         none_existing = config.get("cloudmesh.server.mongo.xyz")
         test2 = False
     except:
         print("Error")
         test2 = True
     assert test1 and test2
Beispiel #22
0
class PBSDeploy(object):

    def load(self):
        self.filename = config_file("/cloudmesh_pbs.yaml")
        self.data = ConfigDict(filename=self.filename)

    def __init__(self, deploy=False):
        if deploy:
            self.deploy()
        self.load()

    def __str__(self):
        return self.data.json()

    @staticmethod
    def deploy(force=True):
        """copies the yaml file from etc in the distribution to the .cloudmesh
        directory. If the file exits it will not be copied and a warning is
        thrown. If the file is the same as in etc no warning is thrown.
        """
        xcopy("../etc/", "~/.cloudmesh", "*.yaml", force=force)

    def servers(self):
        return self.data["cloudmesh"]["pbs"].keys()

    def queues(self, server):
        server = self.data["cloudmesh"]["pbs"][server]
        if "queues" in server:
            return server["queues"]
        else:
            return None

    @staticmethod
    def qstat(host):
        return Shell.ssh(host, "qstat").rstrip()
Beispiel #23
0
class PBSDeploy(object):
    def load(self):
        self.filename = config_file("/cloudmesh_pbs.yaml")
        self.data = ConfigDict(filename=self.filename)

    def __init__(self, deploy=False):
        if deploy:
            self.deploy()
        self.load()

    def __str__(self):
        return self.data.json()

    @staticmethod
    def deploy(force=True):
        """copies the yaml file from etc in the distribution to the .cloudmesh
        directory. If the file exits it will not be copied and a warning is
        thrown. If the file is the same as in etc no warning is thrown.
        """
        xcopy("../etc/", "~/.cloudmesh", "*.yaml", force=force)

    def servers(self):
        return self.data["cloudmesh"]["pbs"].keys()

    def queues(self, server):
        server = self.data["cloudmesh"]["pbs"][server]
        if "queues" in server:
            return server["queues"]
        else:
            return None

    @staticmethod
    def qstat(host):
        return Shell.ssh(host, "qstat").rstrip()
Beispiel #24
0
class Test_cloudmesh:

    username = ConfigDict(
        filename=config_file("/cloudmesh.yaml")).get("cloudmesh.hpc.username")

    filename = "etc/cloudmesh.yaml"

    def setup(self):
        self.idp = cm_userLDAP()
        self.idp.connect("fg-ldap", "ldap")
        self.idp.refresh()

    def tearDown(self):
        pass

    def test_me(self):
        print("USERNAME", self.username)
        user = self.idp.find_one({'cm_user_id': self.username})
        print(user)

    def test_list(self):
        users = self.idp.list()
        pprint(users)
        pprint(self.idp.users)

    def test_auth(self):
        password = getpass.getpass()
        if self.idp.authenticate(self.username, password):
            print("SUCCESS")
        else:
            print("FAILED")
Beispiel #25
0
 def __init__(self,
              username,
              filename,
              Credential,
              style=2.0,
              password=None):
     config = ConfigDict(filename=filename)
     self.password = password
     self[username] = {}
     for cloud in config.get("cloudmesh.clouds").keys():
         self[username][cloud] = Credential(username,
                                            cloud,
                                            filename,
                                            style=style,
                                            password=self.password)
         self.encrypt(username, cloud, style)
Beispiel #26
0
def shell_command_open_web(arguments):
    """
    ::

      Usage:
          web [--fg|--cm] [LINK]

      Arguments:

          LINK    the link on the localhost cm server is opened.

      Options:

          -v         verbose mode
          --fg       opens a link on the FG portal
          --cm       opens a link on the CM portal

      Description:

          Opens a web page with the specified link

    """

    link = arguments["LINK"]
    if link is None or link == "/":
        link = ""

    web_browser = "firefox"
    if sys.platform == 'darwin':
        web_browser = "open"

    if arguments["--fg"]:
        location = "https://portal.futuregrid.org"
    elif arguments["--cm"]:
        location = "https://cloudmesh.futuregrid.org"
    else:
        try:
            filename = config_file("/cloudmesh_server.yaml")
            server_config = ConfigDict(filename=filename)

            host = server_config.get("cloudmesh.server.webui.host")
            port = server_config.get("cloudmesh.server.webui.port")
            location = "http://{0}:{1}".format(host, port)
        except Exception, e:
            print("ERROR: some error reading from the config file")
            print(e)
            return
Beispiel #27
0
def project_apply():

    form = ProjectRegistrationForm(request.form)
    if request.method == 'POST' and form.validate():
        data = dict(request.form)
        action = str(data['button'][0])

        print "Project Data"
        print data

        for key in data:
            if key in ['agreement_use','agreement_slides','agreement_support',
                       'agreement_software','agreement_documentation', 'join_open',
                       'join_notification']:
                if str(data[key][0]) == 'y':
                    data[key] = True
                elif str(data[key][0]) == 'n':
                    data[key] = False
            elif key in ['category', 'managers', 'resources_clusters', 'alumni',
                         'resources_provision', 'resources_services', 'members',
                         'keywords']:
                print data[key][0]
            else:
                 data[key] = data[key][0]
            print str(key)+" - "+str(data[key])+"\n"

        del data['button']

        if action == 'save':
            projects = Projects()
            project = MongoProject()
            for d in data:
                project[d] = data[d]
            print project
            projects.add(project)

        flash('Thanks for registering')
        return redirect('/')
    project_config = ConfigDict(filename=config_file("/cloudmesh_project_intf.yaml"))
    project_fields = project_config.get("cloudmesh.project")
    return render_template('management/project_apply.html',
                           title="Project Application",
                           states=['save', 'cancel'],
                           fields=project_fields,
                           countries_list=[c for c in country_list()],
                           states_list = [c for c in states_list()],
                           disciplines_list = [c for c in disciplines_list()])
Beispiel #28
0
def shell_command_open_web(arguments):
    """
    ::

      Usage:
          web [--fg|--cm] [LINK]

      Arguments:

          LINK    the link on the localhost cm server is opened.

      Options:

          -v         verbose mode
          --fg       opens a link on the FG portal
          --cm       opens a link on the CM portal

      Description:

          Opens a web page with the specified link

    """

    link = arguments["LINK"]
    if link is None or link == "/":
        link = ""

    web_browser = "firefox"
    if sys.platform == 'darwin':
        web_browser = "open"

    if arguments["--fg"]:
        location = "https://portal.futuregrid.org"
    elif arguments["--cm"]:
        location = "https://cloudmesh.futuregrid.org"
    else:
        try:
            filename = config_file("/cloudmesh_server.yaml")
            server_config = ConfigDict(filename=filename)

            host = server_config.get("cloudmesh.server.webui.host")
            port = server_config.get("cloudmesh.server.webui.port")
            location = "http://{0}:{1}".format(host, port)
        except Exception, e:
            print("ERROR: some error reading from the config file")
            print(e)
            return
Beispiel #29
0
    def test_gregor(self):

        banner("ME")
        id = ConfigDict(filename=config_file("/me.yaml")).get("portalname")
        user = cm_user()
        result = user.info(id)
        pprint(result)
        pass
Beispiel #30
0
    def __init__(self):
        # read the host file definition from cloudmesh_cluster.yaml
        self.server_config = cm_config_server()

        self.config = ConfigDict(filename=self.CONFIG_FILE)

        collection = "inventory"
        self.db_inventory = get_mongo_db(collection)
Beispiel #31
0
    def connect(self, **kwargs):
        """
        The method is used to get a connection to a specified database. The hostname and port is being read from the
        cloudmesh_server.yaml file. If the username and password is not mentioned as part of the command line
        arguments, the details are read from the cloudmesh_server.yaml file. If the details are not available in the
        yaml file, it tried to connect without the credentials.

        :param kwargs:
                    Can contain credentials for authentication to the database.

        :return:
                Connection object to the specified server.
        """
        self.DB_CONFIG = {}
        config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))
        mongo_config = config.get("cloudmesh", "server", "mongo")
        #
        self.DB_CONFIG["host"] = mongo_config["host"]
        self.DB_CONFIG["port"] = int(mongo_config["port"])
        self.DB_CONFIG["username"] = mongo_config["username"]
        self.DB_CONFIG["password"] = mongo_config["password"]
        #
        for key, value in kwargs.iteritems():
            if key == "user_name":
                if value:
                    self.DB_CONFIG["username"] = value
            elif key == "pwd":
                if value:
                    self.DB_CONFIG["password"] = value

        if self.DB_CONFIG["username"] and self.DB_CONFIG["password"]:
            uri = "mongodb://{0}:{1}@{2}:{3}".format(
                self.DB_CONFIG["username"], self.DB_CONFIG["password"],
                self.DB_CONFIG["host"], self.DB_CONFIG["port"])
        else:
            uri = "mongodb://{0}:{1}".format(self.DB_CONFIG["host"],
                                             self.DB_CONFIG["port"])

        try:
            return MongoClient(uri)
        except:
            Console.error(
                "Failed to connect to Mongoclient DB. May be an authentication issue.\n\t "
            )
        pass
Beispiel #32
0
    def connect(self, **kwargs):
        """
        The method is used to get a connection to a specified database. The hostname and port is being read from the
        cloudmesh_server.yaml file. If the username and password is not mentioned as part of the command line
        arguments, the details are read from the cloudmesh_server.yaml file. If the details are not available in the
        yaml file, it tried to connect without the credentials.

        :param kwargs:
                    Can contain credentials for authentication to the database.

        :return:
                Connection object to the specified server.
        """
        self.DB_CONFIG = {}
        config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))
        mongo_config = config.get("cloudmesh", "server", "mongo")
        #
        self.DB_CONFIG["host"] = mongo_config["host"]
        self.DB_CONFIG["port"] = int(mongo_config["port"])
        self.DB_CONFIG["username"] = mongo_config["username"]
        self.DB_CONFIG["password"] = mongo_config["password"]
        #
        for key, value in kwargs.iteritems():
            if key == "user_name":
                if value:
                    self.DB_CONFIG["username"] = value
            elif key == "pwd":
                if value:
                    self.DB_CONFIG["password"] = value

        if self.DB_CONFIG["username"] and self.DB_CONFIG["password"]:
            uri = "mongodb://{0}:{1}@{2}:{3}".format(self.DB_CONFIG["username"],
                                                     self.DB_CONFIG["password"],
                                                     self.DB_CONFIG["host"],
                                                     self.DB_CONFIG["port"])
        else:
            uri = "mongodb://{0}:{1}".format(self.DB_CONFIG["host"],
                                             self.DB_CONFIG["port"])

        try:
            return MongoClient(uri)
        except:
            Console.error("Failed to connect to Mongoclient DB. May be an authentication issue.\n\t ")
        pass
Beispiel #33
0
    def load(self, filename):
        """
        loads the configuration from the yaml filename

        :param filename:
        :type filename: string
        :return:
        """

        self.data = BaseConfigDict(filename=Config.path_expand(filename))
Beispiel #34
0
def password():
    user_config = cm_config(filename=config_file("/cloudmesh.yaml"))
    user = user_config.cloud('india')['credentials']

    server_config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))
    server = server_config.get('cloudmesh.server.keystone.india')

    print(" ".join([
        "keystone", "--os-username", server['OS_USERNAME'], "--os-password",
        server['OS_PASSWORD'], "--os-tenant-name", server['OS_TENANT_NAME'],
        "--os-auth-url", server['OS_AUTH_URL'], "user-password-update",
        "--pass", user['OS_PASSWORD'], user['OS_USERNAME']
    ]))

    Shell.keystone("--os-username", server['OS_USERNAME'], "--os-password",
                   server['OS_PASSWORD'], "--os-tenant-name",
                   server['OS_TENANT_NAME'], "--os-auth-url",
                   server['OS_AUTH_URL'], "user-password-update", "--pass",
                   user['OS_PASSWORD'], user['OS_USERNAME'])
Beispiel #35
0
    def __init__(self):
        config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))
        port = config['cloudmesh']['server']['mongo']['port']

        # db = connect('manage', port=port)
        self.users = User.objects()

        dbname = get_mongo_dbname_from_collection("manage")
        if dbname:
            meta = {'db_alias': dbname}
Beispiel #36
0
def check(username=None):
    """clean the dirs"""
    if username is None:
        # bug for some reason the get method does not work
        # useranme = ConfigDict(filename=config_file("/cloudmesh.yaml")).get("cloudmesh.hpc.username")
        username = ConfigDict(filename=config_file(
            "/cloudmesh.yaml"))["cloudmesh"]["hpc"]["username"]
        print "Username: "******"india"]:
        local("ssh %s@%s.futuregrid.org hostname -a" % (username, host))
Beispiel #37
0
def metric_index():

    metric = "metric-summary"
    term = "last_3_months"
    config = ConfigDict(filename=config_file(
        "/cloudmesh_server.yaml"))["cloudmesh"]["server"]["metric"]
    address = "{0}:{1}/{2}/{3}".format(
        config["host"], config["port"], metric, term)
    r = requests.get(address)

    return render_template('/metric/index.html', data=r.text)
Beispiel #38
0
    def generate(self, me_file, out_file):
        cloudmesh_yaml = path_expand(self.filename)
        user_config = ConfigDict(filename=me_file)
        t = cm_template(cloudmesh_yaml)

        result = t.replace(kind="dict", values=user_config)
        location = path_expand(out_file)
        yaml_file = open(location, 'w+')
        print(yaml.dump(result, default_flow_style=False), file=yaml_file)
        yaml_file.close()
        log.info("Written new yaml file in " + location)
Beispiel #39
0
    def __init__(self,
                 username,
                 cloud,
                 datasource=None,
                 yaml_version=2.0,
                 style=2.0,
                 password=None):
        """datasource is afilename"""
        CredentialBaseClass.__init__(self, username, cloud, datasource)

        self.password = password

        if datasource is not None:
            self.filename = datasource
        else:
            self.filename = "~/.cloudmesh/cloudmesh.yaml"

        self.config = ConfigDict(filename=self.filename)

        self.read(username, cloud, style=style)
Beispiel #40
0
def password():
    user_config = cm_config(filename=config_file("/cloudmesh.yaml"))
    user = user_config.cloud('india')['credentials']

    server_config = ConfigDict(filename=config_file("/cloudmesh_server.yaml"))
    server = server_config.get('cloudmesh.server.keystone.india')

    print(" ".join(["keystone", "--os-username", server['OS_USERNAME'],
                    "--os-password", server['OS_PASSWORD'],
                    "--os-tenant-name", server['OS_TENANT_NAME'],
                    "--os-auth-url", server['OS_AUTH_URL'],
                    "user-password-update",
                    "--pass", user['OS_PASSWORD'], user['OS_USERNAME']]))

    Shell.keystone("--os-username", server['OS_USERNAME'],
                   "--os-password", server['OS_PASSWORD'],
                   "--os-tenant-name", server['OS_TENANT_NAME'],
                   "--os-auth-url", server['OS_AUTH_URL'],
                   "user-password-update",
                   "--pass", user['OS_PASSWORD'], user['OS_USERNAME'])
Beispiel #41
0
    def do_loglevel(self, args, arguments):
        """
        ::

          Usage:
              loglevel
              loglevel critical
              loglevel error
              loglevel warning
              loglevel info
              loglevel debug

              Shows current log level or changes it.

              loglevel - shows current log level
              critical - shows log message in critical level
              error    - shows log message in error level including critical
              warning  - shows log message in warning level including error
              info     - shows log message in info level including warning
              debug    - shows log message in debug level including info

        """
        if arguments['debug']:
            self.loglevel = "DEBUG"
        elif arguments['error']:
            self.loglevel = "ERROR"
        elif arguments['warning']:
            self.loglevel = "WARNING"
        elif arguments['info']:
            self.loglevel = "INFO"
        elif arguments['critical']:
            self.loglevel = "CRITICAL"
        else:
            Console.ok("Log level: {0}".format(self.loglevel))
            return
        Console.ok ("Log level: {0} is set".format(self.loglevel))

        filename = path_expand("~/.cloudmesh/cmd3.yaml")
        config = ConfigDict(filename=filename)
        config["cmd3"]["properties"]["loglevel"] = self.loglevel
        config.write(filename=filename, output="yaml", attribute_indent="    ")
Beispiel #42
0
    def do_loglevel(self, args, arguments):
        """
        ::

          Usage:
              loglevel
              loglevel critical
              loglevel error
              loglevel warning
              loglevel info
              loglevel debug

              Shows current log level or changes it.

              loglevel - shows current log level
              critical - shows log message in critical level
              error    - shows log message in error level including critical
              warning  - shows log message in warning level including error
              info     - shows log message in info level including warning
              debug    - shows log message in debug level including info

        """
        if arguments['debug']:
            self.loglevel = "DEBUG"
        elif arguments['error']:
            self.loglevel = "ERROR"
        elif arguments['warning']:
            self.loglevel = "WARNING"
        elif arguments['info']:
            self.loglevel = "INFO"
        elif arguments['critical']:
            self.loglevel = "CRITICAL"
        else:
            Console.ok("Log level: {0}".format(self.loglevel))
            return
        Console.ok("Log level: {0} is set".format(self.loglevel))

        filename = path_expand("~/.cloudmesh/cmd3.yaml")
        config = ConfigDict(filename=filename)
        config["cmd3"]["properties"]["loglevel"] = self.loglevel
        config.write(filename=filename, output="yaml", attribute_indent="    ")
Beispiel #43
0
    def do_admin(self, args, arguments):
        """
        ::

          Usage:
            admin password reset
            admin password

          Options:


          Description:
            admin password reset
              Reset portal password

        """
        pprint(arguments)

        if arguments["password"] and arguments["reset"]:
            Console.ok("password reset ...")

            self.password = getpass("Password:"******"~/.cloudmesh/cmd3.yaml")
            config = ConfigDict(filename=filename)
            config["cmd3"]["properties"]["password"] = self.password
            config.write(filename=filename, output="yaml")
            Console.ok("Resetting password. ok.")

        elif arguments["password"]:

            if yn_choice("Would you like to print the password?"):
                filename = path_expand("~/.cloudmesh/cmd3.yaml")
                config = ConfigDict(filename=filename)
                try:
                    self.password = config["cmd3"]["properties"]["password"]
                except Exception:
                    Console.error("could not find the password. Please set it.")
                    return
                Console.msg("Password: {:}".format(self.password))
Beispiel #44
0
    def load(self, yaml_filename=None):
        """
        Loads the cloudmesh pbs yaml file.

        :param yaml_filename: The filename of the yaml file
        """
        log.debug("PBS yaml filename: {0}".format(self.yaml_filename))
        if yaml_filename is None:
            yaml_filename = self.yaml_filename
        else:
            self.yaml_filename = config_file(yaml_filename)
        self.data = ConfigDict(filename=self.yaml_filename)
        self.hosts = ssh_config()
Beispiel #45
0
class setup_management(object):
    def __init__(self, quiet=False):
        self.quiet = quiet
        try:
            self.filename = config_file("/cmd3.yaml")
            if not self.quiet:
                Console.ok("Reading " + self.filename + ". ok.")
        except:
            Console.error("problem loading cmd3.yaml file")
        try:
            self.config = ConfigDict(filename=self.filename)
            # print(self.config)
        except Exception as e:
            Console.error("problem with ConfigDict")
            print(e)

    def add(self, plugin, dryrun=False):

        if not plugin.endswith(".plugins"):
            plugin = plugin + ".plugins"

        modules = self.config["cmd3"]["modules"]
        if plugin in modules:
            if not self.quiet:
                Console.error("plugin {:} is already activated.".format(plugin))
        else:
            self.config["cmd3"]["modules"].append(plugin)
            if not self.quiet:
                Console.ok("Adding plugin " + plugin)

        if not dryrun:
            self.config.write(self.filename, output="yaml")
        else:
            print(self.config.yaml())

    def delete(self, plugin, dryrun=False):

        if not plugin.endswith(".plugins"):
            plugin = plugin + ".plugins"

        modules = self.config["cmd3"]["modules"]
        if plugin not in modules:
            Console.error("plugin {:} is already deactivated.".format(plugin))
        else:
            self.config["cmd3"]["modules"].remove(plugin)
            if not self.quiet:
                Console.ok("Deleting plugin " + plugin)

        if not dryrun:
            self.config.write(self.filename, output="yaml")
        else:
            print(self.config.yaml())

    def __str__(self):
        with open(self.filename, 'r') as f:
            r = f.read()
        return r
Beispiel #46
0
    def load(self, filename="/cloudmesh_pbs.yaml"):
        """
        The configuration for the job db is stored in a yaml
        file. The defualt location is ~/.cloudmesh/cloudmesh_pbs.yaml

        :param filename: the filename of the yaml file
        :type filename: str
        """
        self.filename = config_file(filename)
        self.data = ConfigDict(filename=self.filename)

        self.port = self.data["cloudmesh"]["jobdatabase"]["port"]
        self.db_path = path_expand(self.data["cloudmesh"]["jobdatabase"]["db_path"])
        self.log_file = path_expand(self.db_path + "/dbjobs.log")
        self.dbname = self.data["cloudmesh"]["jobdatabase"]["dbname"]
Beispiel #47
0
    def __init__(self,
                 username,
                 cloud,
                 datasource=None,
                 yaml_version=2.0,
                 style=2.0,
                 password=None):
        """datasource is afilename"""
        CredentialBaseClass.__init__(self, username, cloud, datasource)

        self.password = password

        if datasource is not None:
            self.filename = datasource
        else:
            self.filename = "~/.cloudmesh/cloudmesh.yaml"

        self.config = ConfigDict(filename=self.filename)

        self.read(username, cloud, style=style)
Beispiel #48
0
    def __init__(self,
                 label,
                 credential=None,
                 service_url_type='publicURL'):
        """
        initializes the openstack cloud from a file
        located at cloudmesh.yaml.
        However if a credential dict is used it is used instead
        """
        self.clear()
        self.label = label
        self.credential = credential
        self.service_url_type = service_url_type

        if credential is None:
            try:
                self.compute_config = ConfigDict(filename="~/.cloudmesh/cloudmesh.yaml")
                self.credential = self.compute_config.get("cloudmesh.clouds.{:}.credentials".format(label))
            except:
                log.error(str(
                    lineno()) + "No user credentail found! Please check your cloudmesh.yaml file.")
                # sys.exit(1)

        self.connect()
Beispiel #49
0
 def __init__(self, filename=None):
     if filename is None:
         filename = self.filename
     ConfigDict.__init__(self, filename=filename, kind="flavor")
Beispiel #50
0
# provider = pbs_mongo

app = Flask(__name__)
api = restful.Api(app)

queue_stat_parser = reqparse.RequestParser()
queue_stat_parser.add_argument('resource', type=str, required=True)
# queue_stat_parser.add_argument('user', type=str)
queue_stat_parser.add_argument('id', type=str)

queue_info_parser = reqparse.RequestParser()
queue_info_parser.add_argument('resource', type=str, required=True)
# queue_info_parser.add_argument('user', type=str)
queue_info_parser.add_argument('queue', type=str)

config = ConfigDict(
    prefix="cloudmesh", filename=config_file("/cloudmesh.yaml"))
user = config.get("cloudmesh.profile.username")


def versioned_url(url):
    return "/" + version + url


def simple_error(kind, attribute, help="does not exist"):
    msg = {}
    msg["error:"] = "{0} {1} {2}".format(kind, attribute, help)
    return msg


class rest_queue_stat(restful.Resource):
Beispiel #51
0
 def __init__(self, filename=None):
     if filename is None:
         filename = self.filename
     ConfigDict.__init__(self, filename=filename)
Beispiel #52
0
class ConfigDict(object):
    def __init__(self,
                 filename,
                 load_order=None,
                 verbose=False):
        """
        Creates a dictionary from a yaml configuration file
        while using the filename to load it in the specified load_order.
        The load order is an array of paths in which the file is searched.
        By default the load order is set to . and ~/.cloudmesh

        :param filename: the filename
        :type filename: string
        :param load_order: an array with path names in with the filename is looked for.
        :type load_order: list of strings
        :return: an instance of ConfigDict
        :rtype: ConfigDict
        """
        self.data = None
        if load_order is None:
            self.load_order = [".", os.path.join("~", ".cloudmesh")]
        else:
            self.load_order = load_order
        for path in self.load_order:
            name = Config.path_expand(os.path.join(path, filename))
            if verbose:
                print("try Loading ConfigDict", name)
            if os.path.isfile(name):
                if verbose:
                    print("Loading ConfigDict", name)
                self.load(name)
                self.filename = name
                return
        raise Exception("could not find file {:} in {:}"
                        .format(filename, self.load_order))

    def load(self, filename):
        """
        loads the configuration from the yaml filename

        :param filename:
        :type filename: string
        :return:
        """

        self.data = BaseConfigDict(filename=Config.path_expand(filename))

    def save(self, filename=None):
        """
        saves the configuration in the given filename,
        if it is none the filename at load time is used.

        :param filename: the file name
        :type filename: string
        :return:
        """
        content = self.data.yaml()
        with open(Config.path_expand(self.filename), 'w') as f:
            f.write(content)

    def __setitem__(self, item, value):
        """
        sets an item with the given value while using . formatted keys

        set('a.b.c", value)

        :param item:
        :type item:
        :param value:
        :type value:
        :return:
        """
        keys = None
        if "." in item:
            keys = item.split(".")
        else:
            element = self.data[item]

        element = self.data[keys[0]]
        for key in keys[1:]:
            element = element[key]
        element = value

    def __getitem__(self, item):
        """
        gets an item form the dict. The key is . separated

        use it as follows get("a.b.c")

        :param item:
        :type item:
        :return:
        """
        if "." in item:
            keys = item.split(".")
        else:
            return self.data[item]
        element = self.data[keys[0]]
        for key in keys[1:]:
            element = element[key]
        return element

    def __str__(self):
        """
        returns the dict in yaml format

        :return: returns the yaml output of the dict
        :rtype: string
        """
        return self.data.yaml()

    @property
    def yaml(self):
        """
        returns the dict in yaml format

        :return: returns the yaml output of the dict
        :rtype: string:
        """
        return self.data.yaml()

    def info(self):
        """
        prints out the dict type and its content
        """
        print(type(self.data))
        print(self.data)

    @property
    def json(self, start=None):
        """
        :param start: start key in dot notation

        returns the dict in json format

        :return: json string version
        :rtype: string
        """
        if start is not None:
            data = self.data[start]
        return json.dumps(self.data, indent=4)

    @classmethod
    def check(cls, filename):
        """
        checks the filename if it is syntactically correct and does not include tabs

        :param filename:
        :type filename: string
        :return:
        """
        TODO.implement()
Beispiel #53
0
class CredentialFromYaml(CredentialBaseClass):
    password = None

    def __init__(self,
                 username,
                 cloud,
                 datasource=None,
                 yaml_version=2.0,
                 style=2.0,
                 password=None):
        """datasource is afilename"""
        CredentialBaseClass.__init__(self, username, cloud, datasource)

        self.password = password

        if datasource is not None:
            self.filename = datasource
        else:
            self.filename = "~/.cloudmesh/cloudmesh.yaml"

        self.config = ConfigDict(filename=self.filename)

        self.read(username, cloud, style=style)

    def read(self, username, cloud, style=2.0):
        self.style = style
        self['cm'] = {}
        self['cm']['source'] = 'yaml'
        self['cm']['filename'] = self.filename
        self['cm']['kind'] = self.config.get("meta.kind")
        self['cm']['yaml_version'] = self.config.get("meta.yaml_version")

        kind = self['cm']['kind']
        if kind == "clouds":
            self['cm']['filename'] = "~/.cloudmesh/cloudmesh.yaml"
            self.update(self.config.get("cloudmesh.clouds.{0}".format(cloud)))

        elif kind == "server":
            self['cm']['filename'] = "~/.cloudmesh/cloudmesh_server.yaml"
            self.update(
                self.config.get("cloudmesh.server.keystone.{0}".format(cloud)))
        else:
            log.error("kind wrong {0}".format(kind))
        self['cm']['username'] = username
        self['cm']['cloud'] = cloud
        self.clean_cm()
        self.transform_cm(self['cm']['yaml_version'], style)
        # self.remove_default()

    def clean_cm(self):
        '''temporary so we do not have to modify yaml files for now'''
        for key in self.keys():
            if key.startswith('cm_'):
                new_key = key.replace('cm_', '')
                self['cm'][new_key] = self[key]
                del self[key]

    """
    def remove_default(self):
        if 'default' in self.keys():
            del self['default']
    """

    def transform_cm(self, yaml_version, style):
        if yaml_version <= 2.0 and style == 2.0:
            for key in self['cm']:
                new_key = 'cm_' + key
                self[new_key] = self['cm'][key]
            del self['cm']
Beispiel #54
0
from cloudmesh_task.tasks import cm_ssh
from cloudmesh_task.parallel import Parallel, Sequential
from cloudmesh.util.stopwatch import StopWatch
from cloudmesh_base.util import banner
from pprint import pprint
from cloudmesh.config.cm_config import cm_config
from cloudmesh_base.ConfigDict import ConfigDict
import sys

config = ConfigDict(
    filename="~/.cloudmesh/cloudmesh_hpc.yaml")["cloudmesh"]["hpc"]

print config


#hosts = []
# hosts.append("localhost")
# hosts.append("bigred2.uits.iu.edu")
# hosts.append("india.futuregrid.org")

def get_credentials(hosts):
    credential = {}
    for host in hosts:
        credential[host] = config[host]['username']
    return credential


hosts = config.keys()

credentials = get_credentials(hosts)