예제 #1
0
	def request_dashboard_api():
		sources = [
			'cpu',
			'memory',
			'disk',
			'mysql',
			'mean',
			'deviation_pos',
			'deviation_neg'
			]
		t = time.time()
		response = DW.cache_key_get('roledefs')
		warnings = DW.cache_key_get('ro_warnings')
		server_dict = ResourceDashboard().create_server_list(
			literal_eval(response),
			'production_servers'
			)
		response_dict = {
			'response': {
				'value': {}
				},
			'warnings': {}
			}
		response_dict['warnings'] = literal_eval(warnings)
		error_dict = {}
		for server in server_dict:
			response_dict['response']['value'][server] = {}
			for source in sources:
				key = 'ro_%s_%s' % (source, server)
				try:
					response = DW.cache_key_get(key)
					response_dict['response']['value'][server][source] = literal_eval(response)
				except Exception, e:
					error_dict[key] = str(e)
예제 #2
0
	def request_admin_api():
		print request.method
		if request.method == 'GET':
			return jsonify(ResourceAdmin()._show_help())
		else:
			print request.json
			if not 'server_name' in request.json \
			or not 'action' in request.json \
			or not 'network' in request.json:
				return jsonify({'error': 'missing required data'})
			response_object = GenericDataObject(request.json)
			roledefs = literal_eval(DW.cache_key_get('roledefs'))
			if response_object.action == 'remove':
				changed_roles = {}
				try:
					for name in roledefs:
						if response_object.server_name in name:
							host = roledefs[name][response_object.network]
					for name in roledefs:
						if host in roledefs[name]:
							roledefs[name].remove(host)
							changed_roles[name] = roledefs[name]
					DW.cache_key_set('roledefs', roledefs)
				except Exception, e:
					return jsonify({'error':e})
				return jsonify({
					'host':host,
					'changed_roles': changed_roles
					})
			elif response_object.action == 'list':
				return jsonify(roledefs)
예제 #3
0
 def request_admin_api():
     print request.method
     if request.method == 'GET':
         return jsonify(ResourceAdmin()._show_help())
     else:
         print request.json
         if not 'server_name' in request.json \
         or not 'action' in request.json \
         or not 'network' in request.json:
             return jsonify({'error': 'missing required data'})
         response_object = GenericDataObject(request.json)
         roledefs = literal_eval(DW.cache_key_get('roledefs'))
         if response_object.action == 'remove':
             changed_roles = {}
             try:
                 for name in roledefs:
                     if response_object.server_name in name:
                         host = roledefs[name][response_object.network]
                 for name in roledefs:
                     if host in roledefs[name]:
                         roledefs[name].remove(host)
                         changed_roles[name] = roledefs[name]
                 DW.cache_key_set('roledefs', roledefs)
             except Exception, e:
                 return jsonify({'error': e})
             return jsonify({'host': host, 'changed_roles': changed_roles})
         elif response_object.action == 'list':
             return jsonify(roledefs)
