db4e 0.44.2__tar.gz → 0.45.0__tar.gz

{db4e-0.44.2 → db4e-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: db4e
-Version: 0.44.2
+Version: 0.45.0
 Summary: A unified Monero XMR mining dashboard for deployment, operation and real-time analytics.
 License: GPL-3.0-or-later
 License-File: LICENSE

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DDef.py

@@ -37,7 +37,7 @@ class DDef(ConstGroup):
     DB4E_SERVICE_FILE : str = "db4e.service"
     DB4E_START_SCRIPT : str = "db4e-server"
     DB4E_UNINSTALL_SCRIPT : str = "db4e-uninstall-service.sh"
-    DB4E_VERSION : str = "0.44.2"
+    DB4E_VERSION : str = "0.45.0"
     DEPL_COLLECTION : str = "depl"
     DEV_DIR : str = "dev"
     DONATION_WALLET : str = "48aTDJfRH2JLcKW2fz4m9HJeLLVK5rMo1bKiNHFc43Ht2e2kPVh2tmk3Md7npz1WsSU7bpgtX2Xnf59RHCLUEaHfQHwao4j"

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DField.py

@@ -61,6 +61,7 @@ class DField(ConstGroup) :
     JOB : str = "job"
     JOBS : str = "jobs"
     LABEL : str = "label"
+    LABELS : str = "labels"
     LEVEL : str = "level"
     LOCAL : str = "local"
     LOCAL_TIMESTAMP : str = "local_timestamp"
@@ -128,6 +129,7 @@ class DField(ConstGroup) :
     RESET_DATA : str = "reset_data"
     RESULTS : str = "results"
     RETRY_TIMEOUT : str = "retry_timeout"
+    RIGHT : str = "right"
     RUN_BACKUP : str = "run_backup"
     RPC_BIND_PORT : str = "rpc_bind_port"
     RUNTIME_LOG : str = "runtime_log"
@@ -137,6 +139,7 @@ class DField(ConstGroup) :
     SET_PANE : str = "set_pane"
     SOCKET_FILE : str = "socket_file"
     START : str = "start"
+    START_STOP_LOG : str = "start_stop_log"
     STARTING : str = "starting"
     STATS_MOD : str = "stats_mod"
     STOP : str = "stop"

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DLabel.py

@@ -21,12 +21,13 @@ class DLabel(ConstGroup):
     API : str = "API"
     BLOCKCHAIN : str = "Blockchain"
     BLOCKCHAIN_DIR : str = "Blockchain Directory"
+    BLOCKS : str = "Blocks"
     BLOCKS_FOUND : str = "Blocks Found"
     CHAIN : str = "Chain"
     CHAIN_STATS : str = "Chain Stats"
     CONFIG : str = "Configuration"
     CONFIG_FILE : str = "Configuration File"
-    CURRENT_UPTIME : str = "Current Uptime"
+    CURRENT : str = "Current"
     DAYS : str = "Days"
     DB4E : str = "Db4E Core"
     DB4E_LONG : str = "Database 4 Everything"
@@ -111,6 +112,7 @@ class DLabel(ConstGroup):
     SHOW_TIME_STATS : str = "Show Time Stats"
     SOFTWARE_SYSTEM : str = "Software System"
     START : str = "Start"
+    START_STOP_LOG : str = "Start/Stop Log"
     STATUS : str = "Status"
     STARTUP_SCRIPT : str = "Startup Script"
     STATS_MOD : str = "API stats_mod"
@@ -118,7 +120,7 @@ class DLabel(ConstGroup):
     STOP : str = "Stop"
     STRATUM_PORT : str = "Stratum Port"
     TIMESTAMP : str = "Timestamp"
-    TOTAL_UPTIME : str = "Total Uptime"
+    TOTAL : str = "Total"
     TUI_LOG : str = "Console Log"
     TYPE : str = "Type"
     UPDATE : str = "Update"

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DMethod.py

@@ -22,6 +22,7 @@ class DMethod(ConstGroup):
     GET_DEPL : str = "get_deployment"
     GET_TUI_LOG : str = "get_tui_log"
     GET_RUNTIME_LOG : str = "get_runtime_log"
+    GET_START_STOP_LOG : str = "get_start_stop_log"
     GET_UPTIME : str = "get_uptime"
     HASHRATES : str = "hashrates"
     INITIAL_SETUP : str = "initial_setup"
@@ -33,5 +34,6 @@ class DMethod(ConstGroup):
     SET_DONATIONS : str = "set_donations"
     SET_PANE : str = DField.SET_PANE
     SET_PRIMARY : str = "set_primary"
+    SHARES_FOUND : str = "shares_found"
     UPDATE_DEPLOYMENT : str = "update_deployment"
     RUNTIME : str = "runtime"

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DPane.py

@@ -27,10 +27,11 @@ class DPane(ConstGroup):
     P2POOL_ANALYTICS: str  = "P2PoolAnalyticsPane"
     P2POOL_HASHRATES: str  = "P2PoolHashratesPane"
     P2POOL_REMOTE: str  = "P2PoolRemotePane"
+    P2POOL_SHARES_FOUND: str  = "P2PoolSharesFoundPane"
     RESULTS: str  = "ResultsPane"
     RUNTIME_LOG: str  = "RuntimeLogPane"
     TUI_LOG: str  = "TuiLogPane"
-    UPTIME: str  = "UptimePane"
+    START_STOP_LOG: str  = "StartStopLogPane"
     WELCOME: str  = "WelcomePane"
     XMRIG: str  = "XMRigPane"
     XMRIG_HASHRATES: str  = "XMRigHashratesPane"

{db4e-0.44.2 → db4e-0.45.0}/db4e/Constants/DSelect.py

@@ -11,13 +11,21 @@ db4e/Constants/DSelect.py
 from db4e.Constants.DLabel import DLabel
 
 
-WEEKS_1 = 7 * 24
-WEEKS_2 = 14 * 24
-MONTHS_1 = 30 * 24
-MONTHS_3 = 30 * 24 * 3
-MONTHS_6 = 30 * 24 * 6
+WEEKS_1 = 7
+WEEKS_2 = 14
+MONTHS_1 = 30
+MONTHS_3 = 30 * 3
+MONTHS_6 = 30 * 6
 
 class DSelect:
+    HOURS_SELECT_LIST = [
+        (DLabel.WEEK_1, WEEKS_1 * 24),
+        (DLabel.WEEKS_2, WEEKS_2 * 24),
+        (DLabel.MONTH_1, MONTHS_1 * 24),
+        (DLabel.MONTHS_3, MONTHS_3 * 24),
+        (DLabel.MONTHS_6, MONTHS_6 * 24),
+        (DLabel.ALL_TIME, -1)    
+    ]
     SELECT_LIST = [
         (DLabel.WEEK_1, WEEKS_1),
         (DLabel.WEEKS_2, WEEKS_2),

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/DeplMgr.py

@@ -494,7 +494,7 @@ class DeplMgr:
         
         elif aDir == DDir.LOGROTATE:
             vendor_dir = self.get_dir(DDir.VENDOR)
-            return os.path.abspath(os.path.join(vendor_dir, DElem.DB4E, DDir.LOGROTATE))
+            return os.path.abspath(os.path.join(vendor_dir, DDir.LOGROTATE))
 
         elif aDir == DElem.MONEROD:
             return DElem.MONEROD + '-' + Default.MONEROD_VERSION

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/InstallMgr.py

@@ -380,7 +380,7 @@ class InstallMgr(Container):
         logrotate_tmpl = self.depl_mgr.get_logrotate_template(DElem.DB4E)
         vendor_dir = db4e.vendor_dir()
         fq_config = os.path.join(
-            vendor_dir, DElem.DB4E, DDef.LOG_ROTATE, DElem.DB4E + DDef.CONF_SUFFIX)
+            vendor_dir, DDef.LOG_ROTATE, DElem.DB4E + DDef.CONF_SUFFIX)
         
         # Populate the config template
         placeholders = {

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/MessageRouter.py

@@ -36,6 +36,8 @@ class MessageRouter:
 
     def load_routes(self):
         # Db4e core
+        self.register(DModule.OPS_MGR, DMethod.GET_RUNTIME_LOG, DElem.DB4E,
+                      self.ops_mgr.get_runtime_log, DPane.RUNTIME_LOG)
         self.register(DModule.INSTALL_MGR, DMethod.INITIAL_SETUP_PROCEED, DElem.DB4E,
                       self.install_mgr.initial_setup_proceed, DPane.INITIAL_SETUP)
         self.register(DModule.INSTALL_MGR, DMethod.INITIAL_SETUP, DElem.DB4E,
@@ -44,67 +46,67 @@ class MessageRouter:
                       self.ops_mgr.get_deployment, DPane.DB4E)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.DB4E,
                       self.depl_client.update_deployment, DPane.WELCOME)
-        self.register(DModule.OPS_MGR, DMethod.GET_UPTIME, DElem.DB4E,
-                      self.ops_mgr.get_uptime, DPane.UPTIME)
 
         # MoneroD - local
-        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.MONEROD,
-                      self.ops_mgr.get_new, DPane.MONEROD)
         self.register(DModule.OPS_MGR, DMethod.ADD_DEPLOYMENT, DElem.MONEROD,
                       self.ops_mgr.add_deployment, DPane.WELCOME)
