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 = {}
