Ejemplo n.º 1
0
def reset():
    """
    Resets default values for any configuration element that is not an empty string by default. This includes log and job paths and could be useful for migrating a deployment between operating systems.
    """
    OUTPUT.info('Resetting configuration file with default values.')
    CFG.reset_default_values()
    CFG.save()
Ejemplo n.º 2
0
def export():
    """
    Exports configuration settings as commands.
    """
    for key, val in CFG.values.items():
        commandout = 'aws-aware -configfile {0} config change {1} {2}'.format(
            CFG.config_file, key, val)
        OUTPUT.info(commandout)
Ejemplo n.º 3
0
def upgrade():
    """
    Upgrade a global configuration file with any missing elements.
    """
    OUTPUT.info(
        'Updating configuration file with any new global config options')
    CFG.merge_default_values()
    CFG.save()
Ejemplo n.º 4
0
 def _add_log(self, mylog, logtype='info'):
     """Add a log generated from this module"""
     if logtype == 'error':
         OUTPUT.error('{0}: {1}'.format(str(self.__class__.__name__),
                                        str(mylog)))
     elif logtype == 'warning':
         OUTPUT.warning('{0}: {1}'.format(str(self.__class__.__name__),
                                          str(mylog)))
     else:
         OUTPUT.info('{0}: {1}'.format(str(self.__class__.__name__),
                                       str(mylog)))
Ejemplo n.º 5
0
def awsdownload(sourcefile, destpath=None):
    """
    Test aws ability to download a specific file
    """
    OUTPUT.info('TEST: Validating aws file download ability')
    if destpath is None:
        destpath = os.path.join(os.path.abspath(os.path.curdir), sourcefile)
        OUTPUT.info(
            'Using current directory and source file name as destination file path: {0}'
            .format(destpath))
    else:
        destpath = os.path.abspath(destpath)

    try:
        monitortask = MonitorTasks(runargs=TESTARGS)
        OUTPUT.info('Connecting to aws')
        monitortask.instantiate_aws()
        OUTPUT.echo('..Connected to AWS', color='green')
    except Exception as awsawareexception:
        raise awsawareexception

    s3fullfilepath = '{0}/{1}'.format(TESTARGS['s3path'], sourcefile)
    OUTPUT.info('Attempting to download file - {0}'.format(s3fullfilepath))
    s3url = urlparse(s3fullfilepath)
    downloaded = monitortask.aws.download_s3_file(bucket=s3url.netloc,
                                                  path=s3url.path.lstrip('/'),
                                                  destpath=destpath)

    if downloaded:
        OUTPUT.echo('..SUCCESS!', color='green')
    else:
        OUTPUT.echo('..FAILED!', color='red')
Ejemplo n.º 6
0
def aws():
    """
    Test AWS connectivity
    """
    OUTPUT.info('TEST: Validating AWS connectivity')

    try:
        monitortask = MonitorTasks(runargs=TESTARGS)
        OUTPUT.info('Testing AWS connectivity')
        monitortask.instantiate_aws()
        OUTPUT.echo('AWS Test Success!', color='green')

    except Exception as awsawareexception:
        raise awsawareexception
Ejemplo n.º 7
0
def new(filename):
    """
    Create a new global configuration file.
    """
    if filename is None:
        filename = os.path.join(os.path.abspath(os.path.curdir), 'config.yml')
    else:
        filename = os.path.abspath(filename)

    OUTPUT.info(
        'Attempting to save new configuration file to: {0}'.format(filename))
    _newconfig = Settings()
    _newconfig.set_config_default_values()
    _newconfig.save_to_file(filename=filename)
Ejemplo n.º 8
0
def change(whatif, element, value):
    """
    Set script configuration elements. These are saved for future script runs.
    """
    if element in CFG.values:
        if whatif:
            OUTPUT.info('Would have updated {0} to {1}'.format(
                CFG.values[element], value))
        else:
            OUTPUT.info('Updating {0} to {1}'.format(element, value))
            CFG.values[element] = value
            CFG.save()
    else:
        OUTPUT.error('No configuration element exists for {0}'.format(element))