-        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.MONEROD,
-                      self.ops_mgr.get_deployment, DPane.MONEROD)
+        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.MONEROD,
+                      self.depl_client.delete_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DISABLE_DEPLOYMENT, DElem.MONEROD,
                       self.depl_client.disable_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.ENABLE_DEPLOYMENT, DElem.MONEROD,
                       self.depl_client.enable_deployment, DPane.WELCOME)
+        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.MONEROD,
+                      self.ops_mgr.get_deployment, DPane.MONEROD)
+        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.MONEROD,
+                      self.ops_mgr.get_new, DPane.MONEROD)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.MONEROD,
                       self.depl_client.update_deployment, DPane.WELCOME)
-        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.MONEROD,
-                      self.depl_client.delete_deployment, DPane.WELCOME)
 
         # MoneroD - remote
-        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.MONEROD_REMOTE,
-                      self.ops_mgr.get_new, DPane.MONEROD_REMOTE)
         self.register(DModule.OPS_MGR, DMethod.ADD_DEPLOYMENT, DElem.MONEROD_REMOTE,
                       self.ops_mgr.add_deployment, DPane.WELCOME)
         self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.MONEROD_REMOTE,
                       self.ops_mgr.get_deployment, DPane.MONEROD_REMOTE)
-        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.MONEROD_REMOTE,
-                      self.depl_client.update_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.MONEROD_REMOTE,
                       self.depl_client.delete_deployment, DPane.WELCOME)
