Added notification stub, lot of refactoring, set default http_server_host to 127.0.0.1 and bug fixes.

bin/uplink

@@ -36,7 +36,7 @@ import time
 from uplink.configuration import Configuration
 from uplink.uplink import Uplink
 
-__version__ = '0.7.0'
+__version__ = '0.8.0'
 __author__ = 'Johannes Findeisen <you@hanez.org>'
 
 logger = logging.getLogger(__name__)
@@ -98,10 +98,9 @@ def main():
         logger.error(str('[uplink] configuration error! {0}'.format(err)))
         sys.exit(1)
 
-    configuration.set_env_var('_start_date', time.strftime('%Y-%m-%d %H:%M:%S',
+    configuration.set_env_var('_internal_start_date', time.strftime('%Y-%m-%d %H:%M:%S',
-                                                           time.localtime(
+                              time.localtime(calendar.timegm(time.gmtime()))))
-                                                               calendar.timegm(time.gmtime()))))
+    configuration.set_env_var('_internal_start_timestamp', calendar.timegm(time.gmtime()))
-    configuration.set_env_var('_start_timestamp', calendar.timegm(time.gmtime()))
 
     # interval set in args is overriding configuration and default
     if args.interval:
@@ -139,7 +138,7 @@ def main():
         root_logger.setLevel(logging.DEBUG)
 
     if args.httpserver or configuration.get_httpserver():
-        configuration.set_env_var('_httpserver', True)
+        configuration.set_httpserver(True)
 
     try:
         u = Uplink(configuration.get_pid_file(), configuration)
@@ -161,7 +160,7 @@ def main():
             u.start()
     elif args.foreground:
         from threading import Thread
-        if configuration.get_env_var('_httpserver'):
+        if configuration.get_httpserver():
             from uplink.httpserver import HTTPServer
             s = HTTPServer(configuration)
             st = Thread(target=s.run_server, daemon=True)

uplink/configuration.py

@@ -37,13 +37,16 @@ class Configuration:
         # objects and readable and writable by all of them.
         self.__env = {}
         self.__httpserver = False
-        self.__httpserver_host = '0.0.0.0'
+        self.__httpserver_host = '127.0.0.1'
         self.__httpserver_port = 1042
         self.__interval = 60
         self.__log_count = 1
         self.__log_file = None
         self.__log_level = None
         self.__log_size = 0
+        self.__notification_gammu = False
+        self.__notification_gammu_configuration = None
+        self.__notification_gammu_receiver = None
         self.__pid_file = '/tmp/uplink.pid'
         self.__run_mode = 'cron'
         self.__speedtest = False
@@ -95,6 +98,23 @@ class Configuration:
         if 'log_size' in self.__configuration:
             self.__log_size = self.__configuration['log_size']
 
+        if 'notification_gammu' in self.__configuration:
+            self.__notification_gammu = self.__configuration['notification_gammu']
+
+        if 'notification_gammu_configuration' in self.__configuration:
+            self.__notification_gammu_configuration = \
+                self.__configuration['notification_gammu_configuration']
+        elif self.__notification_gammu_configuration is None and \
+                self.__configuration['notification_gammu']:
+            raise Exception('notification_gammu_configuration required!')
+
+        if 'notification_gammu_receiver' in self.__configuration:
+            self.__notification_gammu_receiver = \
+                self.__configuration['notification_gammu_receiver']
+        elif self.__notification_gammu_receiver is None and \
+                self.__configuration['notification_gammu']:
+            raise Exception('notification_gammu_receiver required!')
+
         if 'pid_file' in self.__configuration:
             self.__pid_file = self.__configuration['pid_file']
 
@@ -112,7 +132,7 @@ class Configuration:
 
         if 'uplinks' in self.__configuration:
             self.__uplinks = self.__configuration['uplinks']
-        else:
+        if self.__uplinks is None:
             raise Exception('uplinks required!')
 
     # get methods
@@ -137,6 +157,8 @@ class Configuration:
     def get_env_var(self, key):
         if key in self.__env:
             return self.__env[key]
+        else:
+            return False
 
     def get_httpserver(self):
         return self.__httpserver