예제 #4
0
class ResourceRemoveAlertServer(AxolResource):
	"""docstring for ResourceRemoveAlertServer
	Must implement:
		_show_help
		self.methods = {<method_type>: function}
		self.source = {keyword}
		request_{keyword}_api
		calculate_new_fields
	"""
	required_post = {
		'server_name': (True, u's'),
		'profile': (False, u's')
		}

	def __init__(self):
		super(ResourceRemoveAlertServer, self).__init__()
		self.source = 'remove_alert_servers'
		self.local = True

	def _show_help(self):
		return {
			'Help': {
				'api': '/api/remove_alert_servers',
				'method': 'POST',
				'required data':  {
					'server_name': '<name of the server to remove>'
					},
				'version': api
				}
			}

	@staticmethod
	@app.route('/api/remove_alert_server', methods=['POST', 'GET'])
	def api_remove_alert_server():
		role = 'production_servers'
		if request.method == 'GET':
			return jsonify(ResourceRemoveAlertServer()._show_help())
		try:
			data = CommonResource.handle_request(request, ResourceRemoveAlertServer.required_post)
		except Exception, e:
			CommonLogger.log(e, 'remove_alert_server', 'api_remove_alert_server')
			return jsonify({'response': {'error': str(e)}})
		try:
			roledefs = literal_eval(DW.cache_key_get('roledefs'))
			server_dict = ResourceRemoveAlertServer.create_server_list(roledefs, role)
			if server_dict[data.server_name] in roledefs[role]:
				roledefs[role].remove(server_dict[data.server_name])
				DW.cache_key_set('roledefs', roledefs)
			if data.server_name in server_dict.keys():
				del server_dict[data.server_name]
		except Exception, e:
			CommonLogger.log(e, 'remove_alert_server', 'api_remove_alert_server')
			return jsonify({'response': {'error': str(e)}})
	def run_task(self, task):
		print 'RUN TASK 1 ##############'
		print task
		for server in task.value:
			for _type in self.sources:
				key = '%s_%s' % (_type, str(server))
				try:
					cache_data = DW.cache_key_get(key)
					if type(eval(str(cache_data))) is dict:
						try:
							task.value[server][_type] = GenericDataObject(eval(str(cache_data)))
							if task.value[server][_type].warnings[server] != None:
								print 'RED FLAG: %s %s' % (server, _type)
								print task.value[server][_type].warnings
							else:
								task.value[server][_type].health_indicator = CommonMath.adaptive_filtration(
									task.value[server][_type].normalized_indicator,
									task.value[server][_type].multiplier,
									task.value[server][_type].threshold_red,
									task.value[server][_type].scale
									)
						except Exception, e:
							print 'ERROR 1: %s' % e
				except Exception, e:
					CommonLogger.log(e, 'create_health_metrics', 'run_task-<%s-%s>' % (server, _type))
					print 'ERROR 2: %s' % e
					return jsonify({'response': {'error': str(e)}})
예제 #6
0
 def run_task(self, task):
     print 'RUN TASK 1 ##############'
     print task
     for server in task.value:
         for _type in self.sources:
             key = '%s_%s' % (_type, str(server))
             try:
                 cache_data = DW.cache_key_get(key)
                 if type(eval(str(cache_data))) is dict:
                     try:
                         task.value[server][_type] = GenericDataObject(
                             eval(str(cache_data)))
                         if task.value[server][_type].warnings[
                                 server] != None:
                             print 'RED FLAG: %s %s' % (server, _type)
                             print task.value[server][_type].warnings
                         else:
                             task.value[server][
                                 _type].health_indicator = CommonMath.adaptive_filtration(
                                     task.value[server]
                                     [_type].normalized_indicator,
                                     task.value[server][_type].multiplier,
                                     task.value[server]
                                     [_type].threshold_red,
                                     task.value[server][_type].scale)
                     except Exception, e:
                         print 'ERROR 1: %s' % e
             except Exception, e:
                 CommonLogger.log(e, 'create_health_metrics',
                                  'run_task-<%s-%s>' % (server, _type))
                 print 'ERROR 2: %s' % e
                 return jsonify({'response': {'error': str(e)}})
	def populate_cache(self, response):
		server_dict = {}
		print response
		print '##################'
		response['api'] = api
		response['api']['api_name'] = 'health'
		for item in response['value']:
			print '1111'
			print response['value'][item]
			response['value'][item] = response['value'][item]
			for item_2 in response['value'][item]:
				if item_2 != 'name' and item_2 != 'warnings':
					print '2222'
					print response['value'][item][item_2]
					response['value'][item][item_2] = response['value'][item][item_2]
					key = 'ro_%s_%s' % (item_2, item)
					print '-------------------'
					print key
					DW.cache_key_set(key, response['value'][item][item_2])
예제 #8
0
 def populate_cache(self, response):
     server_dict = {}
     print response
     print '##################'
     response['api'] = api
     response['api']['api_name'] = 'health'
     for item in response['value']:
         print '1111'
         print response['value'][item]
         response['value'][item] = response['value'][item]
         for item_2 in response['value'][item]:
             if item_2 != 'name' and item_2 != 'warnings':
                 print '2222'
                 print response['value'][item][item_2]
                 response['value'][item][item_2] = response['value'][item][
                     item_2]
                 key = 'ro_%s_%s' % (item_2, item)
                 print '-------------------'
                 print key
                 DW.cache_key_set(key, response['value'][item][item_2])
