from flask import Flask, request app = Flask(__name__) from PerfDataCache import PerfDataCache from RRD.RRDHandler import RRDHandler from utils.utils import encode from utils.load_config import load_global_config from utils.get_logger import get_logger logger = get_logger('PerfDataCacheHTTPServer') config = load_global_config() cache_size = config.get('cache_size') rrd_root = config.get("RRD_root") db_handler = RRDHandler.getInstance(rrd_root) cache = PerfDataCache.getInstance(cache_size, db_handler) @app.route('/monitor/<host>/<metric>') @app.route('/monitor/<host>/rawdata/<metric>') def get_stats(host, metric): only_latest = False cf = request.args.get('cf', 'AVERAGE') step = request.args.get('step', 15) start = request.args.get('start') if start is None: only_latest = True start = '-%s' % step end = -1 else:
# temporary solution for importing upper level modules/packages _ = lambda f: os.path.dirname(os.path.abspath(f)) par_dir = _(_(__file__)) if par_dir not in sys.path: sys.path.append(par_dir) ############################################################### from ModelDB import ModelDB, ModelDBSession from resources import Host, VirtualHost, CPU, Disk, Partition, NetworkInterface import ID from utils.load_config import load_config from utils.utils import decode from utils.get_logger import get_logger logger = get_logger("models.interface") #config = load_config() cur_dir = _(__file__) def sign_in_handler(ip, info): interface = Interface() interface.signIn(ip, info) interface.close() def host_metric_conf(host_id): interface = Interface() ret = interface.hostMetricConf(host_id) interface.close()
# -*- coding: utf-8 -*- import threading import os.path import socket import xmlrpclib import sys from time import sleep from utils.utils import current_dir, encode, decode, _print from utils.load_config import load_global_config, load_metric_list from utils.get_logger import get_logger from utils.platform_info import get_platform_info logger = get_logger("agent") global_config = load_global_config() PLATFORM = global_config["platform"] # change to the current directory # os.chdir(current_dir(__file__)) class AgentException(Exception): pass def import_module(module_name): # print type(module_name)
import threading import time from includes.singletonmixin import Singleton from utils.get_logger import get_logger from utils.utils import encode logger = get_logger("PerfDataCache") class PerfDataCache(Singleton): _lock = threading.RLock() def __init__(self, max_cache_size, db_handler): self._data_store = {} self.max_cache_size = max_cache_size self.cache_size = 0 self.db_handler = db_handler self._hit = 0 #def rollover(self, cache): #vlist = cache["data"] #vlen = len(vlist) #n = int((1 - float(cache["hit"])/float(self._hit+1)) * vlen) #del vlist[0:n] ##vlist = vlist[n:] #self._lock.acquire() #self.cache_size -= n
import socket from utils.utils import encode from utils.get_logger import get_logger logger = get_logger('PerfDataFetcher') class PerfDataFetcher(object): BUFSIZE = 1024 def __init__(self, server_addr): self.server_addr = server_addr def getStats(self, host, metric, stat, resolution, start, end): res = '' try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(self.server_addr) req = encode((host, metric, stat, resolution, start, end)) sock.send('%s\r\n' % req) while True: chunk = sock.recv(self.BUFSIZE) if not chunk: break res += chunk sock.close() except socket.error, e: print e logger.exception('')
from time import sleep from ThreadingXMLRPCServer import ThreadingXMLRPCServer, get_request_data from PerfDataReciever import DataReciever from RRD.RRDHandler import RRDHandler from models.Interface import sign_in_handler, check_alive, host_metric_conf, get_active_hosts from utils.load_config import load_config from utils.get_logger import get_logger from utils.utils import * _ = lambda f: os.path.dirname(os.path.abspath(f)) SERVER_CONFIG_PATH = _(__file__) + os.path.sep + "serverrc" logger = get_logger("server") class MonServer(object): def signIn(self, msg): try: platform_info = decode(msg) client_ip = get_request_data().client_address[0] logger.debug(client_ip) sign_in_handler(client_ip, platform_info) return 1 except Exception, e: logger.exception("") return 0
# temporary solution for importing upper level modules/packages _ = lambda f: os.path.dirname(os.path.abspath(f)) par_dir = _(_(__file__)) if par_dir not in sys.path: sys.path.append(par_dir) ############################################################### from ModelDB import ModelDB, ModelDBSession from resources import Host, VirtualHost, CPU, Disk, Partition, NetworkInterface import ID from utils.load_config import load_config from utils.utils import decode from utils.get_logger import get_logger logger = get_logger('models.interface') #config = load_config() cur_dir = _(__file__) DB_CONFIG_URL = cur_dir + os.path.sep + 'modelstore.conf' modeldb = ModelDB.getInstance(DB_CONFIG_URL) METRIC_CONFIG_PATH = cur_dir + os.path.sep + 'metric.conf' def sign_in_handler(ip, info): is_virtual = info.get('virtual') virt_type = info.get('virt_type') if not is_virtual:
"""data_reciever.py -- the UDPServer that recieves the monitor data """ from SocketServer import BaseRequestHandler, ThreadingUDPServer import time #from models.interface import getidbyip from models.Interface import Interface from utils.get_logger import get_logger from utils.utils import decode logger = get_logger('PerfDateReciever') class DRRequestHandler(BaseRequestHandler): def __init__(self, request, client_address, server, data_store_handler): self.data_store_handler = data_store_handler self.model_int = Interface() BaseRequestHandler.__init__(self, request, client_address, server) def handle(self): #logger.debug("recieved 1 msg from %s:%d" % \ # (self.client_address[0], self.client_address[1])) data = self.request[0] ip = self.client_address[0] try: #logger.debug(list(self.model_int.session.root.get("active", {}).keys())) host_obj = self.model_int.getActiveHost(ip)
from utils.get_logger import get_logger logger = get_logger("models.Relation") class Relation(object): def oneToOne(self, field, obj, foreign_field): # logger.debug('%s\n%s\n%s\n%s' % (self, field, obj, foreign_field)) setattr(obj, foreign_field, self) setattr(self, field, obj) def oneToMany(self, field, key, obj, foreign_field): # logger.debug('%s\n%s\n%s\n%s' % (self, field, obj, foreign_field)) setattr(obj, foreign_field, self) if not hasattr(self, field): setattr(self, field, dict()) # getattr(self, field).append(obj) getattr(self, field)[key] = obj def manyToMany(self, field, key, obj, foreign_field, foreign_key): # logger.debug('%s\n%s\n%s\n%s' % (self, field, obj, foreign_field)) if not hasattr(obj, foreign_field): setattr(obj, foreign_field, dict()) # getattr(obj, foreign_field).append(self) getattr(obj, foreign_field)[foreign_key] = self if not hasattr(self, field): setattr(self, field, dict()) getattr(self, field)[key] = obj def manyToOne(self, field, obj, foreign_field, foreign_key): # logger.debug('%s\n%s\n%s\n%s' % (self, field, obj, foreign_field))
############################################################### # temporary solution for importing upper level modules/packages _ = lambda f: os.path.dirname(os.path.abspath(f)) par_dir = _(_(__file__)) if par_dir not in sys.path: sys.path.append(par_dir) ############################################################### from includes.singletonmixin import Singleton, SingletonException from rrdtool_wrapper import * from utils.get_logger import get_logger from models.Interface import host_metric_conf logger = get_logger("RRD.RRDHandler") class RRDHandlerException(Exception): pass class RRDHandler(Singleton): _lock = threading.RLock() def __init__(self, root_dir, buffer_size=0): assert type(root_dir) is str assert type(buffer_size) is int self._root_dir = root_dir self._temp = {}