first

src/api/controller/BaseController.py

@@ -2,11 +2,58 @@
 import tornado.ioloop
 import tornado.web
 import dateutil.parser
-
+import redis
 
 class BaseController(tornado.web.RequestHandler):
 
     stats_provider = RedisLiveDataProvider.get_provider()
+
+    def getStatsPerServer(self, server):
+        try:
+            connection = redis.Redis(host=server[0], port=(int)(server[1]), db=0)
+            info = connection.info()
+            # when instances down ,this maybe slowly...
+            info.update({
+                "server_name"        : server,
+                "status"             : info.get("role"),
+                "last_save_humanized": info.get("last_save_time")
+            })
+
+            #master status
+            role = info["role"]
+            slaves=""
+
+            if(role == "master"):
+                connected_slaves = (int)(info["connected_slaves"])
+                slaves = ""
+                for i in range(0, connected_slaves):
+                    slaves += info["slave" + (str)(i)]
+            else:
+                master_host = info["master_host"]
+                master_port = (str)(info["master_port"])
+                master_link_status = info["master_link_status"]
+                master_sync_in_progress = info["master_sync_in_progress"]
+                if(master_host!=""):
+                    slaves=master_host+":"+(str)(master_port)+","+master_link_status
+                    if(master_sync_in_progress==1):
+                        slaves+=",syncing"
+            info['master_slaves']=slaves
+
+
+        except redis.exceptions.ConnectionError:
+            info = {
+                "role"              :"down",
+                "uptime_in_seconds" :0,
+                "total_commands_processed":0,
+                "used_memory_human" :"",
+                "connected_clients" :"",
+                "status"            : "down",
+                "server_name"       : server,
+                "connected_clients" : 0,
+                "used_memory_human" : '?',
+            }
+
+        return info
 
     def datetime_to_list(self, datetime):
         """Converts a datetime to a list.
@@ -26,7 +73,7 @@ def average_data(self, data):
         """
         average = []
 
-        deviation=1024*1024
+        deviation = 1024 * 1024
 
         start = dateutil.parser.parse(data[0][0])
         end = dateutil.parser.parse(data[-1][0])
@@ -54,8 +101,8 @@ def average_data(self, data):
                        current_memory > current_current:
                         average.pop()
                         average.append([dt, max_memory, current_memory])
-                        current_max=max_memory
-                        current_current=current_memory
+                        current_max = max_memory
+                        current_current = current_memory
         elif hours > 0:
             current_max = 0
             current_current = 0
@@ -67,12 +114,12 @@ def average_data(self, data):
                 if d.hour != current:
                     current = d.hour
                     average.append([dt, max_memory, current_memory])
-                    current_max=max_memory
-                    current_current=current_memory
-                    keep_flag=False
+                    current_max = max_memory
+                    current_current = current_memory
+                    keep_flag = False
                 elif abs(max_memory - current_max) > deviation or \
                      abs(current_memory - current_current) > deviation:
-                    #average.pop()
+                    # average.pop()
                     average.append([dt, max_memory, current_memory])
                     current_max = max_memory
                     current_current = current_memory
@@ -100,18 +147,18 @@ def average_data(self, data):
                     keep_flag = False
                 elif abs(max_memory - current_max) > deviation or \
                      abs(current_memory - current_current) > deviation:
-                    #average.pop()
+                    # average.pop()
                     average.append([dt, max_memory, current_memory])
                     current_max = max_memory
                     current_current = current_memory
                     keep_flag = True
                 elif max_memory > current_max or \
                     current_memory > current_current:
-                    if keep_flag!=True:
+                    if keep_flag != True:
                         average.pop()
-                    average.append([dt,max_memory,current_memory])
-                    current_max=max_memory
-                    current_current=current_memory
-                    keep_flag=False
+                    average.append([dt, max_memory, current_memory])
+                    current_max = max_memory
+                    current_current = current_memory
+                    keep_flag = False
 
         return average