예제 #9
0
class ResourceGetAlertServers(AxolResource):
    """docstring for ResourceGetAlertServers
	Must implement:
		_show_help
		self.methods = {<method_type>: function}
		self.source = {keyword}
		request_{keyword}_api
		calculate_new_fields
	"""
    required_post = {'profile': (False, u's')}

    def __init__(self):
        super(ResourceGetAlertServers, self).__init__()
        self.source = 'get_alert_servers'
        self.local = True

    def _show_help(self):
        return {
            'Help': {
                'api': '/api/get_alert_servers',
                'method': 'POST',
                'required data': 'None',
                'version': api
            }
        }

    @staticmethod
    @app.route('/api/get_alert_servers', methods=['POST', 'GET'])
    def api_get_alert_servers():
        if request.method == 'GET':
            return jsonify(ResourceGetAlertServers()._show_help())
        try:
            data = CommonResource.handle_request(
                request, ResourceGetAlertServers.required_post)
        except Exception, e:
            CommonLogger.log(e, 'get_alert_servers', 'api_get_alert_servers')
            return jsonify({'response': {'error': str(e)}})
        try:
            roledefs = literal_eval(DW.cache_key_get('roledefs'))
            server_dict = ResourceGetAlertServers.create_server_list(
                roledefs, 'production_servers')
        except Exception, e:
            CommonLogger.log(e, 'get_alert_servers', 'api_get_alert_servers')
            return jsonify({'response': {'error': str(e)}})
예제 #10
0
	def run_task(self, AxolTask):
		AxolTask.name = 'alerts'
		AxolTask.api = api
		AxolTask.api['api_name'] = 'send_warnings_alerts'
		AxolTask.value = {}
		warnings = {}
		for source in self.sources:
			warnings[source] = []
			key = '%s_warnings' % source
			print key
			try:
				value = literal_eval(DW.cache_key_get(key))
			except Exception, e:
				print 'ERROR RT: %s' % e
			for server in value:
				if type(value[server]) is dict:
					if server in AxolTask.value:
						AxolTask.value[server][source] = value[server]['error']
					else:
						AxolTask.value[server] = {source: value[server]['error']}
예제 #11
0
class ResourceAdmin(AxolResource):
    """docstring for ResourceProcessor
	Must implement:
		_show_help
		self.source = {keyword}
		request_{keyword}_api
		calculate_new_fields
	"""
    def __init__(self):
        super(ResourceAdmin, self).__init__()
        self.source = 'version'
        self.local = True

    def _show_help(self):
        return {
            'Help': {
                'roles administration': {
                    'api': '/api/system/admin/roles',
                    'available_methods': {
                        'POST': {
                            'required data': [
                                'network=<internal, external>',
                                'action=<remove, list, list_ec2, restore>',
                                'server_name=<name of server>'
                            ]
                        }
                    }
                }
            }
        }

    @staticmethod
    @app.route('/api/manage_alerts', methods=['POST', 'GET'])
    def request_admin_api():
        print request.method
        if request.method == 'GET':
            return jsonify(ResourceAdmin()._show_help())
        else:
            print request.json
            if not 'server_name' in request.json \
            or not 'action' in request.json \
            or not 'network' in request.json:
                return jsonify({'error': 'missing required data'})
            response_object = GenericDataObject(request.json)
            roledefs = literal_eval(DW.cache_key_get('roledefs'))
            if response_object.action == 'remove':
                changed_roles = {}
                try:
                    for name in roledefs:
                        if response_object.server_name in name:
                            host = roledefs[name][response_object.network]
                    for name in roledefs:
                        if host in roledefs[name]:
                            roledefs[name].remove(host)
                            changed_roles[name] = roledefs[name]
                    DW.cache_key_set('roledefs', roledefs)
                except Exception, e:
                    return jsonify({'error': e})
                return jsonify({'host': host, 'changed_roles': changed_roles})
            elif response_object.action == 'list':
                return jsonify(roledefs)
            elif response_object.action == 'restore':
                roledefs = generate_base_roles()
                DW.cache_key_set('roledefs', roledefs)
                return jsonify(roledefs)
