Rework feature activations alerting integration

zathras-crypto · zathras-crypto · commit 38a85e654111 · 2015-10-08T20:42:32.000+11:00
* Activations are no longer considered alerts (but an alert is still triggered if the client does not support the feature)
* Completed activations are now tracked as well as pending activations
* Details on pending and completed activations available via omni_getactivations call
* Stale pending activations are removed if an activation is re-issued
diff --git a/src/omnicore/notifications.cpp b/src/omnicore/notifications.cpp
@@ -144,33 +144,11 @@ bool CheckExpiredAlerts(unsigned int curBlock, uint64_t curTime)
     for (std::vector<AlertData>::iterator it = currentOmniAlerts.begin(); it != currentOmniAlerts.end(); ) {
         AlertData alert = *it;
         switch (alert.alert_type) {
-            case ALERT_FEATURE_UNSUPPORTED:
-                if (curBlock >= alert.alert_expiry) {
-                    std::string msgText = strprintf("Shutting down due to alert: %s", alert.alert_message);
-                    PrintToLog(msgText);
-                    PrintToConsole(msgText);
-                    if (!GetBoolArg("-overrideforcedshutdown", false)) {
-                        AbortNode(msgText, msgText);
-                    }
-                    it = currentOmniAlerts.erase(it);
-                } else {
-                    it++;
-                }
-            break;
             case ALERT_BLOCK_EXPIRY:
                 if (curBlock >= alert.alert_expiry) {
                     PrintToLog("Expiring alert (from %s: type:%d expiry:%d message:%s)\n", alert.alert_sender,
                         alert.alert_type, alert.alert_expiry, alert.alert_message);
                     it = currentOmniAlerts.erase(it);
-
-                    // if expiring a feature activation because it's gone live, add another notification
-                    // to say we're now live and expire it in 1024 blocks.
-                    size_t replacePosition = alert.alert_message.find("') will go live at block ");
-                    if (replacePosition != std::string::npos) {
-                        std::string newAlertMessage = alert.alert_message.substr(0, replacePosition) + "') is now live.";
-                        AddAlert("omnicore", 1, alert.alert_expiry + 1024, newAlertMessage);
-                    }
-
                     uiInterface.OmniStateChanged();
                 } else {
                     it++;
diff --git a/src/omnicore/omnicore.cpp b/src/omnicore/omnicore.cpp
@@ -2678,7 +2678,7 @@ int mastercore_init()
     }
 
     // load feature activation messages from txlistdb and process them accordingly
-    p_txlistdb->LoadActivations();
+    p_txlistdb->LoadActivations(nWaterlineBlock);
 
     // load all alerts from levelDB (and immediately expire old ones)
     p_txlistdb->LoadAlerts(nWaterlineBlock);
@@ -2888,7 +2888,7 @@ int mastercore::ClassAgnosticWalletTXBuilder(const std::string& senderAddress, c
 #endif
 }
 
-void CMPTxList::LoadActivations()
+void CMPTxList::LoadActivations(int blockHeight)
 {
     if (!pdb) return;
 
@@ -2945,6 +2945,7 @@ void CMPTxList::LoadActivations()
         }
     }
     delete it;
+    CheckLiveActivations(blockHeight);
 }
 
 void CMPTxList::LoadAlerts(int blockHeight)
@@ -4066,6 +4067,9 @@ int mastercore_handler_block_begin(int nBlockPrev, CBlockIndex const * pBlockInd
         }
     }
 
+    // handle any features that go live with this block
+    CheckLiveActivations(pBlockIndex->nHeight);
+
     eraseExpiredCrowdsale(pBlockIndex);
 
     return 0;
diff --git a/src/omnicore/omnicore.h b/src/omnicore/omnicore.h
@@ -245,7 +245,7 @@ class CMPTxList : public CDBBase
     bool getTX(const uint256 &txid, string &value);
 
     void LoadAlerts(int blockHeight);
-    void LoadActivations();
+    void LoadActivations(int blockHeight);
 
     void printStats();
     void printAll();