src/api/controller/CommandsController.py

@@ -2,55 +2,31 @@
 import tornado.ioloop
 import tornado.web
 import dateutil.parser
-from datetime import datetime, timedelta
+import datetime
 
 
 class CommandsController(BaseController):
 
     def get(self):
         """Serves a GET request.
         """
-        return_data = dict(data=[], timestamp=datetime.now().isoformat())
+        return_data = dict(data=[],
+                           timestamp=datetime.datetime.now().isoformat())
 
         server = self.get_argument("server")
         from_date = self.get_argument("from", None)
         to_date = self.get_argument("to", None)
 
-        if from_date == None or to_date == None:
-            end = datetime.now()
-            delta = timedelta(seconds=120)
+        if from_date==None or to_date==None or len(from_date)==0:
+            end = datetime.datetime.now()
+            delta = datetime.timedelta(seconds=300)
             start = end - delta
         else:
             start = dateutil.parser.parse(from_date)
-            end = dateutil.parser.parse(to_date)
+            end   = dateutil.parser.parse(to_date)
 
-        difference = end - start
-        # added to support python version < 2.7, otherwise timedelta has
-        # total_seconds()
-        difference_total_seconds = difference.days * 24 * 3600
-        difference_total_seconds += difference.seconds
-        difference_total_seconds += difference.microseconds / 1e6
-
-        minutes = difference_total_seconds / 60
-        hours = minutes / 60
-        seconds = difference_total_seconds
-
-        if hours > 120:
-          group_by = "day"
-        elif minutes > 120:
-          group_by = "hour"
-        elif seconds > 120:
-          group_by = "minute"
-        else:
-          group_by = "second"
-
-        combined_data = []
-        stats = self.stats_provider.get_command_stats(server, start, end,
-                                                      group_by)
-        for data in stats:
-            combined_data.append([data[1], data[0]])
-
-        for data in combined_data:
-            return_data['data'].append([self.datetime_to_list(data[0]), data[1]])
+        data = self.stats_provider.get_keys_info(server, start, end)
+
+        return_data['data']=data
 
         self.write(return_data)

src/api/controller/InfoController.py

@@ -3,14 +3,16 @@
 import tornado.ioloop
 import tornado.web
 import re
+import redis
 
 
 class InfoController(BaseController):
     def get(self):
         """Serves a GET request.
         """
-        server = self.get_argument("server")
-        redis_info = self.stats_provider.get_info(server)
+        server = self.get_argument("server").split(':')
+
+        redis_info = self.getStatsPerServer(server)
         databases=[]
 
         for key in sorted(redis_info.keys()):
@@ -35,7 +37,7 @@ def get(self):
         commands_processed = redis_info['total_commands_processed']
         commands_processed = self.shorten_number(commands_processed)
         redis_info['total_commands_processed_human'] = commands_processed
-
+       
         self.write(redis_info)
 
     def shorten_time(self, seconds):

src/api/controller/InfoListController.py

@@ -0,0 +1,38 @@
+from BaseController import BaseController
+from api.util import settings
+import redis
+
+class InfoListController(BaseController):
+
+    def get(self):
+        response = {}
+        response['data']=[]
+        for server in self.read_server_config():
+            info=self.getStatsPerServer(server)
+
+            info.update({
+                "addr" : info.get("server_name")[0].replace(".", "_") +  str(info.get("server_name")[1]),
+            })
+
+            screen_strategy = 'normal'
+            if info.get("status") == 'down':
+                screen_strategy = 'hidden'
+
+            info.update({
+                "screen_strategy": screen_strategy,
+            })
+
+            #key = info.get("addr")
+            response["data"].append(info)
+
+
+        self.write(response)
+
+    def read_server_config(self):
+        server_list = []
+        redis_servers = settings.get_redis_servers()
+
+        for server in redis_servers:
+            server_list.append([server['server'],server['port']])
+
+        return server_list