예제 #12
0
		def process_notification(name, AxolTask, key):
			notification_status = DW.cache_key_get(key)
			print '<Notification Status>: %s' % notification_status
			if notification_status == None:
				default = {
					'warn_threshold': 0,
					'silence_threshold': 0
					}
				DW.cache_key_set(key, default)
				notification_status = DW.cache_key_get(key)
			ns = literal_eval(notification_status)
			ns['warn_threshold'] += 1
			if (7 >= ns['warn_threshold'] > 4 and ns['silence_threshold'] == 0):
				self.send_notice(
					name=AxolTask.name,
					data=AxolTask.value,
					group='default',
					alert_type=['email', 'text']
					)
				DW.cache_key_set(key, ns)
				return 1
			elif (ns['warn_threshold'] > 4 and ns['silence_threshold'] <= 12):
				ns['silence_threshold'] += 1
				DW.cache_key_set(key, ns)
				return 1
			elif ns['silence_threshold'] > 12:
				ns['warn_threshold'] = 5
				ns['silence_threshold'] = 0
				DW.cache_key_set(key, ns)
				return 1
			DW.cache_key_set(key, ns)
			return 1
예제 #13
0
		key = 'notification_threshold'
		if len(AxolTask.value) > 0:
			for server in AxolTask.value:
				if server != 'status':
					if AxolTask.value[server] != []:
						print '<Task Warnings>: %s' % AxolTask.value[server]
						try:
							process_notification(server, AxolTask, key)
						except Exception, e:
							CommonLogger.log(e, 'axol_resource', 'process_notification')
		else:
			default = {
				'warn_threshold': 0,
				'silence_threshold': 0
				}
			DW.cache_key_set(key, default)
		return 1

	def process_queue(self, result):
		t = 0
		while True:
			if result.ready() == True:
				g = result.get()
				return g, t
				break
			else:
				t = t + 0.001
				time.sleep(0.001)
				if t >= 10:
					tmp = {
						'Response': {
예제 #14
0
 def process_notification(name, AxolTask, key):
     notification_status = DW.cache_key_get(key)
     print "<Notification Status>: %s" % notification_status
     if notification_status == None:
         default = {"warn_threshold": 0, "silence_threshold": 0}
         DW.cache_key_set(key, default)
         notification_status = DW.cache_key_get(key)
     ns = literal_eval(notification_status)
     ns["warn_threshold"] += 1
     if 7 >= ns["warn_threshold"] > 4 and ns["silence_threshold"] == 0:
         self.send_notice(name=AxolTask.name, data=AxolTask.value, group="default", alert_type=["email", "text"])
         DW.cache_key_set(key, ns)
         return 1
     elif ns["warn_threshold"] > 4 and ns["silence_threshold"] <= 12:
         ns["silence_threshold"] += 1
         DW.cache_key_set(key, ns)
         return 1
     elif ns["silence_threshold"] > 12:
         ns["warn_threshold"] = 5
         ns["silence_threshold"] = 0
         DW.cache_key_set(key, ns)
         return 1
     DW.cache_key_set(key, ns)
     return 1
예제 #15
0
            DW.cache_key_set(key, ns)
            return 1

        key = "notification_threshold"
        if len(AxolTask.value) > 0:
            for server in AxolTask.value:
                if server != "status":
                    if AxolTask.value[server] != []:
                        print "<Task Warnings>: %s" % AxolTask.value[server]
                        try:
                            process_notification(server, AxolTask, key)
                        except Exception, e:
                            CommonLogger.log(e, "axol_resource", "process_notification")
        else:
            default = {"warn_threshold": 0, "silence_threshold": 0}
            DW.cache_key_set(key, default)
        return 1

    def process_queue(self, result):
        t = 0
        while True:
            if result.ready() == True:
                g = result.get()
                return g, t
                break
            else:
                t = t + 0.001
                time.sleep(0.001)
                if t >= 10:
                    tmp = {"Response": {"failed_request": True}}
                    return tmp, t