diff --git a/src/omnicore/rpc.cpp b/src/omnicore/rpc.cpp
@@ -1487,13 +1487,77 @@ Value omni_getinfo(const Array& params, bool fHelp)
         alertResponse.push_back(Pair("alerttype", alertTypeStr));
         alertResponse.push_back(Pair("alertexpiry", FormatIndivisibleMP(alert.alert_expiry)));
         alertResponse.push_back(Pair("alertmessage", alert.alert_message));
-    alerts.push_back(alertResponse);
+        alerts.push_back(alertResponse);
     }
     infoResponse.push_back(Pair("alerts", alerts));
 
     return infoResponse;
 }
 
+Value omni_getactivations(const Array& params, bool fHelp)
+{
+    if (fHelp || params.size() != 0)
+        throw runtime_error(
+            "omni_getactivations\n"
+            "Returns pending and completed feature activations.\n"
+            "\nResult:\n"
+            "{\n"
+            "  \"pendingactivations\": [                 (array of JSON objects) a list of pending feature activations\n"
+            "    {\n"
+            "      \"featureid\" : n                     (number) the id of the feature\n"
+            "      \"featurename\" : \"xxxxxxxx\"        (string) the name of the feature\n"
+            "      \"activationblock\" : n               (number) the block the feature will be activated\n"
+            "      \"minimumversion\" : n                (number) the minimum client version needed to support this feature\n"
+            "    },\n"
+            "    ...\n"
+            "  ]\n"
+            "  \"completedactivations\": [               (array of JSON objects) a list of completed feature activations\n"
+            "    {\n"
+            "      \"featureid\" : n                     (number) the id of the feature\n"
+            "      \"featurename\" : \"xxxxxxxx\"        (string) the name of the feature\n"
+            "      \"activationblock\" : n               (number) the block the feature will be activated\n"
+            "      \"minimumversion\" : n                (number) the minimum client version needed to support this feature\n"
+            "    },\n"
+            "    ...\n"
+            "  ]\n"
+            "}\n"
+            "\nExamples:\n"
+            + HelpExampleCli("omni_getactivations", "")
+            + HelpExampleRpc("omni_getactivations", "")
+        );
+
+    Object response;
+
+    Array arrayPendingActivations;
+    std::vector<FeatureActivation> PendingActivations = GetPendingActivations();
+    for (std::vector<FeatureActivation>::iterator it = PendingActivations.begin(); it != PendingActivations.end(); ++it) {
+        Object actObj;
+        FeatureActivation pendingAct = *it;
+        actObj.push_back(Pair("featureid", pendingAct.featureId));
+        actObj.push_back(Pair("featurename", pendingAct.featureName));
+        actObj.push_back(Pair("activationblock", FormatIndivisibleMP(pendingAct.activationBlock)));
+        actObj.push_back(Pair("minimumversion", (uint64_t)pendingAct.minClientVersion));
+        arrayPendingActivations.push_back(actObj);
+    }
+
+    Array arrayCompletedActivations;
+    std::vector<FeatureActivation> CompletedActivations = GetCompletedActivations();
+    for (std::vector<FeatureActivation>::iterator it = CompletedActivations.begin(); it != CompletedActivations.end(); ++it) {
+        Object actObj;
+        FeatureActivation completedAct = *it;
+        actObj.push_back(Pair("featureid", completedAct.featureId));
+        actObj.push_back(Pair("featurename", completedAct.featureName));
+        actObj.push_back(Pair("activationblock", FormatIndivisibleMP(completedAct.activationBlock)));
+        actObj.push_back(Pair("minimumversion", (uint64_t)completedAct.minClientVersion));
+        arrayCompletedActivations.push_back(actObj);
+    }
+
+    response.push_back(Pair("pendingactivations", arrayPendingActivations));
+    response.push_back(Pair("completedactivations", arrayCompletedActivations));
+
+    return response;
+}
+
 Value omni_getsto(const Array& params, bool fHelp)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
diff --git a/src/omnicore/rules.cpp b/src/omnicore/rules.cpp
@@ -12,9 +12,12 @@
 #include "omnicore/utilsbitcoin.h"
 #include "omnicore/version.h"
 
+#include "alert.h"
 #include "chainparams.h"
+#include "main.h"
 #include "script/standard.h"
 #include "uint256.h"
+#include "ui_interface.h"
 
 #include <openssl/sha.h>
 
