def __init__(self, ip, port):
#本机IP
self.ip = ip
#本机端口
self.port = port
#self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
class MonitorClient(object):
def __init__(self,server,port):
self.server = server#服务器端ip
self.port = port#端口
self.configs = {}#获取配置信息
self.redis = RedisHelper()
#将传过来的数据序列化
def format_msg(self,key,value):
msg = {key,value}
return pickle.dumps(msg)
def get_configs(self):
config = self.redis.get('HostConfig::%s'%host_ip)
if config:
self.configs = pickle.loads(config)
return True
def handle(self):
if self.get_configs():
print '---going to monitor services---',self.configs
while True:
for service_name, val in self.configs['servcies'].item():
interval,plugin_name,last_check = val
if time.time() - last_check >= interval:
#need to kick off the next run
#启动一个线程，这个线程完成对相关信息的监控并返回给服务器的任务
t = threading.Thread(target=self.task,args=[service_name,plugin_name])
t.start()
self.configs['services'][service_name][2] = time.time() #update last check time
else:
next_run_time = interval - (time.time() - last_check)
print '\033[32;1m%s\033[0m will be run in next \033[32;1m%s\033[0m seconds'%(service_name,next_run_time)
#将所有的服务循环完一遍后，停1s
time.sleep(1)
else:
print '---could not found any configurations for this hosts---'
#修改该方法，使其负责完成监控，收集客户端信息然后发到服务器端的任务
def task(self,servcie_name,plugin_name):
print '---going to run service:',servcie_name,plugin_name
#通过反射的方式从plugin_api中，取出获取的同名字符串插件方法。
func = getattr(plugin_api, plugin_name)
result = func() # 然后执行方法
#方法得到的结果为字典类型，所以需要序列化然后存到redis中
#self.redis.public(pickle.dumps(result))
msg = self.format_msg('report_service_data',
{'ip':host_ip,
'service_name':servcie_name,
'data':result,
}
)
#上面的‘report_service_data’告诉服务端这发送的是监控信息，这样做的好处是细化了功能，
#上面的一系列操作不仅可以用来监控数据，还可以做例如传文件的功能，所以为以后扩展功能预留空间。
self.redis.public(msg)
def run(self):
self.handle()
def test_decr(self):
RedisHelper.redis_flushdb()
# create a counter and decrease value
params = {'prefix': "test", 'ttl': 120}
zcount = RedisZSetCounter(self.redis_server, params)
tmp = zcount.decr('test_id', 'a', 1.0)
# now check that the value in redis is right
key = zcount.get_key('test_id')
val = RedisHelper.get_connection().zscore(key, 'a')
self.assertEqual(tmp, val, "wrong value for counter")
class MonitorClient(object):
def __init__(self, server, port):
self.server = server
self.port = port
self.configs = {}
self.redis = RedisHelper() #建立redis链接
def format_msg(self, key, value): #专门用来处理数据
msg = {key: value}
return pickle.dumps(msg)
def get_configs(self):
config = self.redis.get('HostConfig::%s' % self.server)
if config: #redis里存在此key
self.configs = pickle.loads(config)
return True
def handle(self):
if self.get_configs():
print "--- going to monitor services ---", self.configs
#开始监控
while True:
for service_name, val in self.configs['services'].items():
#print service_name,val
interval, plugin_name, last_check = val
if time.time() - last_check >= interval: #代表超时，需要启一个新线程运行了
t = threading.Thread(target=self.task,
args=[service_name, plugin_name])
t.start()
self.configs['services'][service_name][2] = time.time(
) #更新时间戳
else:
next_run_time = interval + last_check - time.time()
print "%s will be run in next %s seconds" % (
service_name, next_run_time)
time.sleep(2)
else:
print "--- could not found any configurations for this host ---"
def task(self, service_name, plugin_name):
print "---going to run service:", service_name, plugin_name
func = getattr(plugin_api, plugin_name)
result = func() #执行插件
#把执行结果发给redis
#self.redis.publish(pickle.dumps(result))
msg = self.format_msg('report_service_data', {
'ip': host_ip,
'service_name': service_name,
'data': result
})
self.redis.public(msg)
def run(self):
self.handle()
class MonitorClient(object):
def __init__(self, service, port):
self.server = service
self.port = port
self.configs = {}
self.redis = RedisHelper()
@staticmethod
def format_msg(key, value):
msg = {key: value}
return pickle.dumps(msg)
def get_configs(self):
config = self.redis.get('HostConfig::%s' % host_ip)
if config:
self.configs = pickle.loads(config) # 将config序列化后赋值给全局变量
return True
def handle(self):
if self.get_configs():
print 'Going to monitor services ', self.configs
while True:
for service_name, val in self.configs['services'].items():
interval, plugin_name, last_check = val # server.core.serialize.py传入的三个参数
if time.time() - last_check >= interval: # need to kick off the next run
t = threading.Thread(target=self.task, args=[service_name, plugin_name])
t.start()
self.configs['services'][service_name][2] = time.time() # update last check time
else:
next_run_time = interval - (time.time() - last_check) # 下一次运行时间
print '\033[32;1m%s\033[0m will be run in next time \033[32;1m%s\033[0m seconds' \
% (service_name, next_run_time)
time.sleep(1)
else:
print 'Could not found any configurations for this host.'
def task(self, service_name, plugin_name):
print 'Going to run service:', service_name, plugin_name
func = getattr(plugin_api, plugin_name) # 通过反射导入plugins.plugin_api里面的监控方法
result = func()
# self.redis.public(pickle.dumps(result))
msg = self.format_msg(
'report_service_data',
{
'ip': host_ip,
'service_name': service_name,
'data': result,
}
)
self.redis.public(msg)
def run(self):
self.handle()
def flush_all_host_configs_into_redis():
applied_hosts = []
for group in hosts.monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
redishelper = RedisHelper()
for host in applied_hosts:
host_config = host_config_serialize(host)
key = 'HostConfig::%s' % host
redishelper.set(key,pickle.dump(host_config))
return True
def flush_all_host_configs_into_redis(): #把所有配置刷到redis
applied_hosts = []
redis = RedisHelper()
for group in monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
for host_ip in applied_hosts:
host_config = host_config_serializer(host_ip)
# 序列化字典后存入redis
key = 'HostConfig::%s' % host_ip
redis.set(key, pickle.dumps(host_config))
def flush_all_host_configs_into_redis():
applied_hosts = []
redis = RedisHelper()
for group in hosts.monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
for host_ip in applied_hosts:
host_config = host_config_serializer(host_ip)
key = 'HostConfig::%s' % host_ip
redis.set(key, pickle.dumps(host_config))
return True
def test_last_n(self):
RedisHelper.redis_flushdb()
params = {'prefix': "test", 'ttl': 120}
zcount = RedisZSetCounter(self.redis_server, params)
zcount.incr('test_id', 'c', 6)
zcount.incr('test_id', 'b', 3)
zcount.incr('test_id', 'a', 1)
zcount.incr('test_id', 'd', 2)
last3 = zcount.last_n('test_id', 3)
print last3
self.assertEqual(last3[0][0], 'a', "wrong ranking 1st position should be 'c'")
self.assertEqual(last3[1][0], 'd', "wrong ranking 2nd position should be 'b'")
self.assertEqual(last3[2][0], 'b', "wrong ranking 3rd position should be 'c'")
def flush_all_host_configs_into_redis():
applied_hosts = []
redis = RedisHelper()
for group in hosts.monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
for host_ip in applied_hosts:
host_config = host_config_serialize(host_ip)
#redis中只存字符串和数字，并不认识python的字典，所以需要序列化（序列化后就变成字符串了），因为这个程序都是用python写的，而且pickle可以序列化的数据类型比较多
key = 'HostConfig::%s' %host_ip #给这个key加一个标识，这样以后添加其他信息时方便区分识别
redis.set(key,pickle.dumps(host_config))
return True
def flush_all_host_configs_into_redis():
applied_hosts = []
redis = RedisHelper()
for group in hosts.monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
for host_ip in applied_hosts:
host_config = host_config_serializer(host_ip)
key = 'HostConfig::%s' % host_ip
redis.set(key, pickle.dumps(host_config))
print host_config
return True
class MonitorServer(object):
def __init__(self,ip,port):
self.ip = ip
self.port = port
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def handle(self):
redis_sub = self.redis.subscribe()
#redis_sub.parse_response()
while True:
msg = redis_sub.parse_response()
print 'recv:',msg
action_process.action_process(self,msg)#把self传过去的好处是，在另一个模块中也可以调用这个模块中已经生成的实例，而不需要再重新实例化出一个新的实例，相当于把实例传过去
print '---waiting for new msg---'
for host,val in self.hosts['hosts'].items():
print host,val
def run(self):
print '---starting monitor server---'
self.handle()
def process(self):
pass
class MonitorServer(object):
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.hosts = serialize.flush_all_host_configs_into_redis()
self.redis = RedisHelper()
def handle(self):
redis_sub = self.redis.subscribe()
#redis_sub.parse_response()
while True:
msg = redis_sub.parse_response()
print 'recv:', msg
action_process.action_process(self, msg)
print '----waiting for new msg----'
# received data
for host, val in self.hosts['HostConfig'].items():
print host, val
def run(self):
print '----starting monitor server----'
self.handle()
def process(self):
pass
class MonitorServer(object):
def __init__(self, ip, port):
#本机IP
self.ip = ip
#本机端口
self.port = port
#self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def handle(self):
redis_sub = self.redis.subscribe()
#redis_sub.parse_response()
while True:
msg = redis_sub.parse_response()
#收到消息就打印，没有就堵塞
print('recv:', msg)
#收到丢给action_process
action_process.action_process(self, msg)
print('-----waiting for new msg------')
for host, val in self.hosts['hosts'].items():
print(host, val)
def run(self):
print('--------starting monitor server -------')
self.handle()
def process(self):
pass
class MonitorServer(object):
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def handle(self):
redis_sub = self.redis.subscribe()
redis_sub.parse_response()
while True:
msg = redis_sub.parse_response()
# print('recv:', msg)
action_process.action_process(self, msg) # 传入 self 实例本身, 和订阅的数据
print('----waiting for new msg ---')
# received data
for host, val in self.hosts['hosts'].items():
print(host, val)
def run(self):
print('----starting monitor server----')
self.handle()
def process(self):
pass
def get_redis(self):
"""
Get redis connection, lazy loading
:return: redis object
"""
if self.redis is None:
self.redis = RedisHelper.get_connection()
return self.redis
class MonitorClient(object):
def __init__(self,server,port):
self.server = server
self.port = port
self.configs = {}
self.redis = RedisHelper()
def get_configs(self):
value = self.redis.get('HostConfig::%s' % host_ip)
if value:
self.configs =pickle.load(value)
return True
return False
def handle(self):
if self.get_configs():
print '--going to monitor services-- ',self.configs
while True:
for service_name,val in self.configs['services'].items():
interval,plugin_name,last_check = val
if time.time() - last_check >= interval:
t = threading.Thread(target=self.task,args=[service_name,plugin_name])
t.start()
self.configs['serivces'][service_name][2] = time.time()
else:
next_run_time = interval - (time.time()-last_check)
print '%s will be run in next %s seconds' % (service_name,next_run_time)
time.sleep(1)
else:
print '--could not found any configuration for this host---'
def task(self,service_name,plugin_name):
print '---going to run service:',service_name
func = getattr(plugin_api,plugin_name)
result = func()
self.redis.public(pickle.dump(result))
def run(self):
self.handle()
class MonitorServer(object): #创建主的类，调用连接Redis&调用serialize序列化，把监控模板上传至Redis
def __init__(self):
self.r = RedisHelper()
self.save_configs()
self.sub = self.r.subscribe()
def start(self):
self.monitor_data_processing()
while True:
client_data = json.loads(self.sub.parse_response()[2])
client_data['last_update'] = time.time()
#print client_data
business_type = client_data.keys()[0]
action_process.action_process(self,business_type,client_data)
'''
self.r.set('ServiceData::%s:%s' % (client_data['report_monitor_data']['ip_address'],
client_data['report_monitor_data']['service_name']),
client_data)
'''
#数据存入到Redis中并且存储的相同数据只保留一条，数据不断刷新
def monitor_data_processing(self): #启用多进程处理任务
p = multiprocessing.Process(target=self.monitor_data_handling,)
p.daemon = True #设置为dameon模式，主进程挂掉之后，关闭进程
p.start()
def monitor_data_handling(self):#所有的数据逻辑处理方法
print '''---starting a new process to deal with monitor data ---'''
while True:
client_data = self.r.keys("ServiceData::*")
for i in client_data:
host_ip,host_server = i.split('::')[1].split(':')
action_process.action_work(self,i,host_server)
self.r.del_key(i)
print i,'is work done'
def save_configs(self):
serialize.push_config_toredis(self,hosts.monitored_groups)#这里把self传过去，在push_config_toredis中即可调用实例
def on_click(self):
input_value = self.textbox.text()
# print(type(input_value))
if self.pattern.match(input_value):
textboxValue = input_value
print(textboxValue)
#发布到redis
obj = RedisHelper()
for i in range(1, 8):
obj.publish({
"type": "add_sn",
"sn": textboxValue,
"complete": 1,
"station": 'ST' + str(i) + '0'
}) #发布
rd = obj.get_redis()
while True:
now_time = int(time.time())
if rd.sadd("option_sets", now_time):
rd.hset(
"option_hashes", now_time,
'{"method": "write_complete", "params": "%s"}' %
"ST10")
rd.publish("START", now_time)
print('station_name complete')
break
#结果存到label中
self.lb1.setText(textboxValue)
self.lb1.adjustSize()
"""打印完毕之后清空文本框"""
self.textbox.setText('')
else:
self.textbox.setText('')
print("序列号位数不对")
class sucker(object):
def __init__(self):
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def handle(self):
for host_ip,v in self.hosts['hosts'].items():
self.hosts['hosts'][host_ip]['configs'] = serialize.config_serializer(host_ip, detail=True)
print host_ip,v
print 'status data:',self.pull_host_data(host_ip)
def pull_host_data(self,ip):
key = 'StatusData::%s' % ip
data =self.redis.get(key)
if data:
return pickle.loads(data)
class sucker(object):
def __init__(self):
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def handle(self):
for host_ip,v in self.hosts['hosts'].items():
self.hosts['hosts'][host_ip]['configs'] = serialize.config_serializer(host_ip,detail=True)
print(host_ip,v)
print('status data:',self.pull_host_data(host_ip))
def pull_host_data(self,ip):
key = 'StatusData::%s' % ip
data =self.redis.get(key)
if data:
return pickle.loads(data)
def init_all_host_configs_into_client():
applied_hosts = []
redis = RedisHelper()
for group in hosts.monitored_groups:
applied_hosts.extend(group.hosts)
applied_hosts = set(applied_hosts)
configs = {'configs': {}}
for host_ip in applied_hosts:
host_config = host_config_serializer(host_ip)
key = 'HostConfig::%s' % host_ip
configs['configs'][key] = pickle.dumps(host_config)
return configs
class MonitorServer(object):
def __init__(self,ip,port):
self.ip = ip
self.port = port
self.hosts = serialize.host_config_serialize()
self.redis = RedisHelper()
def handle(self):
redis_sub = self.redis.subscribe()
while True:
msg = redis_sub.parse_response()
print 'recv:',msg
action_process.action_process(self,msg)
print '---waiting for new msg ---'
for host,val in self.hosts['hosts'].items():
print host,val
def run(self):
self.handle()
def process(self):
pass
#!/usr/bin/env python
# -*- coding:utf-8 -*-
''''订阅方'''
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
from redishelper import RedisHelper
obj = RedisHelper()
redis_sub = obj.subscribe(channel='liyanliang')
while True:
msg = redis_sub.parse_response()
print('接收：'.decode(), msg)
def __init__(self):
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def __init__(self):
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
#!/usr/bin/env python # -*- coding: UTF-8 -*- __author__ = "Sigai" from redishelper import RedisHelper import time publisher = RedisHelper() result = publisher.publish(time.ctime()) print(result)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
'''
发布者
'''
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
from redishelper import RedisHelper
obj = RedisHelper()
#订阅了100次
n = 1
while True:
if n <= 100:
obj.public(chanel='liyanliang', msg='no usr moren')
else:
obj.unsubscribe(chanel='liyanliang')
print('取消订阅')
break
n += 1
def __init__(self,server,port):
self.server = server#服务器端ip
self.port = port#端口
self.configs = {}#获取配置信息
self.redis = RedisHelper()
#! /usr/bin/env python
# coding:utf-8
"""
在redis设置一个key,然后去获取他得值
"""
from redishelper import RedisHelper
r = RedisHelper()
# 设置key
r.set('name','wweeee2222')
# 获取key
print(r.get('name'))
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.hosts = serialize.flush_all_host_configs_into_redis()
self.redis = RedisHelper()
def __init__(self,ip,port):
self.ip = ip
self.port = port
self.hosts = serialize.host_config_serialize()
self.redis = RedisHelper()
__author__ = "那位先生Beer"
from redishelper import RedisHelper
obj = RedisHelper()
redis_sub = obj.subscribe()
while True: #不停地接收消息
msg = redis_sub.parse_response() #这才是真正的接收消息
print(msg)
class MonitorClient(object):
def __init__(self, server, port):
self.server = server
self.port = port
self.configs = {}
self.lock = threading.Lock()
self.redis = RedisHelper()
def format_msg(self, key, value):
"""
将 message 序列化
:param key:
:param value:
:return:
"""
msg = {key: value}
return pickle.dumps(msg)
def get_configs(self):
"""
向 server 发送 client ip 获取 监控指标
:return:
"""
msg = self.format_msg('get_host_configs', {'ip': client_ip})
print('-----get host monitor configs----') # ,msg
redis_pub = self.redis.public(msg)
count = 1
while count < 30: # 重复30 次, 从 redis 中获取 client 的监控指标数据
configs = self.redis.get(client_ip)
if configs:
# print configs
return pickle.loads(configs)
else:
count += 1
time.sleep(1)
sys.exit('Error:could not get client monitor configurations!')
def handle(self):
"""
循环处理
:return:
"""
self.configs = self.get_configs()
if self.configs['services']:
print('--going to monitor ---', self.configs)
# {'services': {'linux_memory': [30, 'get_memory_info', 0], 'linux_cpu': [30, 'get_cpu_status', 0]}}
while True: # 依据监控指标进行循环执行脚本
for service_name, val in self.configs['services'].items():
interval, plugin_name, last_check = val
next_run_time = interval - (time.time() - last_check)
if time.time() - last_check >= interval:
print(
'service\033[32;1m%s\033[0m has reached monitor interval'
% service_name)
t = threading.Thread(target=self.task_run,
args=[
service_name,
plugin_name,
])
t.start()
self.configs['services'][service_name][2] = time.time()
else:
print(
'service\033[34;1m%s\033[0m next run time is \033[34;1m%s\033[0m seconds later'
% (service_name, next_run_time))
time.sleep(1)
# print self.configs
else:
print('---nothing to monitor,configs dict is empty---')
def task_run(self, service_name, plugin_name):
"""
执行监控脚本, 向 redis 发布数据
:param service_name:
:param plugin_name:
:return:
"""
plugin_func = getattr(plugin_api, plugin_name)
result = plugin_func()
msg = self.format_msg('report_service_data', {
'ip': client_ip,
'service_name': service_name,
'data': result,
})
self.redis.public(msg)
def run(self):
self.handle()
class MonitorClient(object):
def __init__(self,server,port):
self.server = server
self.port = port
self.configs = {}
self.lock = threading.Lock()
self.redis = RedisHelper()
def format_msg(self,key,value):
msg = {key: value}
return pickle.dumps(msg)
def get_configs(self):
msg = self.format_msg('get_host_configs', {'ip': client_ip})
print u'-----get host monitor configs----' #,msg
redis_pub = self.redis.public(msg)
count = 1
while count<30:
configs = self.redis.get(client_ip)
if configs:
#print configs
return pickle.loads(configs)
else:
count +=1
time.sleep(1)
sys.exit('Error:could not get client monitor configurations!')
def handle(self):
self.configs = self.get_configs()
if self.configs['services']:
print '--going to monitor ---',self.configs
#{'services': {'linux_memory': [30, 'get_memory_info', 0], 'linux_cpu': [30, 'get_cpu_status', 0]}}
while True:
for service_name,val in self.configs['services'].items():
interval,plugin_name,last_check = val
next_run_time = interval - (time.time() - last_check)
if time.time() - last_check >= interval:
print 'service\033[32;1m%s\033[0m has reached monitor interval' % service_name
t = threading.Thread(target=self.task_run,args=[service_name,plugin_name,])
t.start()
self.configs['services'][service_name][2] = time.time()
else:
print 'service\033[34;1m%s\033[0m next run time is \033[34;1m%s\033[0m seconds later' % (service_name,next_run_time)
time.sleep(1)
#print self.configs
else:
print '---nothing to monitor,configs dict is empty---'
def task_run(self,service_name,plugin_name):
plugin_func = getattr(plugin_api, plugin_name)
result = plugin_func()
msg = self.format_msg('report_service_data',
{'ip': client_ip,
'service_name':service_name,
'data': result,
})
self.redis.public(msg)
def run(self):
self.handle()
from redishelper import RedisHelper
obj = RedisHelper()
obj.public('hello')
obj.public('how old are you')
def __init__(self, server, port):
self.server = server
self.port = port
self.configs = {}
self.redis = RedisHelper() #建立redis链接
def __init__(self,server,port):
self.server = server
self.port = port
self.configs = {}
self.lock = threading.Lock()
self.redis = RedisHelper()
def __init__(self, server, port):
self.server = server
self.port = port
self.configs = {}
self.lock = threading.Lock()
self.redis = RedisHelper()
def __init__(self):
self.r = RedisHelper()
self.save_configs()
self.sub = self.r.subscribe()
class MonitorServer(object):
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.hosts = serialize.all_host_configs()
self.redis = RedisHelper()
def get_config(self, host):
applied_services = []
config_list = {host: {}}
for group in monitored_groups:
if host in group.hosts:
applied_services.extend(
group.services) #后面追加列表，group.services是一台主机所有配置的服务
applied_services = set(applied_services) #去重，列表转集合去掉重复项
for service in applied_services:
service = service() #把类实例化
config_list[host][service.name] = service.triggers
#print config_list
return config_list[host]
def handle(self):
redis_sub = self.redis.subscribe()
value_dic = {}
for host in self.hosts['hosts'].keys():
value_dic[host] = {
'MemUsage': [],
'iowait': [],
'idle': [],
'load1': []
} #用来存数据
print value_dic
while True:
msg = redis_sub.parse_response()
#print 'recv:',msg
action_process.action_process(
self,
msg) #self是将本实例传给action_process方法，action_process不再需要导入redis
print '----waiting for new msg ---'
#received data
for host, val in self.hosts['hosts'].items():
if val is not None:
#print host, val
#get config
configs = self.get_config(host)
for service_name, val2 in val.items():
print "hahaha", configs[service_name]
c_time_stamp = val2['time_stamp']
data = val2['data']
#print "dadada",data
time_pass_since_last_recv = time.time() - c_time_stamp
#print "Time pass:"******"\033[41;1m Service %s has no data for %ss\033[0m" % (
service_name, time_pass_since_last_recv)
else:
if 'MemUsage' in data.keys():
key = 'MemUsage'
key_value = int(data['MemUsage']) * 100 / int(
data['MemTotal'])
print key, ": ", key_value
value_dic[host][key].append(float(key_value))
else:
for key in configs[service_name].keys():
key_value = data[key]
print key, ": ", key_value
value_dic[host][key].append(
float(key_value))
for key in configs[service_name].keys():
if len(value_dic[host][key]) > 5: #只保留5个数，测试用
del value_dic[host][key][0]
configs[service_name][key]['func'](
configs[service_name][key]['warning'],
configs[service_name][key]['operator'],
value_dic[host][key][-6:-1])
#times = int(configs[service_name][key]['minutes'])*60/
print value_dic
def run(self):
print '----starting monitor server----'
self.handle()
def process(self):
pass
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
__author__ = "Sigai"
from redishelper import RedisHelper
subscriber = RedisHelper()
sub = subscriber.subscribe()
while True:
msg = sub.parse_response()
print(msg)
__author__ = "那位先生Beer" from redishelper import RedisHelper #在指令环境下 public 频道 “消息” obj = RedisHelper() obj.public( 'hello' )
def __init__(self, server, config):
RedisHelper.set_server(server)
self.redis = None
CounterBase.__init__(self, config['prefix'], config['ttl'])
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# author: xiatian
from redishelper import RedisHelper
obj = RedisHelper()
obj.public('i am xiatian!')
#! /usr/bin/env python
# coding:utf-8
"""
redis 订阅端
"""
from redishelper import RedisHelper
import time
r=RedisHelper()
recv = r.subscribe()
while True:
print(r.subscribe())
__author__ = 'qgw'
from redishelper import RedisHelper
obj = RedisHelper()
obj.public('how are you')
# obj.public('你怎么样')
def __init__(self, service, port):
self.server = service
self.port = port
self.configs = {}
self.redis = RedisHelper()
