def update_input(self, array_name, params):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        if len(params) > 0:

            self.logger.info("~" * 50)
            self.logger.info("Updating parameters for array: %s" % array_name)
            self.logger.info("    ~~~~ PARAMETERS ~~~~")
            for k, v in params.items():
                self.logger.info("%s: %s" % (k, v))
            self.logger.info("~" * 50)

            filters = {"nickname": array_name}
            array_id = self.get_id(filters)
            update_data = dict(
                map(lambda (key, value): ("server[parameters][" + str(key) + "]", value), params.items())
            )

            url = "/".join([self.base_url + "servers", str(array_id)])

            http_code = ResumatorRightScale.make_request(self, url, "PUT", update_data)

            if http_code == 204:
                self.logger.info("%s: Updated inputs" % array_name)
                return True

            self.logger.error("HTTP CODE: %d: %s: Unable to update inputs!" % (http_code, array_name))
            return False

        self.logger.error("No params sent")
        return False
    def run_recipe(self, array_name, recipe, inputs={}):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id), "run_executable"])

        post_data = {"recipe": recipe}
        post_data = dict(map(lambda (key, value): ("server[" + str(key) + "]", value), post_data.items()))

        if inputs:
            inputs = dict(map(lambda (key, value): ("server[parameters][" + str(key) + "]", value), inputs.items()))
            post_data = dict(post_data.items() + inputs.items())

        self.logger.debug("post data: %s" % post_data)
        self.logger.info("Running recipe: %s on %s" % (recipe, array_name))

        http_code = ResumatorRightScale.make_request(self, url, "POST", post_data)

        if http_code == 201:
            self.logger.info("Successfully executed %s on %s" % (recipe, array_name))

            return True

        self.logger.error("HTTP CODE: %d: %s failed on %s" % (http_code, recipe, array_name))
        return False
Exemple #3
0
    def run_rightscript(self, server_name, script_data, inputs={}):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters     = {'nickname': server_name}
        server_id   = self.get_id(filters)
        url         = '/'.join([self.base_url + 'servers', str(server_id), 'run_script'])

        rs          = RightScript(self.account_id, self.username, self.password)

        post_data   = {'right_script_href': rs.get_href(script_data)}
        post_data   = dict(map(lambda (key, value): ("server[" + str(key) + "]", value), post_data.items()))

        if inputs:
            inputs      = dict(map(lambda (key, value): ("server[parameters][" + str(key) + "]", value), inputs.items()))
            post_data   = dict(post_data.items() + inputs.items())

        self.logger.debug("post data: %s" % post_data)
        self.logger.info("Running rightscript: \"%s\" on %s" % (', '.join(["%s: %s" % (key, val) for (key, val) in script_data.items()]), server_name))

        http_code   = ResumatorRightScale.make_request(self, url, "POST", post_data)
        
        if http_code == 201:
            self.logger.info("Successfully executed %s on %s" % (script_data['name'], server_name))

            return True

        self.logger.error("HTTP CODE: %d: %s failed on %s" % (http_code, script_data['name'], server_name))
        return False
Exemple #4
0
    def get_deployments(self):
        http_code = ResumatorRightScale.make_request(self, self.url)

        content = json.loads(self.response_body)

        if http_code == 200 and content:
            return content
        self.logger.error("HTTP CODE: %d: Unable to get deployments" % http_code)
        return []
Exemple #5
0
    def get_settings(self, server_id):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        # Ugh... you can't use servers.js here, you can only get back json by setting the format on the query string.
        url         = '/'.join([self.base_url + 'servers', str(server_id), "settings?format=%s" % self.resp_format])
        http_code   = ResumatorRightScale.make_request(self, url)
        contents    = json.loads(self.response_body)

        if http_code == 200 and contents:
            return contents

        self.logger.error("HTTP CODE: %d: Unable to pull settings for server id: %d" % (http_code, server_id))
        return {}