@@ -28,7 +31,12 @@ namespace mastercore
 /**
  * Pending activations
  */
-std::vector<PendingActivation> PendingActivations;
+std::vector<FeatureActivation> PendingActivations;
+
+/**
+ * Completed activations
+ */
+std::vector<FeatureActivation> CompletedActivations;
 
 /**
  * Returns a mapping of transaction types, and the blocks at which they are enabled.
@@ -318,18 +326,90 @@ bool IsAllowedOutputType(int whichType, int nBlock)
 }
 
 /**
- * Adds a pending activation to the PendingActivations vector.
+ * Adds a feature activation to the PendingActivations vector.
  *
  */
 void AddPendingActivation(uint16_t featureId, int activationBlock, uint32_t minClientVersion, const std::string& featureName)
 {
-    PendingActivation pa;
-    pa.featureId = featureId;
-    pa.activationBlock = activationBlock;
-    pa.minClientVersion = minClientVersion;
-    pa.featureName = featureName;
+    FeatureActivation featureActivation;
 
-    PendingActivations.push_back(pa);
+    featureActivation.featureId = featureId;
+    featureActivation.featureName = featureName;
+    featureActivation.activationBlock = activationBlock;
+    featureActivation.minClientVersion = minClientVersion;
+
+    PendingActivations.push_back(featureActivation);
+}
+
+/**
+ * Deletes a pending activation from the PendingActivations vector.  Deletion is not supported on the CompletedActivations vector.
+ *
+ */
+void DeletePendingActivation(uint16_t featureId)
+{
+   for (std::vector<FeatureActivation>::iterator it = PendingActivations.begin(); it != PendingActivations.end(); ) {
+       if ((*it).featureId == featureId) {
+           it = PendingActivations.erase(it);
+       } else {
+           it++;
+       }
+   }
+}
+
+/**
+ * Checks if any activations went live in the block
+ *
+ */
+void CheckLiveActivations(int blockHeight)
+{
+    std::vector<FeatureActivation> PendingActivations = GetPendingActivations();
+    for (std::vector<FeatureActivation>::iterator it = PendingActivations.begin(); it != PendingActivations.end(); ++it) {
+       if ((*it).activationBlock > blockHeight) continue;
+       FeatureActivation LiveActivation = *it;
+       if (OMNICORE_VERSION < LiveActivation.minClientVersion) {
+           std::string msgText = strprintf("Shutting down due to unsupported feature activation (%d: %s)", LiveActivation.featureId, LiveActivation.featureName);
+           PrintToLog(msgText);
+           PrintToConsole(msgText);
+           if (!GetBoolArg("-overrideforcedshutdown", false)) {
+               AbortNode(msgText, msgText);
+           }
+       }
+       PendingActivationCompleted(LiveActivation.featureId);
+       uiInterface.OmniStateChanged();
+    }
+}
+
+/**
+ * Moves an activation from PendingActivations to CompletedActivations when it is activated
+ *
+ */
+void PendingActivationCompleted(uint16_t featureId)
+{
+   for (std::vector<FeatureActivation>::iterator it = PendingActivations.begin(); it != PendingActivations.end(); ) {
+       if ((*it).featureId == featureId) {
+           FeatureActivation completedActivation = *it;
+           CompletedActivations.push_back(completedActivation);
+           it = PendingActivations.erase(it);
+       } else {
+           it++;
+       }
+   }
+}
+
+/**
+ * Returns the vector of pending activations.
+ */
+std::vector<FeatureActivation> GetPendingActivations()
+{
+    return PendingActivations;
+}
+
+/**
+ * Returns the vector of completed activations.
+ */
+std::vector<FeatureActivation> GetCompletedActivations()
+{
+    return CompletedActivations;
 }
 
 /**
@@ -428,13 +508,14 @@ bool ActivateFeature(uint16_t featureId, int activationBlock, uint32_t minClient
         break;
     }
     PrintToLog("Feature activation of ID %d processed. %s will be enabled at block %d.\n", featureId, featureName, activationBlock);
+    DeletePendingActivation(featureId); // if this feature id was previously scheduled for activation, delete the stale pending object
     AddPendingActivation(featureId, activationBlock, minClientVersion, featureName);
-    AddAlert("omnicore", ALERT_BLOCK_EXPIRY, activationBlock, strprintf("Feature %d ('%s') will go live at block %d", featureId, featureName, activationBlock));
     if (!supported) {
         PrintToLog("WARNING!!! AS OF BLOCK %d THIS CLIENT WILL BE OUT OF CONSENSUS AND WILL AUTOMATICALLY SHUTDOWN.\n", activationBlock);
-        AddAlert("omnicore", ALERT_FEATURE_UNSUPPORTED, activationBlock,
-                 strprintf("Your client must be updated and will shutdown at block %d "
-                           "(unsupported feature %d ('%s') activated)\n", activationBlock, featureId, featureName));
+        std::string alertText = strprintf("Your client must be updated and will shutdown at block %d (unsupported feature %d ('%s') activated)\n",
+                                          activationBlock, featureId, featureName);
+        AddAlert("omnicore", ALERT_BLOCK_EXPIRY, activationBlock, alertText);
+        CAlert::Notify(alertText, true);
     }
     return true;
 }
diff --git a/src/omnicore/rules.h b/src/omnicore/rules.h
@@ -25,9 +25,9 @@ const uint16_t FEATURE_GRANTEFFECTS = 4;
 //! Feature identifier to disable DEx "over-offers" and to switch to plain integer math
 const uint16_t FEATURE_DEXMATH = 5;
 
-/** A structure to represent a pending activation
+/** A structure to represent a feature activation
  */