+        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.MONEROD_REMOTE,
+                      self.ops_mgr.get_new, DPane.MONEROD_REMOTE)
+        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.MONEROD_REMOTE,
+                      self.depl_client.update_deployment, DPane.WELCOME)
         
 
         # P2Pool - Local
-        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.P2POOL,
-                      self.ops_mgr.get_new, DPane.P2POOL)
         self.register(DModule.OPS_MGR, DMethod.ADD_DEPLOYMENT, DElem.P2POOL,
                       self.ops_mgr.add_deployment, DPane.WELCOME)
-        self.register(DModule.OPS_MGR, DMethod.HASHRATES, DElem.P2POOL,
-                      self.ops_mgr.hashrates, DPane.P2POOL_HASHRATES)
-        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.P2POOL,
-                      self.ops_mgr.get_deployment, DPane.P2POOL)
+        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.P2POOL,
+                      self.depl_client.delete_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DISABLE_DEPLOYMENT, DElem.P2POOL,
                       self.depl_client.disable_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.ENABLE_DEPLOYMENT, DElem.P2POOL,
                       self.depl_client.enable_deployment, DPane.WELCOME)
+        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.P2POOL,
+                      self.ops_mgr.get_deployment, DPane.P2POOL)
+        self.register(DModule.OPS_MGR, DMethod.HASHRATES, DElem.P2POOL,
+                      self.ops_mgr.hashrates, DPane.P2POOL_HASHRATES)
+        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.P2POOL,
+                      self.ops_mgr.get_new, DPane.P2POOL)
+        self.register(DModule.OPS_MGR, DMethod.SHARES_FOUND, DElem.P2POOL,
+                      self.ops_mgr.shares_found, DPane.P2POOL_SHARES_FOUND)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.P2POOL,
                       self.depl_client.update_deployment, DPane.WELCOME)