Exemple #6
0
    def create(self, data):
        deployment_name = (data['nickname'] if 'nickname' in data else 'unknown')
        if len(data) > 0:
            data = dict(map(lambda (key, value): ("deployment[" + str(key) + "]", value), data.items()))

        http_code = ResumatorRightScale.make_request(self, self.url, "POST", data)

        if http_code == 201:
            self.logger.info("Created Deployment \"%s\"" % deployment_name)
            return True

        self.logger.error("HTTP CODE: %d: Unable to create deployment (%s)" % (http_code, deployment_name))
        return False
    def delete(self, array_name):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id)])

        http_code = ResumatorRightScale.make_request(self, url, "DELETE")

        if http_code == 200:
            self.logger.info("Deleted Server Array: %s" % array_name)
            return True

        self.logger.error("HTTP CODE: %d: Unable to delete server array: %s" % (http_code, array_name))
        return False
Exemple #8
0
    def terminate(self, server_name):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters     = {'nickname': server_name}
        server_id   = self.get_id(filters)
        url         = '/'.join([self.base_url + 'servers', str(server_id), 'stop'])

        http_code = ResumatorRightScale.make_request(self, url, "POST")

        if http_code == 201:
            self.logger.info("Terminated: %s" % server_name)
            return True

        self.logger.error("HTTP CODE: %d: Unable to terminate: %s" % (http_code, server_name))
        return False
    def terminate(self, array_name):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id), "terminate_all"])

        http_code = ResumatorRightScale.make_request(self, url, "POST")

        if http_code == 201:
            self.logger.info("Terminated: %s" % array_name)
            return True

        self.logger.error("HTTP CODE: %d: Unable to terminate: %s" % (http_code, array_name))
        return False
Exemple #10
0
    def launch(self, array_name):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id), "launch"])

        self.logger.info("Launching Array: %s" % array_name)

        http_code = ResumatorRightScale.make_request(self, url, "POST")

        if http_code == 201:
            self.logger.info("%s launched" % array_name)
            return True

        self.logger.error("HTTP CODE: %d: Server Array launch failed for: %s" % (http_code, array_name))
        return False
Exemple #11
0
    def get_instances(self, filters={}):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id), "instances?format=%s" % self.resp_format])

        http_code = ResumatorRightScale.make_request(self, url)
        contents = json.loads(self.response_body)

        if http_code == 200 and contents:
            return contents
        elif http_code == 200 and not contents:
            self.logger.warn("No instances returned for %s" % filters["nickname"])
            return []

        self.logger.error("HTTP CODE: %d: Unable to get instances." % http_code)
        return []
Exemple #12
0
    def launch(self, server_name):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters     = {'nickname': server_name}
        server_id   = self.get_id(filters)
        url         = '/'.join([self.base_url + 'servers', str(server_id), 'start'])

        self.logger.info("Launching Server: %s" % server_name)

        http_code   = ResumatorRightScale.make_request(self, url, "POST")

        if http_code == 201:
            self.logger.info("%s launched" % server_name)
            return True

        self.logger.error("HTTP CODE: %d: Server launch failed for: %s" % (http_code, server_name))
        return False
Exemple #13
0
    def get_details(self, filters):
        try:
            key_id = self.ssh_keys[filters['aws_key_name']]
        except KeyError:
            self.logger.error("Unable to get ssh key id by: %s" % filters)
            return False

        url         = '/'.join([self.base_url + 'ec2_ssh_keys', str(key_id), "?format=%s" % self.resp_format])

        http_code   = ResumatorRightScale.make_request(self, url)
        contents    = json.loads(self.response_body)

        if http_code == 200 and contents:
            return contents

        self.logger.error("HTTP CODE: %d: Unable to get details for ssh key: %s" % (http_code, filters['aws_key_name']))
        return {}
Exemple #14
0
    def run_rightscript(self, array_name, script_data, inputs={}, all_servers=True):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join(
            [
                self.base_url + "server_arrays",
                str(array_id),
                ("run_script_on_all" if all_servers else "run_script") + "?format=%s" % self.resp_format,
            ]
        )

        rs = RightScript(self.account_id, self.username, self.password)

        ## we could also do this with the ServerTemplate module and pass a name, but
        ## in this case I think it makes more sense to pass in the href because we want to send
        ## the server template that is being used by the array.
        server_template_href = script_data.pop("server_template_href", None)

        post_data = {"right_script_href": rs.get_href(script_data), "server_template_hrefs": server_template_href}

        post_data = dict(map(lambda (key, value): ("server_array[" + str(key) + "]", value), post_data.items()))

        if inputs:
            inputs = dict(
                map(lambda (key, value): ("server_array[parameters][" + str(key) + "]", value), inputs.items())
            )
            post_data = dict(post_data.items() + inputs.items())

        self.logger.debug("post data: %s" % post_data)
        self.logger.info(
            'Running rightscript: "%s" on %s'
            % (", ".join(["%s: %s" % (key, val) for (key, val) in script_data.items()]), array_name)
        )

        http_code = ResumatorRightScale.make_request(self, url, "POST", post_data)

        if http_code == 201:
            self.logger.info("Successfully executed %s on %s" % (script_data["name"], array_name))

            return True

        self.logger.error("HTTP CODE: %d: %s failed on %s" % (http_code, script_data["name"], array_name))
        return False