@@ -162,6 +184,15 @@ class Configuration:
     def get_log_size(self):
         return self.__log_size
 
+    def get_notification_gammu(self):
+        return self.__notification_gammu
+
+    def get_notification_gammu_configuration(self):
+        return self.__notification_gammu_configuration
+
+    def get_notification_gammu_receiver(self):
+        return self.__notification_gammu_receiver
+
     def get_pid_file(self):
         return self.__pid_file
 

uplink/notification.py

@@ -18,6 +18,8 @@
 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 # OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+#import gammu
+
 from logging import getLogger
 
 logger = getLogger(__name__)
@@ -27,3 +29,15 @@ class Notification:
 
     def __init__(self, configuration):
         self.__configuration = configuration
+        #self.__state_machine = gammu.StateMachine()
+        #self.__state_machine.ReadConfig(
+        #    self.__configuration.get_notification_gammu_configuration())
+
+    def send(self, status):
+        #message = {
+        #    "Number": self.__configuration.get_notification_gammu_receiver(),
+        #    "Text": "message text",
+        #    "SMSC": {"Location": 1},
+        #}
+        #self.__state_machine.SendSMS(message)
+        logger.error(status)

uplink/uplink.py

@@ -32,7 +32,6 @@ from threading import Thread
 from uplink.daemon import Daemon
 from uplink.database import Database
 from uplink.model import Model
-from uplink.notification import Notification
 
 logger = getLogger(__name__)
 
@@ -43,60 +42,106 @@ class Uplink(Daemon):
         super().__init__(pid_file)
         self.__configuration = configuration
 
-        self.date = None
-        self.time = None
-        self.status = None
-
     def fetch_data(self, i):
         timestamp = calendar.timegm(time.gmtime())
         local_time = time.localtime(timestamp)
-        self.date = time.strftime('%Y-%m-%d', local_time)
+        date_formatted = time.strftime('%Y-%m-%d', local_time)
-        self.time = time.strftime('%H:%M:%S', local_time)
+        time_formatted = time.strftime('%H:%M:%S', local_time)
 
-        self.__configuration.set_env_var('_last_run_date', self.date + ' ' + self.time)
+        self.__configuration.set_env_var('_internal_last_run_date', date_formatted + ' ' +
-        self.__configuration.set_env_var('_last_run_timestamp', timestamp)
+                                         time_formatted)
+        self.__configuration.set_env_var('_internal_last_run_timestamp', timestamp)
 
         uplink = self.__configuration.get_uplink(i)
-        try:
-            fc = FritzStatus(address=uplink['ip'],
-                             password=uplink['password'])
-            if fc.is_connected:
-                self.status = 'UP'
-                self.__configuration.set_env_var('_last_success_' + uplink['identifier'] +
-                                                 '_date', self.date + ' ' + self.time)
-                self.__configuration.set_env_var('_last_success_' + uplink['identifier'] +
-                                                 '_timestamp', timestamp)
-            else:
-                self.status = 'DOWN'
-                self.__configuration.set_env_var('_last_fail_' + uplink['identifier'] +
-                                                 '_date', self.date + ' ' + self.time)
-                self.__configuration.set_env_var('_last_fail_' + uplink['identifier'] +
-                                                 '_timestamp', timestamp)
 