Ejemplo n.º 9
0
 def send_slack_notification(self, force=False):
     """Send a slack notification"""
     if force or self.should_send_warning() or self.should_send_alert():
         if ('slack_webhooks' in CFG.values) and ('slack_notifications'
                                                  in CFG.values):
             if CFG.values['slack_webhooks'] and CFG.values[
                     'slack_notifications']:
                 slk = SlackPoster(CFG.values['slack_webhooks'])
                 slackmessage = self.get_slackmessage()
                 if slackmessage:
                     slk.post_message(slackmessage)
             else:
                 OUTPUT.info(
                     'Slack notifications not enabled or there are no webhooks defined.'
                 )
Ejemplo n.º 10
0
def export(ctx):
    """
    Exports all raw instance data without any filtering. Useful for pre-caching.
    """
    run_args = ctx.copy()
    suppressoutput = run_args['terse'] or CFG.values.get(
        'suppressconsoleoutput')
    OUTPUT.header('Check Thresholds', suppress=suppressoutput)

    # Load up default monitors and instantiate a task object
    monitortask = MonitorTasks(runargs=run_args)

    # Pull aws information
    try:
        OUTPUT.info('Polling AWS')
        monitortask.poll_instance_data()
    except Exception as monitorclassexception:
        raise monitorclassexception
Ejemplo n.º 11
0
def run(ctx,
        awsprofile=None,
        awsid=None,
        awsregion=None,
        emailrecipients=None,
        terse=False,
        verbose=False,
        force=False,
        datapath=None,
        **kwargs):
    """
    Run aws-aware actions
    """
    # First get all of our common run args. If not passed in,
    #  they will be updated with global config values (if they line up)
    #  Then we look in the global config for explict mappings
    #  (name differences) that exist
    OUTPUT.info(
        'Merging common run arguments with global config file settings.',
        suppress=True)
    RUN_ARGS = RUNARGS.copy()
    for key, val in RUN_ARGS.items():
        RUN_ARGS[key] = kwargs.pop(key, val)
        # Did we get an empty (unpassed) run argument?
        if RUN_ARGS[key] is None:
            # Do we have the same argument in CFG?
            if key in CFG.values:
                # Does it have a value? Great, lets use it
                if CFG.values[key] is not None:
                    RUN_ARGS[key] = CFG.values[key]

    # Sanitize run args for Tibco's sake *sigh*
    #for key, val in RUN_ARGS.items():
    #    # if we get passed in '' or "" then convert to empty string
    #    if val == "''" or val == '""':
    #        RUN_ARGS[key] = ''
    #    # if we get passed in null or Null convert to None
    #    if val == 'null' or val == 'Null':
    #        RUN_ARGS[key] = None
    ctx = click.get_current_context()
    RUN_ARGS = UTIL.santize_arguments(RUN_ARGS)
    ctx.obj = RUN_ARGS
Ejemplo n.º 12
0
    def show_monitors(self):
        """Prints information about current monitors to console"""
        try:
            OUTPUT.info('Loading and displaying monitors')

            outlines = []
            outlines.append([
                'name', 'thresholdtype', 'warn_thresh', 'alert_thresh',
                'enabled'
            ])
            for monitor in self.monitorjobs:
                outlines.append(monitor.show())

            col_width = max(len(word) for row in outlines for word in row) + 2
            # padding
            for row in outlines:
                OUTPUT.echo("".join(word.ljust(col_width) for word in row))

        except Exception as monitorexception:
            OUTPUT.error('Unable to print monitor output')
            raise monitorexception