Exemple #15
0
    def __array_activation(self, array_name, activate=True):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        filters = {"nickname": array_name}
        array_id = self.get_id(filters)
        url = "/".join([self.base_url + "server_arrays", str(array_id)])
        _act = "true" if activate else "false"
        _verb = "enable" if activate else "disable"
        _past = "Enabled" if activate else "Disabled"

        post_data = {"server_array[active]": _act}

        http_code = ResumatorRightScale.make_request(self, url, "PUT", post_data)

        if http_code == 204:
            self.logger.info("%s Server Array: %s" % (_past, array_name))
            return True

        self.logger.error("Unable to %s %s" % (_verb, array_name))
        return False
Exemple #16
0
    def create(self, server_data, cloud_id=1):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])
        server_name     = (server_data['nickname'] if 'nickname' in server_data else 'unknown')

        st              = ServerTemplate(self.account_id, self.username, self.password)
        ssh             = SshKey(self.account_id, self.username, self.password)
        template_data   = server_data.pop('server_template', None)
        key_data        = server_data.pop('ssh_key', None)
        security_groups = server_data.pop('security_groups', None)

        server_data['server_template_href'] = st.get_href(template_data)
        server_data['ec2_ssh_key_href']     = ssh.get_href(key_data)

        _ebs_optimized                      = ('Yes' if 'ebs_optimized' in server_data and (server_data['ebs_optimized'] == 1 or server_data['ebs_optimized'] == 'true') else 'No')

        self.logger.info("~" * 50)
        self.logger.info("      Creating Server: %s" % server_name)
        self.logger.info("      Server Template: %s" % ', '.join(["%s: %s" % (key, val) for (key, val) in template_data.items()]))
        self.logger.info("      Security Groups: %s" % ', '.join(security_groups))
        self.logger.info("        Instance Type: %s" % server_data['instance_type'])
        #self.logger.info("              Pricing: %s" % server_data['pricing'])
        self.logger.info("        EBS Optimized: %s" % _ebs_optimized)
        self.logger.info("              SSH Key: %s" % key_data['aws_key_name'])
        self.logger.info("             Cloud Id: %d" % cloud_id)
        self.logger.info("~" * 50)

        server_data = dict(map(lambda (key, value): ("server[" + str(key) + "]", value), server_data.items()))

        if cloud_id != 1:
            self.logger.warn("Deviating from default cloud id of 1!")

        server_data['cloud_id'] = cloud_id

        self.logger.debug("Server post data: %s" % server_data)

        http_code = ResumatorRightScale.make_request(self, self.url, "POST", server_data)

        if http_code == 201:
            self.logger.info("Created server '%s'" % server_name)
            return self.add_security_groups(server_name, security_groups)
        
        self.logger.error("HTTP CODE: %d: Unable to create '%s'" % (http_code, server_name))
        return False
Exemple #17
0
    def delete(self, deployment_name):
        filters         = {'nickname': deployment_name}
        deployment_id   = self.get_id(filters)

        if deployment_id == 0:
            self.logger.error("%s: Cannot delete deployment 0" % inspect.stack()[0][3])
            return False

        ## Delete cannot have the .js on the end of deployments...
        url = '/'.join([self.base_url + 'deployments', str(deployment_id)])

        http_code = ResumatorRightScale.make_request(self, url, "DELETE")

        if http_code == 200:
            self.logger.info("Deleted Deployment: %s" % deployment_name)
            return True

        self.logger.error("HTTP CODE: %d: Unable to delete deployment: %s" % (http_code, deployment_name))
        return False
    def __init__(self, account_id, username, password):
        ResumatorRightScale.__init__(self, account_id, username, password)

        self.url                = self.base_url + "server_templates.%s" % self.resp_format