-        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.P2POOL,
-                      self.depl_client.delete_deployment, DPane.WELCOME)
 
         # P2Pool - Remote
-        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.P2POOL_REMOTE,
-                      self.ops_mgr.get_new, DPane.P2POOL_REMOTE)
         self.register(DModule.OPS_MGR, DMethod.ADD_DEPLOYMENT, DElem.P2POOL_REMOTE,
                       self.ops_mgr.add_deployment, DPane.WELCOME)
+        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.P2POOL_REMOTE,
+                      self.depl_client.delete_deployment, DPane.WELCOME)
         self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.P2POOL_REMOTE,
                       self.ops_mgr.get_deployment, DPane.P2POOL_REMOTE)
+        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.P2POOL_REMOTE,
+                      self.ops_mgr.get_new, DPane.P2POOL_REMOTE)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.P2POOL_REMOTE,
                       self.depl_client.update_deployment, DPane.WELCOME)
-        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.P2POOL_REMOTE,
-                      self.depl_client.delete_deployment, DPane.WELCOME)
 
         # P2Pool - Internal
         self.register(DModule.OPS_MGR, DMethod.BLOCKS_FOUND, DElem.INT_P2POOL,
@@ -115,22 +117,22 @@ class MessageRouter:
                       self.ops_mgr.hashrates, DPane.CHAIN_HASHRATES)
 
         # XMRig
-        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.XMRIG,
-                      self.ops_mgr.get_new, DPane.XMRIG)
         self.register(DModule.OPS_MGR, DMethod.ADD_DEPLOYMENT, DElem.XMRIG,
                       self.ops_mgr.add_deployment, DPane.WELCOME)
-        self.register(DModule.OPS_MGR, DMethod.HASHRATES, DElem.XMRIG,
-                      self.ops_mgr.hashrates, DPane.XMRIG_HASHRATES)
-        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.XMRIG,
-                      self.ops_mgr.get_deployment, DPane.XMRIG)
+        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.XMRIG,
+                      self.depl_client.delete_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DISABLE_DEPLOYMENT, DElem.XMRIG,
                       self.depl_client.disable_deployment, DPane.WELCOME)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.ENABLE_DEPLOYMENT, DElem.XMRIG,
                       self.depl_client.enable_deployment, DPane.WELCOME)
+        self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.XMRIG,
+                      self.ops_mgr.get_deployment, DPane.XMRIG)
+        self.register(DModule.OPS_MGR, DMethod.GET_NEW, DElem.XMRIG,
+                      self.ops_mgr.get_new, DPane.XMRIG)
+        self.register(DModule.OPS_MGR, DMethod.HASHRATES, DElem.XMRIG,
+                      self.ops_mgr.hashrates, DPane.XMRIG_HASHRATES)
         self.register(DModule.DEPLOYMENT_CLIENT, DMethod.UPDATE_DEPLOYMENT, DElem.XMRIG,
                       self.depl_client.update_deployment, DPane.WELCOME)
