def main(args):
config = ConfigParser.RawConfigParser()
config.read('/root/.raxrc')
driver = get_driver(Provider.RACKSPACE)
conn = get_conn(config, driver)
if conn is None:
print("Unable to get a client to MaaS, exiting")
sys.exit(1)
for entity in conn.list_entities():
error = 0
if args.prefix is None or args.prefix in entity.label:
for check in conn.list_checks(entity):
try:
result = conn.test_existing_check(check)
except RackspaceMonitoringValidationError as e:
print('Entity %s (%s):' % (entity.id, entity.label))
print(' - %s' % e)
break
available = result[0]['available']
status = result[0]['status']
if available is False or status != 'okay':
if error == 0:
print('Entity %s (%s):' % (entity.id, entity.label))
error = 1
if available is False:
print(' - Check %s (%s) did not run correctly' %
(check.id, check.label))
elif status != 'okay':
print(" - Check %s (%s) ran correctly but returned a "
"'%s' status" % (check.id, check.label, status))
def get_entity_id(ctx, label):
Cls = get_driver(Provider.RACKSPACE)
driver = Cls(ctx.obj['username'], ctx.obj['api-key'])
entities = driver.list_entities()
for e in entities:
if label == e.label:
click.echo(e.id)
def get_client(parsed_args):
config = get_config()
driver = get_driver(Provider.RACKSPACE)
username = config['username']
api_key = config['api_key']
if parsed_args.username:
username = parsed_args.username
if parsed_args.api_key:
api_key = parsed_args.api_key
api_url = parsed_args.api_url
auth_url = parsed_args.auth_url
if not username:
raise ValueError('Missing required argument: username')
if not api_key:
raise ValueError('Missing required argument: api-key')
options = {}
if api_url is not None:
options['ex_force_base_url'] = api_url
if auth_url is not None:
options['ex_force_auth_url'] = auth_url
return driver(username, api_key, **options)
def ping_alarm(server):
"""Add a ping alarm, so we get emails whenever a node appears to go down."""
from rackspace_monitoring.providers import get_driver
from rackspace_monitoring.types import Provider
RaxMon = get_driver(Provider.RACKSPACE)
cm = RaxMon(os.environ['OS_USERNAME'], os.environ['OS_PASSWORD'])
notification_plan = cm.list_notification_plans()[0]
# get monitoring entities
# get ping check
pings = []
while not pings:
entities = [ e for e in cm.list_entities() if e.label == server.name ]
pings = [ e for e in entities if cm.list_checks(e) and 'ping' in cm.list_checks(e)[0].label.lower() ]
if not pings:
print('waiting for ping check to be registered')
print([cm.list_checks(e)[0].label.lower() for e in entities])
time.sleep(1)
ping = pings[0]
ping_check = cm.list_checks(ping)[0]
cm.create_alarm(ping,
check_id=ping_check.id,
notification_plan_id=notification_plan.id,
criteria=PING_ALARM_CRITERIA,
label='ping')
def get_entity_id(ctx, label):
Cls = get_driver(Provider.RACKSPACE)
driver = Cls(ctx.obj['username'], ctx.obj['api-key'])
entities = driver.list_entities()
for e in entities:
if label == e.label:
click.echo(e.id)
def get_instance(username, api_key, url, auth_url=None):
driver = get_driver(Provider.RACKSPACE)
kwargs = {}
kwargs['ex_force_base_url'] = url
kwargs['ex_force_auth_url'] = auth_url
instance = driver(username, api_key, **kwargs)
return instance
def get_instance(username, api_key, url, auth_url=None):
driver = get_driver(Provider.RACKSPACE)
kwargs = {}
kwargs['ex_force_base_url'] = url
kwargs['ex_force_auth_url'] = auth_url
instance = driver(username, api_key, **kwargs)
return instance
def _get_driver():
driver = get_driver(Provider.RACKSPACE)
kwargs = {}
kwargs['ex_force_base_url'] = 'https://monitoring.api.rackspacecloud.com/v1.0'
kwargs['ex_force_auth_url'] = 'https://identity.api.rackspacecloud.com/v2.0/tokens'
kwargs['ex_force_auth_token'] = None
instance = driver(RS_USERNAME, RS_APIKEY, **kwargs)
return instance
def __init__(self, entity_match='', entities=None,
config_file=DEFAULT_CONFIG_FILE):
self.entity_label_whitelist = entities
self.entity_match = entity_match
self.config_file = config_file
self.driver = get_driver(Provider.RACKSPACE)
self._get_conn()
self._get_overview()
self._add_links()
self._filter_entities()
self.q = Queue()
def _get_driver():
driver = get_driver(Provider.RACKSPACE)
kwargs = {}
kwargs[
'ex_force_base_url'] = 'https://monitoring.api.rackspacecloud.com/v1.0'
kwargs[
'ex_force_auth_url'] = 'https://identity.api.rackspacecloud.com/v2.0/tokens'
kwargs['ex_force_auth_token'] = None
instance = driver(RS_USERNAME, RS_APIKEY, **kwargs)
return instance
def get_mon_usage(username, key):
""" Returns the number (integer) of checks and alarms for the account """
Cls = get_driver(Provider.RACKSPACE)
driver = Cls(username, key)
overview = driver.ex_views_overview()
total_checks = 0
total_alarms = 0
x = 0
while x < len(overview):
total_alarms = total_alarms + len(overview[x]['alarms'])
total_checks = total_checks + len(overview[x]['checks'])
x = x + 1
return total_checks,total_alarms
def __init__(self, entity_match='', entities=None,
config_file=DEFAULT_CONFIG_FILE, use_api=True):
self.entity_label_whitelist = entities
self.entity_match = entity_match
self.config_file = config_file
self.use_api = use_api
if self.use_api:
self.driver = get_driver(Provider.RACKSPACE)
self._get_conn()
self._get_overview()
self._add_links()
self._filter_entities()
self.q = Queue()
def _driver(self):
cookie = cherrypy.request.cookie
username = None
apikey = None
if cookie.has_key('monitoring_username'):
username = cookie['monitoring_username'].value
if cookie.has_key('monitoring_apikey'):
apikey = cookie['monitoring_apikey'].value
raxMon = get_driver(Provider.RACKSPACE)
driver = raxMon(username, apikey, ex_force_base_url="https://ele-api.k1k.me/v1.0")
return driver
def _get_conn(get_driver, provider_cls, raxmon_cfg):
cfg = ConfigParser.RawConfigParser()
cfg.read(raxmon_cfg)
driver = get_driver(provider_cls.RACKSPACE)
try:
user = cfg.get('credentials', 'username')
api_key = cfg.get('credentials', 'api_key')
conn = driver(user, api_key)
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
url = cfg.get('api', 'url')
token = cfg.get('api', 'token')
conn = driver(None, None, ex_force_base_url=url,
ex_force_auth_token=token)
return conn
def _get_conn(get_driver, provider_cls, raxmon_cfg):
cfg = ConfigParser.RawConfigParser()
cfg.read(raxmon_cfg)
driver = get_driver(provider_cls.RACKSPACE)
try:
user = cfg.get('credentials', 'username')
api_key = cfg.get('credentials', 'api_key')
conn = driver(user, api_key)
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
url = cfg.get('api', 'url')
token = cfg.get('api', 'token')
conn = driver(None, None, ex_force_base_url=url,
ex_force_auth_token=token)
return conn
def _driver(self):
cookie = cherrypy.request.cookie
username = None
apikey = None
if cookie.has_key('monitoring_username'):
username = cookie['monitoring_username'].value
if cookie.has_key('monitoring_apikey'):
apikey = cookie['monitoring_apikey'].value
raxMon = get_driver(Provider.RACKSPACE)
driver = raxMon(
username, apikey
) #, ex_force_base_url="https://monitoring.api.rackspacecloud.com/v1.0")
return driver
def main(args):
config = ConfigParser.RawConfigParser()
config.read('/root/.raxrc')
driver = get_driver(Provider.RACKSPACE)
conn = _get_conn(config, driver)
if conn is None:
print("Unable to get a client to MaaS, exiting")
sys.exit(1)
if args.command == 'alarms':
alarms(args, conn)
elif args.command == 'check':
check(args, conn)
elif args.command == 'delete':
delete(args, conn)
def setup_rs(rs_username=None, rs_api_key=None):
"""
set up rackspace_monitoring, prompt for key/secret if not configured
"""
from rackspace_monitoring.providers import get_driver
from rackspace_monitoring.types import Provider
if not rs_username:
rs_username = get_input("Rackspace Username: "******"Rackspace API Key: ", hidden=True)
try:
driver = get_driver(Provider.RACKSPACE)(rs_username, rs_api_key)
return driver
except Exception as e:
sys.stderr.write('Failed to initialize Rackspace API.\n')
sys.stderr.write('Exception: %s' % (e))
sys.exit(1)
def main(args):
config = ConfigParser.RawConfigParser()
config.read("/root/.raxrc")
driver = get_driver(Provider.RACKSPACE)
conn = _get_conn(config, driver)
if conn is None:
print ("Unable to get a client to MaaS, exiting")
sys.exit(1)
if args.command == "alarms":
alarms(args, conn)
elif args.command == "check":
check(args, conn)
elif args.command == "delete":
delete(args, conn)
elif args.command == "remove-defunct-checks":
remove_defunct_checks(args, conn)
elif args.command == "remove-defunct-alarms":
remove_defunct_alarms(args, conn)
def cli(ctxt, api_key, username):
Cls = get_driver(Provider.RACKSPACE)
ctxt.obj = Cls(username, api_key)
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import collections
import errno
import json
import os
from rackspace_monitoring.providers import get_driver
from rackspace_monitoring.types import Provider
import re
USERNAME = os.environ['OS_USERNAME']
API_KEY = os.environ['OS_PASSWORD']
Cls = get_driver(Provider.RACKSPACE)
CM = Cls(USERNAME, API_KEY)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('tasks', help='MaaS tasks file used to setup Maas.')
parser.add_argument('label_templates',
nargs='*',
default=[],
help='entity_label:template_mapping')
parser.add_argument('--raw_output', action='store_true')
parser.add_argument('--from_file')
parser.add_argument('--base_dir', default='.')
args = parser.parse_args()
if args.tasks.endswith('.yml'):
def spawn():
parser = argparse.ArgumentParser(
description="Manage your Rackspace Cloud Monitors.")
parser.add_argument('--who',
default=None,
help='Who is making the change (for auditing)')
parser.add_argument('--why',
default=None,
help='Why the change is being made (for auditing)')
parser.add_argument('-v',
'--verbose',
action='count',
help='Increase output verbosity')
parser.add_argument('account', help="Account name to manage")
subparsers = parser.add_subparsers()
parser_pw = subparsers.add_parser(
'passwd', help='Set or update password for account')
parser_pw.add_argument(
'-k',
'--key',
default=None,
help='Provide API key as an arg instead of asking for input')
parser_pw.set_defaults(func=setpass)
parser_lsents = subparsers.add_parser('list-entities', help='')
parser_lsents.set_defaults(func=list_entities)
parser_lsnots = subparsers.add_parser('list-notifications', help='')
parser_lsnots.set_defaults(func=list_notifications)
parser_mknot = subparsers.add_parser(
'create-notification',
help='Notifications are steps MaaS takes when your alarms are tripped')
parser_mknot.add_argument('label', help='What to call your notification')
parser_mknot.add_argument('type',
choices=['email', 'pagerduty', 'webhook'])
parser_mknot.add_argument(
'detail', help='Email address, URI for webhook, or pagerduty details')
parser_mknot.set_defaults(func=make_notification)
parser_mknp = subparsers.add_parser(
'create-notification-plan',
help=
'Notification plans tell MaaS what notifications to run when your alarms are tripped'
)
parser_mknp.add_argument('label',
help='What to call your notification plan')
parser_mknp.add_argument(
'--ok',
nargs='+',
help='Notification ID(s) to run when alarm changes to OK')
parser_mknp.add_argument(
'--warning',
nargs='+',
help='Notification ID(s) to run when alarm changes to WARNING')
parser_mknp.add_argument(
'--critical',
nargs='+',
help='Notification ID(s) to run when alarm changes to CRITICAL')
parser_mknp.set_defaults(func=make_notification_plan)
parser_ap = subparsers.add_parser(
'apply', help='Apply a configured profile to one or more entity IDs')
parser_ap.add_argument('profile',
help='Name of profile from config to apply')
parser_ap.add_argument('ents',
nargs='+',
help='Entity IDs to apply profile to')
parser_ap.add_argument(
'-p',
'--plan',
default='npTechnicalContactsEmail',
help='Notification Plan ID to use when these alarms are tripped')
parser_ap.set_defaults(func=apply)
parser_ho = subparsers.add_parser(
'hose', help='Hose all the checks and alarm on one or more entity IDs')
parser_ho.add_argument('ents',
nargs='+',
help='Entity IDs to erase checks and alarms on')
parser_ho.set_defaults(func=hose)
parser_lstoks = subparsers.add_parser('list-tokens',
help='List monitoring agent tokens')
parser_lstoks.set_defaults(func=lstoks)
parser_mktok = subparsers.add_parser(
'create-token', help='Create a monitoring agent token')
parser_mktok.add_argument('-l',
'--label',
default=None,
help='Label your new monitoring agent token')
parser_mktok.set_defaults(func=mktok)
parser_rmtok = subparsers.add_parser(
'delete-token', help='Delete a monitoirng agent token')
parser_rmtok.add_argument('token_id', help='Token ID to delete')
parser_rmtok.set_defaults(func=rmtok)
parser_lschks = subparsers.add_parser(
'list-checks', help='List all checks on a series of entities')
parser_lschks.add_argument('ents',
nargs='+',
help='Entity IDs to list checks on')
parser_lschks.set_defaults(func=lschecks)
parser_lsalms = subparsers.add_parser(
'list-alarms', help='List all alarms on a series of entities')
parser_lsalms.add_argument('ents',
nargs='+',
help='Entity IDs to list alarms on')
parser_lsalms.set_defaults(func=lsalarms)
args = parser.parse_args()
Cls = get_driver(Provider.RACKSPACE)
driver = Cls(args.account, get_password('hawk', args.account))
args.func(driver, args)
def __init__(self, args, config):
self.args = args
self.config = config
self.driver = get_driver(Provider.RACKSPACE)
self.conn = self._get_conn()
def get_instance(username, api_key, url):
driver = get_driver(Provider.RACKSPACE)
instance = driver(username, api_key, ex_force_base_url=url)
return instance
# limitations under the License.
import argparse
import collections
import errno
import json
import os
from rackspace_monitoring.providers import get_driver
from rackspace_monitoring.types import Provider
import re
USERNAME = os.environ['OS_USERNAME']
API_KEY = os.environ['OS_PASSWORD']
Cls = get_driver(Provider.RACKSPACE)
CM = Cls(USERNAME, API_KEY)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('tasks', help='MaaS tasks file used to setup Maas.')
parser.add_argument('label_templates', nargs='*', default=[],
help='entity_label:template_mapping')
parser.add_argument('--raw_output', action='store_true')
parser.add_argument('--from_file')
parser.add_argument('--base_dir', default='.')
args = parser.parse_args()
if args.tasks.endswith('.yml'):
args.tasks = args.tasks[:-4]
return args
def init_rackspace_monitoring(self):
self.entities = []
self.agents = []
self.agent_tokens = []
Cls = get_driver(Provider.RACKSPACE)
return Cls(self.username, self.api_key)
def get_mon_limits(username, key):
""" Obtains absolute limits for alarms and checks """
Cls = get_driver(Provider.RACKSPACE)
driver = Cls(username, key)
maas_limits = driver.ex_limits()
return maas_limits
def __init__(self):
raxMon = get_driver(Provider.RACKSPACE)
self.driver = raxMon(argv[2], argv[3])
self.files = {}
self.files['/'] = MaaSDir(None, '/')
def __init__(self, args, config):
self.args = args
self.config = config
self.driver = get_driver(Provider.RACKSPACE)
self.conn = self._get_conn()