-            logger.info(str(uplink['provider'] + ' (IP: ' + fc.external_ip + ') ' +
+        if 'primary' in uplink:
-                            self.status))
+            self.__configuration.set_env_var('_uplink_' + uplink['identifier'] + '_primary',
+                                             uplink['primary'])
+
+        if self.__configuration.get_env_var('_uplink_' + uplink['identifier'] +
+                                            '_fail_count') is False:
+            self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                             '_fail_count', 0)
+
+        if self.__configuration.get_env_var('_uplink_' + uplink['identifier'] +
+                                            '_fail_overall_count') is False:
+            self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                             '_fail_overall_count', 0)
+
+        try:
+            fritz_connection = FritzStatus(address=uplink['ip'],
+                                           password=uplink['password'])
+
+            if fritz_connection.is_connected:
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_fail_count', 0)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_last_success_date', date_formatted + ' ' +
+                                                 time_formatted)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_last_success_timestamp', timestamp)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_status', 'UP')
+
+                status = 'UP'
+            else:
+                fail_count = self.__configuration.get_env_var('_uplink_' + uplink['identifier'] +
+                                                              '_fail_count')
+                fail_count += 1
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] + '_fail_count',
+                                                 fail_count)
+
+                fail_overall_count = self.__configuration.get_env_var('_uplink_' +
+                                                                      uplink['identifier'] +
+                                                                      '_fail_overall_count')
+                fail_overall_count += 1
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_fail_overall_count', fail_overall_count)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_last_fail_date', date_formatted + ' ' +
+                                                 time_formatted)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_last_fail_timestamp', timestamp)
+
+                self.__configuration.set_env_var('_uplink_' + uplink['identifier'] +
+                                                 '_status', 'DOWN')
+
+                status = 'DOWN'
+
+                if self.__configuration.get_notification_gammu():
+                    from uplink.notification import Notification
+                    notification = Notification(self.__configuration)
+                    notification.send('STATUS: ' + status)
+
+            logger.info(str(uplink['provider'] + ' (IP: ' + fritz_connection.external_ip + ') ' +
+                            status))
 
             model = Model(self.__configuration)
-            model.set_date(self.date)
+            model.set_date(date_formatted)
-            model.set_external_ip(fc.external_ip)
+            model.set_external_ip(fritz_connection.external_ip)
-            model.set_external_ipv6(fc.external_ipv6)
+            model.set_external_ipv6(fritz_connection.external_ipv6)
             model.set_internal_ip(uplink['ip'])
-            model.set_is_connected(fc.is_connected)
+            model.set_is_connected(fritz_connection.is_connected)
-            model.set_is_linked(fc.is_linked)
+            model.set_is_linked(fritz_connection.is_linked)
-            model.set_message(self.status)
+            model.set_message(status)
-            model.set_model_name(fc.modelname)
+            model.set_model_name(fritz_connection.modelname)
             model.set_provider(uplink['provider'])
             model.set_source_host(socket.gethostname())
-            model.set_str_max_bit_rate_down(fc.str_max_bit_rate[1])
+            model.set_str_max_bit_rate_down(fritz_connection.str_max_bit_rate[1])
-            model.set_str_max_bit_rate_up(fc.str_max_bit_rate[0])
+            model.set_str_max_bit_rate_up(fritz_connection.str_max_bit_rate[0])
-            model.set_str_max_linked_bit_rate_down(fc.str_max_linked_bit_rate[1])
+            model.set_str_max_linked_bit_rate_down(fritz_connection.str_max_linked_bit_rate[1])
-            model.set_str_max_linked_bit_rate_up(fc.str_max_linked_bit_rate[0])
+            model.set_str_max_linked_bit_rate_up(fritz_connection.str_max_linked_bit_rate[0])
-            model.set_str_transmission_rate_down(fc.str_transmission_rate[1])
+            model.set_str_transmission_rate_down(fritz_connection.str_transmission_rate[1])
-            model.set_str_transmission_rate_up (fc.str_transmission_rate[0])
+            model.set_str_transmission_rate_up(fritz_connection.str_transmission_rate[0])
-            model.set_system_version(fc.fc.system_version)
+            model.set_system_version(fritz_connection.fc.system_version)
-            model.set_time(self.time)
+            model.set_time(time_formatted)
             model.set_timestamp(timestamp)
-            model.set_uptime(fc.connection_uptime)
+            model.set_uptime(fritz_connection.connection_uptime)
 
             database = Database(self.__configuration)
             database.write_log_to_db(model)
@@ -106,7 +151,7 @@ class Uplink(Daemon):
             logger.error(str(message.format(err)))
 
     def run(self):
-        if self.__configuration.get_env_var('_httpserver'):
+        if self.__configuration.get_http_server():
             from uplink.httpserver import HTTPServer
             s = HTTPServer(self.__configuration)
             st = Thread(target=s.run_server, daemon=True)