def memcacheds_group(group_id):
memcacheds = db_session.query(Memcacheds).filter_by(group_id = group_id).order_by(Memcacheds.id).all()
groups = db_session.query(Groups).filter_by(id = group_id).all()
import socket
_memcacheds = []
group_names = {}
for _group in groups :
group_names[_group.id] = _group.name
for _memcached in memcacheds :
try :
ip = _memcached.ip
port = _memcached.port
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(0.01)
address = (str(ip),int(port))
status = sk.connect((address))
status = 'ok'
except Exception, e :
status = 'error'
_memcacheds.append({"id":_memcached.id,
"ip":ip,
"port":port,
'status':status,
'group_id' : _memcached.group_id,
'group_name' : group_names[_memcached.group_id] if group_names.has_key(_memcached.group_id) else '/'
})
def memcached_do_add() :
result = {}
if not request.form.has_key('ip') :
result['status'] = 'no ip address'
elif not request.form.has_key('version') :
result['status'] = 'no version selected'
elif not request.form.has_key('port') :
result['status'] = 'no port inputed'
elif not request.form.has_key('memory') :
result['status'] = 'no memory inputed'
elif not request.form.has_key('group') :
result['status'] = 'no group selected'
else :
ip = request.form['ip'].strip().encode('utf8')
version = request.form['version']
port = str(request.form['port'].strip())
memory = str(request.form['memory'].strip())
group = str(request.form['group'])
param = request.form['param'].strip().encode('utf8')
isstart = str(request.form['isstart'])
_memcached = db_session.query(Memcacheds).filter_by(ip = ip,port = port).first()
if not _memcached :
if not param :
data = os.popen("bash -l /var/www/memcache_cloud/memcached_add.sh " + ip + " " + version + " " + port + " " + memory + " " + isstart).read()
else :
data = os.popen("bash -l /var/www/memcache_cloud/memcached_add.sh " + ip + " " + version + " " + port + " " + memory + " " + isstart + " '" + param + "'").read()
result['status'] = data
if (isstart == "1" and data == "add success\n") or isstart == "0" :
memcache = Memcacheds(ip=ip, port=port, memory=memory, status=1, group_id=group, version=version, parameters=param)
db_session.add(memcache)
db_session.commit()
else :
result['status'] = 'the memcached is already added'
return json.dumps(result)
def memcached_reset_stats(memcached_id) :
_memcached = db_session.query(Memcacheds).filter_by(id = memcached_id).first()
addr = _memcached.ip + ':' + str(_memcached.port)
print addr
client = Client([addr])
client.reset_stats()
return redirect(url_for(".memcached_detail", memcached_id = memcached_id))
def groups_index():
from sqlalchemy import func
groups = db_session.query(Groups, func.sum(Memcacheds.memory).label('group_total_memory'),func.count(Memcacheds.ip).label('memcached_count')) \
.outerjoin(Memcacheds, Memcacheds.group_id == Groups.id) \
.group_by(Groups.id).all()
stats_hit = {}
stats_useage = {}
for group in groups :
group_get = 0
group_hit = 0
group_useage = 0
group_free = 0
group_total = 0
memcacheds = db_session.query(Memcacheds).filter_by(group_id = group.Groups.id).all()
for memcached in memcacheds :
try :
addr = memcached.ip + ":" + str(memcached.port)
client = Client([addr])
stats = client.get_stats()[0][1]
stats['cmd_get'] = int(stats['cmd_get'])
stats['get_hits'] = int(stats['get_hits'])
stats['bytes'] = float(stats['bytes'])
stats['limit_maxbytes'] = float(stats['limit_maxbytes'])
stats['free'] = float(stats['limit_maxbytes'] - stats['bytes'])
except Exception, e :
continue
group_get += int(stats['cmd_get'])
group_hit += float(stats['get_hits'])
group_useage += round((stats['bytes'] / 1024 / 1024 / 1024),2)
group_free += round((stats['free'] / 1024 / 1024 / 1024),2)
group_total += round((stats['limit_maxbytes'] / 1024 / 1024 / 1024),2)
if (group_total != 0) :
group_use_per = round((group_useage / group_total * 100),2)
group_free_per = round((group_free / group_total * 100),2)
else :
group_use_per = "/"
group_free_per = "/"
stats_useage[group.Groups.id] = {"useage": group_useage, "free": group_free, "use_per": group_use_per, "free_per": group_free_per}
if (group_get != 0) :
stats_hit[group.Groups.id] = {"hit": round(((group_hit / group_get) * 100),2)}
else :
stats_hit[group.Groups.id] = {"hit": "/"}
def memcached_check() :
result = {}
if not request.form.has_key('ip') :
result['status'] = '0'
elif not request.form.has_key('port') :
result['status'] = '0'
else :
ip = request.form['ip'].strip().encode('utf8')
port = str(request.form['port'].strip())
_memcached = db_session.query(Memcacheds).filter_by(ip = ip,port = port).first()
if not _memcached :
result['status'] = '1'
else :
result['status'] = '0'
return json.dumps(result)
def get_hit_data() :
result = []
hits_data = {}
m_id = int(request.form['m_id'])
the_date = str(request.form['the_date'])
get_date = int(time.mktime(time.strptime(the_date + ' 00:00:00', '%Y-%m-%d %H:%M:%S')))
next_date = get_date + 24 * 3600
hits_history = db_session.query(Logs).filter(Logs.m_id == m_id,Logs.log_type == 1,Logs.time >= get_date,Logs.time < next_date).all()
for hits_history in hits_history :
hits_data['dater'] = str(time.strftime('%H.%M',time.localtime(hits_history.time)))
hits_data['hit_range'] = str(hits_history.num)
hits_data['get_num'] = str(hits_history.get)
#hits_data += "{date:'" + str(time.strftime('%H.%M',time.localtime(_hits_history.time))) + "',value:" + str(_hits_history.num) + "},"
result.append(hits_data.copy())
return json.dumps(result)
def memcached_do_edit() :
result = {}
memcached_id = int(request.form['memcached_id'])
ip = request.form['ip'].strip().encode('utf8')
version = int(request.form['version'])
port = int(request.form['port'].strip())
memory = int(request.form['memory'].strip())
group = int(request.form['group'])
param = request.form['param'].strip().encode('utf8')
_memcached = db_session.query(Memcacheds).filter_by(id = memcached_id).first()
_memcached.ip = ip
_memcached.version = version
_memcached.port = port
_memcached.memory = memory
_memcached.group_id = group
_memcached.parameters = param
db_session.commit()
result['status'] = 'Edit success!'
return json.dumps(result)
def group_do_add() :
result = {}
if not request.form.has_key('name') :
result['status'] = 'error'
result['message'] = 'please input name'
else :
name = request.form['name']
count = db_session.query(Groups).filter_by(name = name).count()
if (count > 0) :
result['status'] = 'error'
result['message'] = 'group ' + name + ' is existed!'
else :
group = Groups(name)
db_session.add(group)
db_session.commit()
result['status'] = 'ok'
result['message'] = 'add successed. group id is ' + str(group.id)
return json.dumps(result)
def memcached_add() :
groups = db_session.query(Groups).all()
group_names = {}
for _group in groups :
group_names[_group.id] = _group.name
return render_template('mc/memcached_add.html', group_names = group_names)
_memcached.port = port
_memcached.memory = memory
_memcached.group_id = group
_memcached.parameters = param
db_session.commit()
result['status'] = 'Edit success!'
return json.dumps(result)
@mod.route('/memcached-<memcached_id>-stop', methods=['GET', 'POST'])
def memcached_stop(memcached_id) :
try :
memcached_id = int(memcached_id)
except Exception, e :
return 'invalid memcached id'
_memcached = db_session.query(Memcacheds).filter_by(id = memcached_id).first()
result = {}
if not _memcached :
result['status'] = "the memcached not exist"
else :
data = os.popen("bash -l /var/www/memcache_cloud/memcached_stop.sh " + _memcached.ip + " " + str(_memcached.port) + " " + str(_memcached.memory) + " " + str(_memcached.version) + " '" + str(_memcached.parameters) + "'").read()
result['status'] = data
_memcached.status = 0
db_session.commit()
return json.dumps(result)
@mod.route('/memcached-<memcached_id>-delete', methods=['GET', 'POST'])
def memcached_delete(memcached_id) :
result = {}
try :
memcached_id = int(memcached_id)
def index():
return render_template("mc/index.html",
group_count = db_session.query(Groups).count(),
host_count = db_session.query(Memcacheds).group_by(Memcacheds.ip).count(),
memcached_count = db_session.query(Memcacheds).count())
# -*- coding: utf-8 -*-
from mc.db.db import db_session
from mc.model import *
from cache.cache_server import Client
import json
import os
import time
memcacheds = db_session.query(Memcacheds).order_by(Memcacheds.group_id).order_by(Memcacheds.id).all()
logs_dir = "/var/www/memcache_cloud/logs/"
for memcached in memcacheds :
ip = memcached.ip
port = memcached.port
addr = str(ip) + ":" + str(port)
try :
client = Client([addr])
stats = client.get_stats()[0][1]
current_get = stats['cmd_get']
current_hit = stats['get_hits']
mid = memcached.id
log_file = logs_dir + str(memcached.id) + "_data"
if os.path.isfile(log_file) :
filehandler = open(log_file,'r')
old_data = filehandler.readline().rstrip()
old_data_arr = old_data.split(' ')
if len(old_data_arr) == 2 :
old_get = old_data_arr[0]
def hosts_index():
from sqlalchemy import func
hosts = db_session.query(Memcacheds.ip, func.count(Memcacheds.ip).label('memcached_count')).group_by(Memcacheds.ip).all()
return render_template('mc/host_index.html', hosts = hosts)