Ejemplo n.º 13
0
def test(**kwargs):
    """
    Script testing
    """
    # First get all of our common run args. If not passed in,
    #  they will be updated with global config values (if they line up)
    #  Then we look in the global config for explicit mappings (name differences) that exist

    OUTPUT.info(
        'Merging common test arguments with global config file settings.',
        suppress=True)
    for key, val in RUNARGS.items():
        TESTARGS[key] = kwargs.pop(key, val)
        # Did we get an empty (unpassed) run argument?
        if TESTARGS[key] is None:
            # Do we have the same argument in CFG?
            if key in CFG.values:
                # Does it have a value? Great, lets use it
                if CFG.values[key] is not None:
                    TESTARGS[key] = CFG.values[key]

    suppressoutput = TESTARGS['terse'] or CFG.values.get(
        'suppressconsoleoutput')
    OUTPUT.header('TESTING', suppress=suppressoutput)
Ejemplo n.º 14
0
    def poll_instance_data(self):
        """Poll AWS for data we need"""
        if self.skipprobe:
            # Pull prior aws information
            try:
                OUTPUT.info('Loading prior instance data: {0}'.format(
                    self.datapath))
                self.allinstances = self.load_instance_data(
                    datapath=self.datapath)
            except Exception as monitorclassexception:
                raise monitorclassexception

            self.instances = self.allinstances
            for filtername in self.filters.keys():
                if self.eval_filter(filtername) != '*':
                    results = [
                        i for i in results
                        if i[filtername] == self.eval_filter(filtername)
                    ]
            # if self.eval_filter('environment') != '*':
            #     self.instances = [i for i in self.instances if i['Environment'] == self.eval_filter('environment')]
            # if self.eval_filter('appname') != '*':
            #     self.instances = [i for i in self.instances if i['ApplicationName'] == self.eval_filter('appname')]
            # if self.eval_filter('costcenter') != '*':
            #     self.instances = [i for i in self.instances if i['CostCenter'] == self.eval_filter('costcenter')]
        else:
            self._add_log('Polling AWS for instance data')
            # Get aws going
            try:
                OUTPUT.info('Instantiating connection to AWS first...')
                self.instantiate_aws()
            except Exception as monitorclassexception:
                raise monitorclassexception

            otherfilters = []

            # Other filter definitions
            # Running instances
            otherfilters.append({
                'Name': 'instance-state-name',
                'Values': self.view['instance_state']
            })
            if len(self.filters) > 0:
                for filtername in self.filters.keys():
                    if self.eval_filter(filtername) != '*':
                        self._add_log(
                            'Other Filter Added - {0}'.format(filtername))
                        otherfilters.append({
                            'Name':
                            'tag:{0}'.format(filtername),
                            'Values': [self.eval_filter(filtername)]
                        })

            # # Particular cost center
            # tag_cc = str(self.eval_filter('costcenter'))
            # self._add_log('Other Filter - CostCenter: {0}'.format(tag_cc))
            # otherfilters.append({'Name': 'tag:CostCenter', 'Values': [tag_cc]})

            # # ApplicationName
            # tag_app = str(self.eval_filter('appname'))
            # self._add_log('Other Filter - ApplicationName: {0}'.format(tag_app))
            # otherfilters.append({'Name': 'tag:ApplicationName', 'Values': [tag_app]})

            # # Environment
            # tag_env = str(self.eval_filter('environment'))
            # self._add_log('Other Filter - Environment: {0}'.format(tag_env))
            # otherfilters.append({'Name': 'tag:Environment', 'Values': [tag_env]})

            self._add_log('Instance filters applied: {0}'.format(
                len(otherfilters)))
            # Basic instance dictionary list result with some additional tags.
            self.allinstances = self.aws.aws_instances_brief(
                otherfilters=otherfilters, tags=self.view['instance_tags'])

            self._add_log('AWS instances found: {0}'.format(
                len(self.allinstances)))

            if self.allinstances:
                self._add_log('Inferring clustername attributes...')
                for instance in self.allinstances:
                    instance['cluster'] = self.awsinstancename_to_clustername(
                        instance['name'])
            else:
                self._add_log('Zero AWS Instances found!')

            self.save_instance_data(filepath=self.runargs['datapath'])