-        self.register(DModule.DEPLOYMENT_CLIENT, DMethod.DELETE_DEPLOYMENT, DElem.XMRIG,
-                      self.depl_client.delete_deployment, DPane.WELCOME)
 
         # XMRig Remote
         self.register(DModule.OPS_MGR, DMethod.GET_DEPL, DElem.XMRIG_REMOTE,
@@ -150,9 +152,9 @@ class MessageRouter:
         self.register(DModule.OPS_MGR, DMethod.GET_TUI_LOG, DField.TUI_LOG,
                       self.ops_mgr.get_tui_log, DPane.TUI_LOG)
 
-        # Runtime Log
-        self.register(DModule.OPS_MGR, DMethod.GET_RUNTIME_LOG, DField.RUNTIME_LOG,
-                      self.ops_mgr.get_runtime_log, DPane.RUNTIME_LOG)
+        # Start/Stop Log
+        self.register(DModule.OPS_MGR, DMethod.GET_START_STOP_LOG, DField.START_STOP_LOG,
+                      self.ops_mgr.get_start_stop_log, DPane.START_STOP_LOG)
 
         # Donations
         self.register(DModule.OPS_MGR, DMethod.SET_DONATIONS, DField.DONATIONS,

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/MiningDb.py

@@ -347,9 +347,10 @@ class MiningDb():
 
 
     def get_block_found_events(self, instance):
+        print(f"MiningDb:get_block_found_events(): {instance}")
         return self.db.find_many(
             self.mining_col, 
-            { DMongo.DOC_TYPE: DMining.BLOCK_FOUND_EVENT, DMongo.INSTANCE: instance },
+            { DMongo.DOC_TYPE: DMining.BLOCK_FOUND_EVENT, DMongo.POOL: instance },
             { DMongo.TIMESTAMP: 1 })
 
 
@@ -397,6 +398,13 @@ class MiningDb():
             { DMongo.TIMESTAMP: 1 })
 
 
+    def get_share_found_events(self, pool):
+        return self.db.find_many(
+            self.mining_col, 
+            { DMongo.DOC_TYPE: DMining.SHARE_FOUND_EVENT, DMongo.POOL: pool },
+            { DMongo.TIMESTAMP: 1 })
+
+
     def get_xmrigs_remote(self):
         recs = self.db.find_many(self.mining_col, {
             DMongo.DOC_TYPE: DMining.RT_MINER_HASHRATE})

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/MiningETL.py

@@ -29,45 +29,7 @@ class MiningETL:
 
     def get_block_found_events(self, instance):
         recs = self.mining_db.get_block_found_events(instance)
-        if not recs:
-            return {DField.DAYS: [], DField.VALUES: []}
-
-        results = {}
-
-        cur_day = recs[0][DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
-
-        for rec in recs:
-            rec_day = rec[DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
-
-            # Fill in all missing days with 0
-            while cur_day < rec_day:
-                if cur_day not in results:
-                    results[cur_day] = 0
-                cur_day += timedelta(days=1)
-
-            # Count the block for this day
-            results[rec_day] = results.get(rec_day, 0) + 1
-            cur_day = rec_day
-
-        # Convert dict → lists (sorted by day)
-        times = [day.strftime("%Y-%m-%d %H:%M") for day in sorted(results.keys())]
-        values = [results[day] for day in sorted(results.keys())]
-
-        # Replace datetime days with integers for plotting
-        new_times = range(- len(times), 0, 1)
-
-        new_values = []
-        for value in values:
-            new_values.append(float(value))
-
-        first_day = - len(new_times)
-        new_days = list(range(first_day, 0, 1))
-
-        print(f"days: {new_days}\n{new_values}")
-        return {
-            DField.DAYS: new_days,
-            DField.VALUES: new_values,
-        }
+        return self.get_found_events(recs)
 
     
     def get_chain_hashrate(self, instance):
@@ -125,6 +87,48 @@ class MiningETL:
         return self.get_hashrates(recs)
 
 
+    def get_found_events(self, recs):
+        if not recs:
+            return {DField.DAYS: [], DField.VALUES: []}
+
+        results = {}
+
+        cur_day = recs[0][DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
+
+        for rec in recs:
+            rec_day = rec[DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
+
+            # Fill in all missing days with 0
+            while cur_day < rec_day:
+                if cur_day not in results:
+                    results[cur_day] = 0
+                cur_day += timedelta(days=1)
+
+            # Count the block for this day
+            results[rec_day] = results.get(rec_day, 0) + 1
+            cur_day = rec_day
+
+        # Convert dict → lists (sorted by day)
+        times = [day.strftime("%Y-%m-%d %H:%M") for day in sorted(results.keys())]
+        values = [results[day] for day in sorted(results.keys())]
+
+        # Replace datetime days with integers for plotting
+        new_times = range(- len(times), 0, 1)
+
+        new_values = []
+        for value in values:
+            new_values.append(float(value))
+
+        first_day = - len(new_times)
+        new_days = list(range(first_day, 0, 1))
+
+        print(f"days: {new_days}\n{new_values}")
+        return {
+            DField.DAYS: new_days,
+            DField.VALUES: new_values,
+        }
+
+
     def get_hashrates(self, recs):
         if not recs:
             return {DField.VALUES: [], DField.DAYS: [], DField.UNITS: ""}
@@ -190,4 +194,56 @@ class MiningETL:
         if rec:
             return rec[DMongo.TIMESTAMP]
         return None
-    
+
+
+    def get_share_found_events(self, pool):
+        recs = self.mining_db.get_share_found_events(pool)
+        return self.get_found_events(recs)
+
+
+    def get_share_found_events_stacked(self, pool):
+        recs = self.mining_db.get_share_found_events(pool)
+        if not recs:
+            return {DField.DAYS: [], DField.VALUES: [], DField.MINERS: []}
+
+
+        results = {}
+        miner_set = set()
+
+        cur_day = recs[0][DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
+
+        for rec in recs:
+            rec_day = rec[DMongo.TIMESTAMP].replace(hour=0, minute=0, second=0, microsecond=0)
+
+            # Fill in all missing days with 0
+            while cur_day < rec_day:
+                results.setdefault(cur_day, {})
+                cur_day += timedelta(days=1)
+
+            # Get the miner name
+            miner = rec[DMining.MINER]
+            miner_set.add(miner)
+
+            # Count the share found for this day
+            results.setdefault(rec_day, {})
+            results[rec_day][miner] = results[rec_day].get(miner, 0) + 1
+
+            cur_day = rec_day
+
+        miners = sorted(miner_set)
+        miner_lists = {miner: [] for miner in miners}
+
+
+        for day in results:
+            for miner in miners:
+                miner_lists[miner].append(results[day].get(miner, 0))
+
+        new_days = range(- len(results), 0, 1)
+
+        final_results = {
+            DField.DAYS: list(new_days),
+            DField.VALUES: list(miner_lists.values()),
+            DField.MINERS: list(miner_set)
+        }
+        print(final_results)
+        return final_results

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/OpsMgr.py

@@ -61,33 +61,14 @@ class OpsMgr:
     def blocks_found(self, form_data: dict):
         elem = form_data[DField.ELEMENT]
         if type(elem == InternalP2Pool):
-            elem.blocks_found(self.mining_etl.get_block_found_events(instance=elem.instance()))
+            #elem.blocks_found(self.mining_etl.get_block_found_events(instance=elem.instance()))
+            res = self.mining_etl.get_block_found_events(instance=elem.instance())
+            elem.blocks_found(res)
+            print(f"OpsMgr:blocks_found() {res}")
+
         return elem
     
 
-    def hashrates(self, form_data: dict):
-        elem = form_data[DField.ELEMENT]
-
-        if type(elem) == P2Pool:
-            elem.hashrate(self.mining_etl.get_pool_hashrate(instance=elem.instance()))
-            elem.hashrates(self.mining_etl.get_pool_hashrates(instance=elem.instance()))
-
-        if type(elem) == InternalP2Pool:
-            elem.hashrate(self.mining_etl.get_chain_hashrate(instance=elem.instance()))
-            elem.hashrates(self.mining_etl.get_chain_hashrates(instance=elem.instance()))
-
-        elif type(elem) == XMRig:
-            elem.hashrates(self.mining_etl.get_miner_hashrates(elem.instance()))
-            elem.hashrate(self.mining_etl.get_miner_hashrate(elem.instance()))
-            elem.uptime(self.mining_etl.get_miner_uptime(elem.instance()))
-
-        elif type(elem) == XMRigRemote:
-            print(self.mining_etl.get_miner_hashrates(elem.instance()))
-            elem.hashrates(self.mining_etl.get_miner_hashrates(elem.instance()))
-
-        return elem
- 
-   
     def get_deployment(self, elem_type, instance=None):
         if type(elem_type) == dict:
             instance = elem_type[DField.INSTANCE]
@@ -144,7 +125,7 @@ class OpsMgr:
         return self.mining_etl.get_remote_xmrig_timestamp(xmrig.instance())
 
 
-    def get_uptime(self, form_data: dict):
+    def get_runtime_log(self, form_data: dict):
         return self.ops_etl.get_ops_summary()
 
 
@@ -157,10 +138,33 @@ class OpsMgr:
         return self.depl_client.job_queue.get_jobs()
     
 
-    def get_runtime_log(self, event_list: list):
+    def get_start_stop_log(self, event_list: list):
         return self.ops_db.get_ops_events()
     
 
+    def hashrates(self, form_data: dict):
+        elem = form_data[DField.ELEMENT]
+
+        if type(elem) == P2Pool:
+            elem.hashrate(self.mining_etl.get_pool_hashrate(instance=elem.instance()))
+            elem.hashrates(self.mining_etl.get_pool_hashrates(instance=elem.instance()))
+
+        if type(elem) == InternalP2Pool:
+            elem.hashrate(self.mining_etl.get_chain_hashrate(instance=elem.instance()))
+            elem.hashrates(self.mining_etl.get_chain_hashrates(instance=elem.instance()))
+
+        elif type(elem) == XMRig:
+            elem.hashrates(self.mining_etl.get_miner_hashrates(elem.instance()))
+            elem.hashrate(self.mining_etl.get_miner_hashrate(elem.instance()))
+            elem.uptime(self.mining_etl.get_miner_uptime(elem.instance()))
+
+        elif type(elem) == XMRigRemote:
+            print(self.mining_etl.get_miner_hashrates(elem.instance()))
+            elem.hashrates(self.mining_etl.get_miner_hashrates(elem.instance()))
+
+        return elem
+ 
+   
     def log_viewer(self, form_data: dict):
         elem_type = form_data[DField.ELEMENT_TYPE]
         instance = form_data[DField.INSTANCE]
@@ -173,6 +177,12 @@ class OpsMgr:
         return plot_metadata
 
 
+    def shares_found(self, form_data: dict):
+        p2pool = form_data[DField.ELEMENT]
+        p2pool.shares_found(self.mining_etl.get_share_found_events(pool=p2pool.instance()))
+        return p2pool
+
+            
     def set_donations(self, form_data: dict):
         return DPane.DONATIONS
 

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/P2Pool.py

@@ -138,8 +138,8 @@ class P2Pool(SoftwareSystem):
     def gen_logrotate_config(self, tmpl_file: str, vendor_dir: str, db4e_group:str):
         # Logrotate configuration file
         fq_config = os.path.join(
-            vendor_dir, DElem.DB4E, DDef.LOG_ROTATE, DElem.P2POOL + "-" + \
-                self.instance() + DDef.CONF_SUFFIX)
+            vendor_dir, DDef.LOG_ROTATE, DElem.P2POOL + "-" + self.instance() + \
+                DDef.CONF_SUFFIX)
         
         # Populate the config template
         placeholders = {

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/PaneCatalogue.py

@@ -22,10 +22,11 @@ from db4e.Panes.P2PoolPane import P2PoolPane
 from db4e.Panes.P2PoolHashratesPane import P2PoolHashratesPane
 from db4e.Panes.ChainPane import ChainPane
 from db4e.Panes.P2PoolRemotePane import P2PoolRemotePane
+from db4e.Panes.P2PoolSharesFoundPane import P2PoolSharesFoundPane
 from db4e.Panes.ResultsPane import ResultsPane
-from db4e.Panes.RuntimeLogPane import RuntimeLogPane
+from db4e.Panes.StartStopLogPane import StartStopLogPane
 from db4e.Panes.TUILogPane import TUILogPane
-from db4e.Panes.UptimePane import UptimePane
+from db4e.Panes.RuntimePane import RuntimePane
 from db4e.Panes.WelcomePane import WelcomePane
 from db4e.Panes.XMRigHashratesPane import XMRigHashratesPane
 from db4e.Panes.XMRigPane import XMRigPane
@@ -49,10 +50,11 @@ REGISTRY = {
     DPane.P2POOL: (P2PoolPane, DLabel.P2POOL, DLabel.NEW),
     DPane.P2POOL_HASHRATES: (P2PoolHashratesPane, DLabel.P2POOL, DLabel.HASHRATES),
     DPane.P2POOL_REMOTE: (P2PoolRemotePane, DLabel.P2POOL_REMOTE, DLabel.CONFIG),
+    DPane.P2POOL_SHARES_FOUND: (P2PoolSharesFoundPane, DLabel.P2POOL, DLabel.SHARES_FOUND),
     DPane.RESULTS: (ResultsPane, DLabel.DB4E_LONG, DLabel.RESULTS),
-    DPane.RUNTIME_LOG: (RuntimeLogPane, DLabel.LOG, DLabel.RUNTIME_LOG),
+    DPane.START_STOP_LOG: (StartStopLogPane, DLabel.LOG, DLabel.START_STOP_LOG),
     DPane.TUI_LOG: (TUILogPane, DLabel.LOG, DLabel.TUI_LOG),
-    DPane.UPTIME: (UptimePane, DLabel.DB4E_LONG, DLabel.RUNTIME),
+    DPane.RUNTIME_LOG: (RuntimePane, DLabel.DB4E_LONG, DLabel.RUNTIME_LOG),
     DPane.WELCOME: (WelcomePane, DLabel.DB4E_LONG, DLabel.WELCOME),
     DPane.XMRIG: (XMRigPane, DLabel.XMRIG, DLabel.NEW),
     DPane.XMRIG_HASHRATES: (XMRigHashratesPane, DLabel.XMRIG, DLabel.HASHRATES),

{db4e-0.44.2 → db4e-0.45.0}/db4e/Modules/XMRig.py

@@ -111,8 +111,8 @@ class XMRig(SoftwareSystem):
     def gen_logrotate_config(self, tmpl_file: str, vendor_dir: str, db4e_group:str):
         # Logrotate configuration file
         fq_config = os.path.join(
-            vendor_dir, DElem.DB4E, DDef.LOG_ROTATE, DElem.XMRIG + "-" + \
-                self.instance() + DDef.CONF_SUFFIX)
+            vendor_dir, DDef.LOG_ROTATE, DElem.XMRIG + "-" + self.instance() + \
+                DDef.CONF_SUFFIX)
         
         # Populate the config template placeholders
         placeholders = {

{db4e-0.44.2 → db4e-0.45.0}/db4e/Panes/ChainBlocksFoundPane.py

@@ -53,7 +53,6 @@ class ChainBlocksFoundPane(Container):
                 classes=DForm.PANE_BOX)
 
     def on_mount(self) -> None:
-        print(f"ChainBlocksFoundPane:on_mount()")
         plt = self.query_one(PlotextPlot).plt
         plt.bar(self.days, self.blocks_found, color="blue")
         plt.title("Blocks Found")

{db4e-0.44.2 → db4e-0.45.0}/db4e/Panes/Db4EPane.py

@@ -84,7 +84,7 @@ class Db4EPane(Container):
 
                 Horizontal(
                     Button(label=DLabel.UPDATE, id=DButton.UPDATE),
-                    Button(label=DLabel.UPTIME, id=DButton.UPTIME),
+                    Button(label=DLabel.RUNTIME, id=DButton.RUNTIME),
                     classes=DForm.BUTTON_ROW
                 ),
             classes=DForm.PANE_BOX))
@@ -133,10 +133,10 @@ class Db4EPane(Container):
                 DField.ELEMENT: self.db4e,
             }
 
-        elif button_id == DButton.UPTIME:
+        elif button_id == DButton.RUNTIME:
             form_data = {
                 DField.TO_MODULE: DModule.OPS_MGR,
-                DField.TO_METHOD: DMethod.GET_UPTIME,
+                DField.TO_METHOD: DMethod.GET_RUNTIME_LOG,
                 DField.ELEMENT_TYPE: DElem.DB4E,
                 DField.ELEMENT: self.db4e,
             }