src/api/controller/SettingsController.py

@@ -0,0 +1,44 @@
+from BaseController import BaseController
+from api.util import settings
+
+class SettingsController(BaseController):
+
+    def get(self):
+        server_list=""
+        for server in settings.get_redis_servers():
+            server_list+= "%(server)s:%(port)s\r\n" % server
+
+        sms_repl=0;
+        sms_stats=0;
+        try:
+            sms=settings.get_master_slave_sms_type()
+            sms=sms.split(',')
+            sms_repl=(int)(sms[0])
+            sms_stats=(int)(sms[1])
+        except:
+            pass
+
+        servers = {"servers": server_list,"sms1":sms_repl,"sms2":sms_stats}
+        self.write(servers)
+
+    def post(self):
+        try:
+            server_list=self.get_argument("servers")
+            sms1=(int)(self.get_argument("sms1"))
+            sms2=(int)(self.get_argument("sms2"))
+            sms= "%s,%s" %(sms1,sms2)
+
+            servers=[]
+            for server in server_list.split('\n'):
+                eps=server.split(':')
+                if(len(eps)!=2):
+                    raise Exception('server Ip format error.');
+                ip=eps[0]
+                port=eps[1]
+
+                servers.append({'server':ip,'port':(int)(port)})
+            settings.save_settings(servers, sms)
+            self.write({"status":200})
+        except Exception,ex:
+            self.write({"status":500,"error":ex.message})
+

src/api/controller/StatusController.py

@@ -0,0 +1,33 @@
+from BaseController import BaseController
+import tornado.ioloop
+import tornado.web
+import dateutil.parser
+import datetime
+
+class StatusController(BaseController):
+
+    def get(self):
+        return_data = {}
+        return_data['data']=[]
+
+        server = self.get_argument("server")
+        from_date = self.get_argument("from", None)
+        to_date = self.get_argument("to", None)
+
+        if from_date == None or to_date == None or len(from_date) == 0:
+            end = datetime.datetime.now()
+            delta = datetime.timedelta(seconds=300)
+            start = end - delta
+        else:
+            start = dateutil.parser.parse(from_date)
+            end = dateutil.parser.parse(to_date)
+
+        data = self.stats_provider.get_status_info(server, start, end)
+
+        for item in data:
+            row=item[1]
+            timestamp = datetime.datetime.fromtimestamp(int(row['timestamp']))
+            row['time']= timestamp.strftime('%Y-%m-%d %H:%M:%S')
+            return_data['data'].append(row)
+
+        self.write(return_data)

src/api/util/settings.py

@@ -1,19 +1,46 @@
 import json
+import os
+
+curpath=''
 
 def get_settings():
     """Parses the settings from redis-live.conf.
     """
     # TODO: Consider YAML. Human writable, machine readable.
-    return json.load(open("redis-live.conf"))
+    global curpath
+    if(curpath==''):
+        curpath=os.path.abspath('.')
+
+    return json.load(open(curpath+ "/redis_live.conf"))
 
 def get_redis_servers():
     config = get_settings()
     return config["RedisServers"]
 
+def get_redis_alerturi():
+    config = get_settings()
+    return config["sms_alert"]
+
 def get_redis_stats_server():
     config = get_settings()
     return config["RedisStatsServer"]
 
 def get_data_store_type():
     config = get_settings()
     return config["DataStoreType"]
+
+def get_master_slave_sms_type():
+    config = get_settings()
+    return config['master_slave_sms']
+
+def save_settings(redisServers,smsType):
+    config = get_settings()
+    config["RedisServers"]= redisServers;
+    config['master_slave_sms']=smsType;
+
+    data = json.dumps(config)
+    data = data.replace('}', '}\r\n')
+    output = open(os.path.abspath('.') + "/redis_live.conf", "w")
+    output.truncate()
+    output.write(data)
+    output.close()