Exemple #19
0
    def __init__(self, account_id, username, password):
        ResumatorRightScale.__init__(self, account_id, username, password)

        self.url                = self.base_url + "ec2_ssh_keys.%s" % self.resp_format
        self.ssh_keys           = {}
        self.__set_keys()
    def __init__(self, account_id, username, password):
        ResumatorRightScale.__init__(self, account_id, username, password)

        self.url                = self.base_url + "ec2_security_groups.%s" % self.resp_format
Exemple #21
0
    def __init__(self, account_id, username, password):
        ResumatorRightScale.__init__(self, account_id, username, password)

        self.url    = self.base_url + "deployments.%s" % self.resp_format
Exemple #22
0
    def create(self, server_data, parameters={}, cloud_id=1):
        self.logger.debug("~~~~ %s ~~~~" % inspect.stack()[0][3])

        array_name = server_data["nickname"] if "nickname" in server_data else "unknown"

        st = ServerTemplate(self.account_id, self.username, self.password)
        ssh = SshKey(self.account_id, self.username, self.password)

        elasticity_data = server_data.pop("elasticity", None)
        security_groups = server_data.pop("security_groups", None)
        ssh_key_data = server_data.pop("ssh_key", None)
        template_data = server_data.pop("server_template", None)

        array_enabled = (
            "Yes"
            if "active" in server_data and (server_data["active"] == "true" or server_data["active"] == "true")
            else "No"
        )

        self.logger.info("~" * 50)
        self.logger.info("Creating Server Array: %s" % array_name)
        self.logger.info("              Enabled: %s" % array_enabled)
        self.logger.info(
            "      Server Template: %s" % ", ".join(["%s: %s" % (key, val) for (key, val) in template_data.items()])
        )
        self.logger.info("           Array Type: %s" % server_data["array_type"])
        self.logger.info("      Security Groups: %s" % ", ".join(security_groups))
        self.logger.info("        Instance Type: %s" % server_data["instance_type"])
        # self.logger.info("              Pricing: %s" % server_data['pricing'])
        self.logger.info("              SSH Key: %s" % ssh_key_data["aws_key_name"])
        self.logger.info("             Cloud Id: %d" % cloud_id)
        self.logger.info(
            "           Elasticity: %s" % ", ".join(["%s: %s" % (key, val) for (key, val) in elasticity_data.items()])
        )
        if parameters:
            self.logger.info("    ~~~~ PARAMETERS ~~~~")
            for k, v in parameters.items():
                self.logger.info("%s: %s" % (k, v))
        self.logger.info("~" * 50)

        server_data["server_template_href"] = st.get_href(template_data)
        server_data["ec2_ssh_key_href"] = ssh.get_href(ssh_key_data)

        server_data = dict(map(lambda (key, value): ("server_array[" + str(key) + "]", value), server_data.items()))

        elasticity_data = dict(
            map(lambda (key, value): ("server_array[elasticity][" + str(key) + "]", value), elasticity_data.items())
        )
        server_data = dict(server_data.items() + elasticity_data.items())

        if parameters:
            param_data = dict(
                map(lambda (key, value): ("server_array[parameters][" + str(key) + "]", value), parameters.items())
            )
            server_data = dict(server_data.items() + param_data.items())

        if cloud_id != 1:
            self.logger.warn("Deviating from default cloud id of 1!")

        server_data["cloud_id"] = cloud_id

        self.logger.debug("Server array post data: %s" % server_data)

        http_code = ResumatorRightScale.make_request(self, self.url, "POST", server_data)

        if http_code == 201:
            self.logger.info("Created server array '%s'" % array_name)
            return self.add_security_groups(array_name, security_groups)

        self.logger.error("HTTP CODE: %d: Unable to create '%s'" % (http_code, array_name))
        return False
Exemple #23
0
    def __init__(self, account_id, username, password):
        ResumatorRightScale.__init__(self, account_id, username, password)

        self.url                = self.base_url + "ec2_ebs_volumes.%s" % self.resp_format