-struct PendingActivation
+struct FeatureActivation
 {
     uint16_t featureId;
     int activationBlock;
@@ -175,6 +175,16 @@ CConsensusParams& MutableConsensusParams();
 
 /** Determines whether the sender is an authorized source for Omni Core activations. */
 bool CheckActivationAuthorization(const std::string& sender);
+/** Returns the vector of pending activations */
+std::vector<FeatureActivation> GetPendingActivations();
+/** Returns the vector of completed activations */
+std::vector<FeatureActivation> GetCompletedActivations();
+/** Moves a feature activation from pending vector to completed vector */
+void PendingActivationCompleted(uint16_t featureId);
+/** Checks if any activations went live in the block */
+void CheckLiveActivations(int blockHeight);
+/** Deletes a pending activation */
+void DeletePendingActivation(uint16_t featureId);
 /** Activates a feature at a specific block height. */
 bool ActivateFeature(uint16_t featureId, int activationBlock, uint32_t minClientVersion, int transactionBlock);
 /** Checks, whether a feature is activated at the given block. */
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
@@ -16,6 +16,7 @@
 
 #include "omnicore/notifications.h"
 #include "omnicore/omnicore.h"
+#include "omnicore/rules.h"
 #include "omnicore/sp.h"
 #include "omnicore/tx.h"
 #include "omnicore/pending.h"
@@ -622,12 +623,31 @@ void OverviewPage::updateDisplayUnit()
 void OverviewPage::updateAlerts()
 {
     QString alertString = QString::fromStdString(GetWarnings("statusbar")); // get current bitcoin alert/warning directly
+
+    // get alert messages
     std::vector<std::string> omniAlerts = GetOmniCoreAlertMessages();
     for (std::vector<std::string>::iterator it = omniAlerts.begin(); it != omniAlerts.end(); it++) {
         if (!alertString.isEmpty()) alertString += "\n";
         alertString += QString::fromStdString(*it);
     }
 
+    // get activations
+    std::vector<FeatureActivation> PendingActivations = GetPendingActivations();
+    for (std::vector<FeatureActivation>::iterator it = PendingActivations.begin(); it != PendingActivations.end(); ++it) {
+        if (!alertString.isEmpty()) alertString += "\n";
+        FeatureActivation pendingAct = *it;
+        alertString += QString::fromStdString(strprintf("Feature %d ('%s') will go live at block %d",
+                                                  pendingAct.featureId, pendingAct.featureName, pendingAct.activationBlock));
+    }
+    int currentHeight = GetHeight();
+    std::vector<FeatureActivation> CompletedActivations = GetCompletedActivations();
+    for (std::vector<FeatureActivation>::iterator it = CompletedActivations.begin(); it != CompletedActivations.end(); ++it) {
+        if (currentHeight > (*it).activationBlock+1024) continue; // don't include after live+1024 blocks
+        if (!alertString.isEmpty()) alertString += "\n";
+        FeatureActivation completedAct = *it;
+        alertString += QString::fromStdString(strprintf("Feature %d ('%s') is now live.", completedAct.featureId, completedAct.featureName));
+    }
+
     if (!alertString.isEmpty()) {
         this->ui->labelAlerts->setVisible(true);
         this->ui->labelAlerts->setText(alertString);
diff --git a/src/rpcserver.cpp b/src/rpcserver.cpp
@@ -358,6 +358,7 @@ static const CRPCCommand vRPCCommands[] =
     /* Omni Core data retrieval calls */
     /* CATEGORY                              NAME                               ACTOR (FUNCTION)                  OKSAFEMODE  THREADSAFE  REQWALLET */
     { "omni layer (data retrieval)",         "omni_getinfo",                    &omni_getinfo,                    true,       true,       false },
+    { "omni layer (data retrieval)",         "omni_getactivations",             &omni_getactivations,             true,       true,       false },
     { "omni layer (data retrieval)",         "omni_getallbalancesforid",        &omni_getallbalancesforid,        false,      true,       false },
     { "omni layer (data retrieval)",         "omni_getbalance",                 &omni_getbalance,                 false,      true,       false },
     { "omni layer (data retrieval)",         "omni_gettransaction",             &omni_gettransaction,             false,      true,       false },
diff --git a/src/rpcserver.h b/src/rpcserver.h
@@ -228,6 +228,7 @@ extern json_spirit::Value reconsiderblock(const json_spirit::Array& params, bool
 
 /* Omni Core data retrieval calls */
 extern json_spirit::Value omni_getinfo(const json_spirit::Array& params, bool fHelp);
+extern json_spirit::Value omni_getactivations(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value omni_getallbalancesforid(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value omni_getbalance(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value omni_gettransaction(const json_spirit::Array& params, bool fHelp);

Original file line number	Diff line number	Diff line change
`@@ -2678,7 +2678,7 @@ int mastercore_init()`
`2678`	`2678`	`}`
`2679`	`2679`
`2680`	`2680`	`// load feature activation messages from txlistdb and process them accordingly`
`2681`		`- p_txlistdb->LoadActivations();`
	`2681`	`+ p_txlistdb->LoadActivations(nWaterlineBlock);`
`2682`	`2682`
`2683`	`2683`	`// load all alerts from levelDB (and immediately expire old ones)`
`2684`	`2684`	`p_txlistdb->LoadAlerts(nWaterlineBlock);`
`@@ -2888,7 +2888,7 @@ int mastercore::ClassAgnosticWalletTXBuilder(const std::string& senderAddress, c`
`2888`	`2888`	`#endif`
`2889`	`2889`	`}`
`2890`	`2890`
`2891`		`-void CMPTxList::LoadActivations()`
	`2891`	`+void CMPTxList::LoadActivations(int blockHeight)`
`2892`	`2892`	`{`
`2893`	`2893`	`if (!pdb) return;`
`2894`	`2894`
`@@ -2945,6 +2945,7 @@ void CMPTxList::LoadActivations()`
`2945`	`2945`	`}`
`2946`	`2946`	`}`
`2947`	`2947`	`delete it;`
	`2948`	`+ CheckLiveActivations(blockHeight);`
`2948`	`2949`	`}`
`2949`	`2950`
`2950`	`2951`	`void CMPTxList::LoadAlerts(int blockHeight)`
`@@ -4066,6 +4067,9 @@ int mastercore_handler_block_begin(int nBlockPrev, CBlockIndex const * pBlockInd`
`4066`	`4067`	`}`
`4067`	`4068`	`}`
`4068`	`4069`
	`4070`	`+ // handle any features that go live with this block`
	`4071`	`+ CheckLiveActivations(pBlockIndex->nHeight);`
	`4072`	`+`
`4069`	`4073`	`eraseExpiredCrowdsale(pBlockIndex);`
`4070`	`4074`
`4071`	`4075`	`return 0;`