History

TimeSeriesPlatformLibrary: Fleshed out more code related to handling of new client subscriptions and signal index cache management.

J. Ritchie Carroll committed 7 years ago

Commit 2373d781 parent adf1b4e5 files · +129 −46Browse files

Unified · Split

5 files
  1. Source/Libraries/TimeSeriesPlatformLibrary/FilterExpressions/FilterExpressionParser.h +2 −2
  2. Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.cpp +109 −36
  3. Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.h +12 −4
  4. Source/Libraries/TimeSeriesPlatformLibrary/Transport/PublisherInstance.cpp +4 −4
  5. Source/Libraries/TimeSeriesPlatformLibrary/Transport/SignalIndexCache.h +2 −0
Source/Libraries/TimeSeriesPlatformLibrary/FilterExpressions/FilterExpressionParser.h+2−2
@@ -61,13 +61,13 @@ typedef GSF::SharedPtr<TableIDFields> TableIDFieldsPtr; · 60 unmodified lines
6161 class FilterExpressionParser;
6262 typedef GSF::SharedPtr<FilterExpressionParser> FilterExpressionParserPtr;
6363
64+typedef std::function<void(FilterExpressionParserPtr, const std::string&)> ParsingExceptionCallback;
65+
6466 class FilterExpressionParser : // NOLINT
6567 public FilterExpressionSyntaxBaseListener,
6668 public GSF::EnableSharedThisPtr<FilterExpressionParser>
6769 {
6870 private:
69− typedef void(*ParsingExceptionCallback)(FilterExpressionParserPtr, const std::string&);
70−
7171 class CallbackErrorListener : public antlr4::BaseErrorListener
7272 {
7373 private:
Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.cpp+109−36
@@ -21,23 +21,15 @@ · 20 unmodified lines
2121 //
2222 //******************************************************************************************************
2323
24−// ReSharper disable once CppUnusedIncludeDirective
25−#include "../FilterExpressions/FilterExpressions.h"
26−#include <boost/bind.hpp>
27−#include <boost/locale.hpp>
28−
2924 #include "DataPublisher.h"
3025 #include "Constants.h"
3126 #include "../Common/Convert.h"
3227 #include "../Common/EndianConverter.h"
33−#include "../FilterExpressions/FilterExpressionParser.h"
3428 #include "MetadataSchema.h"
3529 #include "ActiveMeasurementsSchema.h"
3630
3731 using namespace std;
38−using namespace pugi;
3932 using namespace boost;
40−using namespace boost::locale::conv;
4133 using namespace boost::asio;
4234 using namespace boost::asio::ip;
4335 using namespace GSF;
@@ -46,6 +38,16 @@ using namespace GSF::FilterExpressions; · 2 unmodified lines
4638 using namespace GSF::TimeSeries;
4739 using namespace GSF::TimeSeries::Transport;
4840
41+inline int32_t GetColumnIndex(const DataTablePtr& table, const string& columnName)
42+{
43+ const DataColumnPtr& column = table->Column(columnName);
44+
45+ if (column == nullptr)
46+ throw PublisherException("Column name \"" + columnName + "\" was not found in table \"" + table->Name() + "\"");
47+
48+ return column->Index();
49+}
50+
4951 // --- ClientConnectedInfo ---
5052
5153 struct ClientConnectionInfo
@@ -67,6 +69,7 @@ ClientConnection::ClientConnection(DataPublisherPtr parent, IOContext& commandCh · 15 unmodified lines
6769 m_commandChannelService(commandChannelService),
6870 m_subscriberID(NewGuid()),
6971 m_operationalModes(OperationalModes::NoFlags),
72+ m_compressionModes(CompressionModes::None),
7073 m_encoding(OperationalEncoding::UTF8),
7174 m_usePayloadCompression(false),
7275 m_useCompactMeasurementFormat(true),
@@ -129,6 +132,16 @@ void ClientConnection::SetOperationalModes(uint32_t value) · 56 unmodified lines
129132 m_encoding = m_operationalModes & OperationalModes::EncodingMask;
130133 }
131134
135+uint32_t ClientConnection::GetCompressionModes() const
136+{
137+ return m_compressionModes;
138+}
139+
140+void ClientConnection::SetCompressionModes(uint32_t value)
141+{
142+ m_compressionModes = value;
143+}
144+
132145 uint32_t ClientConnection::GetEncoding() const
133146 {
134147 return m_encoding;
@@ -196,11 +209,16 @@ void ClientConnection::SetSubscriptionInfo(const string& value) · 61 unmodified lines
196209 m_subscriptionInfo = source + " version " + version + " built on " + buildDate;
197210 }
198211
199−SignalIndexCache& ClientConnection::GetSignalIndexCache()
212+const SignalIndexCachePtr& ClientConnection::GetSignalIndexCache() const
200213 {
201214 return m_signalIndexCache;
202215 }
203216
217+void ClientConnection::SetSignalIndexCache(SignalIndexCachePtr signalIndexCache)
218+{
219+ m_signalIndexCache = std::move(signalIndexCache);
220+}
221+
204222 bool ClientConnection::CipherKeysDefined() const
205223 {
206224 return !m_keys[0].empty();
@@ -496,6 +514,11 @@ DataPublisher::DataPublisher(const TcpEndPoint& endpoint) : · 289 unmodified lines
496514 m_clientConnectedCallback(nullptr),
497515 m_clientDisconnectedCallback(nullptr)
498516 {
517+ m_tableIDFields = NewSharedPtr<TableIDFields>();
518+ m_tableIDFields->SignalIDFieldName = "SignalID";
519+ m_tableIDFields->MeasurementKeyFieldName = "ID";
520+ m_tableIDFields->PointTagFieldName = "PointTag";
521+
499522 m_callbackThread = Thread(bind(&DataPublisher::RunCallbackThread, this));
500523 m_commandChannelAcceptThread = Thread(bind(&DataPublisher::RunCommandChannelAcceptThread, this));
501524 }
@@ -602,28 +625,75 @@ void DataPublisher::HandleSubscribe(const ClientConnectionPtr& connection, uint8 · 100 unmodified lines
602625 const StringMap<string> settings = ParseKeyValuePairs(connectionString);
603626 string setting;
604627
605− // TODO: Explore re-subscription details
606− // if (connection->GetIsSubscribed()) ...
607−
608628 connection->SetUsePayloadCompression(usePayloadCompression);
609629 connection->SetUseCompactMeasurementFormat(useCompactMeasurementFormat);
610630
611− // Apply client filter expression and build signal index cache
631+ SignalIndexCachePtr signalIndexCache = nullptr;
632+
633+ // Apply subscriber filter expression and build signal index cache
612634 if (TryGetValue(settings, "inputMeasurementKeys", setting))
613635 {
614− SignalIndexCache& signalIndexCache = connection->GetSignalIndexCache();
615− const DataTablePtr& filterTable = m_activeMetadata->Table("ActiveMeasurements");
616− vector<DataRowPtr> rows = FilterExpressionParser::Select(filterTable, setting); //??
617− const int32_t signalIDColumn = filterTable->Column("SignalID")->Index();
636+ signalIndexCache = NewSharedPtr<SignalIndexCache>();
637+ string exceptionMessage, parsingException;
638+ FilterExpressionParser parser(setting);
639+
640+ parser.SetDataSet(m_activeMetadata);
641+ parser.SetTableIDFields("ActiveMeasurements", m_tableIDFields);
642+ parser.RegisterParsingExceptionCallback([&parsingException](FilterExpressionParserPtr, const string& exception) { parsingException = exception; });
643+
644+ try
645+ {
646+ parser.Evaluate();
647+ }
648+ catch (const FilterExpressionParserException& ex)
649+ {
650+ exceptionMessage = "FilterExpressionParser exception: " + string(ex.what());
651+ }
652+ catch (const ExpressionTreeException& ex)
653+ {
654+ exceptionMessage = "ExpressionTree exception: " + string(ex.what());
655+ }
656+ catch (...)
657+ {
658+ exceptionMessage = current_exception_diagnostic_information(true);
659+ }
660+
661+ if (!exceptionMessage.empty())
662+ {
663+ if (!parsingException.empty())
664+ exceptionMessage += "\n" + parsingException;
665+
666+ SendClientResponse(connection, ServerResponse::Failed, ServerCommand::Subscribe, exceptionMessage);
667+ DispatchErrorMessage(exceptionMessage);
668+ return;
669+ }
670+
671+ const DataTablePtr& activeMeasurements = m_activeMetadata->Table("ActiveMeasurements");
672+ const vector<DataRowPtr>& rows = parser.FilteredRows();
673+ const int32_t idColumn = GetColumnIndex(activeMeasurements, "ID");
674+ const int32_t signalIDColumn = GetColumnIndex(activeMeasurements, "SignalID");
618675
619676 for (size_t i = 0; i < rows.size(); i++)
620677 {
621678 const DataRowPtr& row = rows[i];
622− const uint16_t signalIndex = 0;
623679 const Guid& signalID = row->ValueAsGuid(signalIDColumn).GetValueOrDefault();
624− signalIndexCache.AddMeasurementKey(signalIndex, signalID, "", 0);
680+ const vector<string> parts = Split(row->ValueAsString(idColumn).GetValueOrDefault(), ":");
681+ uint16_t signalIndex = 0;
682+ string source;
683+ int32_t id = 0;
684+
685+ if (parts.size() == 2)
686+ {
687+ source = parts[0];
688+ id = stoi(parts[1]);
689+ }
690+ else
691+ {
692+ source = parts[0];
693+ }
694+
695+ signalIndexCache->AddMeasurementKey(signalIndex++, signalID, source, id);
625696 }
626−
627697 }
628698
629699 // Pass subscriber assembly information to connection, if defined
@@ -674,7 +744,18 @@ void DataPublisher::HandleSubscribe(const ClientConnectionPtr& connection, uint8 · 44 unmodified lines
674744 */
675745 }
676746
677− const string message = "Client subscribed as " + string(useCompactMeasurementFormat ? "" : "non-") + "compact unsynchronized with " + ToString(connection->GetSignalIndexCache().Count()) + " signals.";
747+ // Send updated signal index cache to client with validated rights of the selected input measurement keys
748+ vector<uint8_t> serializedSignalIndexCache;
749+ SerializeSignalIndexCache(connection, signalIndexCache, serializedSignalIndexCache);
750+ SendClientResponse(connection, ServerResponse::UpdateSignalIndexCache, ServerCommand::Subscribe, serializedSignalIndexCache);
751+ connection->SetSignalIndexCache(signalIndexCache);
752+
753+ int32_t signalCount = 0;
754+
755+ if (signalIndexCache != nullptr)
756+ signalCount = signalIndexCache->Count();
757+
758+ const string message = "Client subscribed as " + string(useCompactMeasurementFormat ? "" : "non-") + "compact unsynchronized with " + ToString(signalCount) + " signals.";
678759
679760 connection->SetIsSubscribed(true);
680761 SendClientResponse(connection, ServerResponse::Succeeded, ServerCommand::Subscribe, message);
@@ -919,11 +1000,12 @@ void DataPublisher::ClientDisconnectedDispatcher(DataPublisher* source, const st · 238 unmodified lines
9191000 delete data;
9201001 }
9211002
922−void DataPublisher::SerializeSignalIndexCache(const GSF::Guid& clientID, const SignalIndexCache& signalIndexCache, vector<uint8_t>& buffer)
1003+void DataPublisher::SerializeSignalIndexCache(const ClientConnectionPtr& connection, const SignalIndexCachePtr& signalIndexCache, vector<uint8_t>& buffer)
9231004 {
1005+ // TODO: Serialize signal index cache
9241006 }
9251007
926−std::string DataPublisher::DecodeClientString(const ClientConnectionPtr& connection, const uint8_t* data, uint32_t offset, uint32_t length) const
1008+string DataPublisher::DecodeClientString(const ClientConnectionPtr& connection, const uint8_t* data, uint32_t offset, uint32_t length) const
9271009 {
9281010 uint32_t encoding = OperationalEncoding::UTF8;
9291011 bool swapBytes = EndianConverter::IsLittleEndian();
@@ -934,7 +1016,7 @@ std::string DataPublisher::DecodeClientString(const ClientConnectionPtr& connect · 4 unmodified lines
9341016 switch (encoding)
9351017 {
9361018 case OperationalEncoding::UTF8:
937− return string(reinterpret_cast<const char_t*>(data + offset), length / sizeof(char_t));
1019+ return string(reinterpret_cast<const char*>(data + offset), length / sizeof(char));
9381020 case OperationalEncoding::Unicode:
9391021 case OperationalEncoding::ANSI:
9401022 swapBytes = !swapBytes;
@@ -958,7 +1040,7 @@ std::string DataPublisher::DecodeClientString(const ClientConnectionPtr& connect · 17 unmodified lines
9581040 }
9591041 }
9601042
961−std::vector<uint8_t> DataPublisher::EncodeClientString(const ClientConnectionPtr& connection, const std::string& value) const
1043+vector<uint8_t> DataPublisher::EncodeClientString(const ClientConnectionPtr& connection, const std::string& value) const
9621044 {
9631045 uint32_t encoding = OperationalEncoding::UTF8;
9641046 bool swapBytes = EndianConverter::IsLittleEndian();
@@ -971,7 +1053,7 @@ std::vector<uint8_t> DataPublisher::EncodeClientString(const ClientConnectionPtr · 6 unmodified lines
9711053 switch (encoding)
9721054 {
9731055 case OperationalEncoding::UTF8:
974− result.reserve(value.size() * sizeof(char_t));
1056+ result.reserve(value.size() * sizeof(char));
9751057 result.assign(value.begin(), value.end());
9761058 break;
9771059 case OperationalEncoding::Unicode:
@@ -1195,16 +1277,6 @@ bool DataPublisher::SendClientResponse(const ClientConnectionPtr& connection, ui · 217 unmodified lines
11951277 return success;
11961278 }
11971279
1198−inline int32_t GetColumnIndex(const DataTablePtr& table, const string& columnName)
1199−{
1200− const DataColumnPtr& column = table->Column(columnName);
1201−
1202− if (column == nullptr)
1203− throw PublisherException("Column name \"" + columnName + "\" was not found in table \"" + table->Name() + "\"");
1204−
1205− return column->Index();
1206−}
1207−
12081280 void DataPublisher::DefineMetadata(const vector<DeviceMetadataPtr>& deviceMetadata, const vector<MeasurementMetadataPtr>& measurementMetadata, const vector<PhasorMetadataPtr>& phasorMetadata, const int32_t versionNumber)
12091281 {
12101282 typedef unordered_map<uint16_t, char> PhasorTypeMap;
@@ -1589,6 +1661,7 @@ void DataPublisher::DefineMetadata(const DataSetPtr& metadata) · 378 unmodified lines
15891661
15901662 void DataPublisher::PublishMeasurements(const vector<Measurement>& measurements)
15911663 {
1664+ // TODO: Publish measurements to subscribed connections - routing?
15921665 }
15931666
15941667 void DataPublisher::PublishMeasurements(const vector<MeasurementPtr>& measurements)
Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.h+12−4
@@ -24,11 +24,13 @@ · 23 unmodified lines
2424 #ifndef __DATA_PUBLISHER_H
2525 #define __DATA_PUBLISHER_H
2626
27+// ReSharper disable once CppUnusedIncludeDirective
28+#include "../FilterExpressions/FilterExpressions.h"
2729 #include "../Common/CommonTypes.h"
2830 #include "../Common/ThreadSafeQueue.h"
2931 #include "../Common/Timer.h"
30−#include "../Common/pugixml.hpp"
3132 #include "../Data/DataSet.h"
33+#include "../FilterExpressions/FilterExpressionParser.h"
3234 #include "TransportTypes.h"
3335 #include "SignalIndexCache.h"
3436 #include "Constants.h"
@@ -71,6 +73,7 @@ namespace Transport · 36 unmodified lines
7173 std::string m_connectionID;
7274 std::string m_subscriptionInfo;
7375 uint32_t m_operationalModes;
76+ uint32_t m_compressionModes;
7477 uint32_t m_encoding;
7578 bool m_usePayloadCompression;
7679 bool m_useCompactMeasurementFormat;
@@ -90,7 +93,7 @@ namespace Transport · 13 unmodified lines
9093 std::vector<uint8_t> m_ivs[2];
9194
9295 // Measurement parsing
93− SignalIndexCache m_signalIndexCache;
96+ SignalIndexCachePtr m_signalIndexCache;
9497 int32_t m_timeIndex;
9598 int64_t m_baseTimeOffsets[2];
9699 //TSSCMeasurementParser m_tsscMeasurementParser;
@@ -118,6 +121,9 @@ namespace Transport · 21 unmodified lines
118121 uint32_t GetOperationalModes() const;
119122 void SetOperationalModes(uint32_t value);
120123
124+ uint32_t GetCompressionModes() const;
125+ void SetCompressionModes(uint32_t value);
126+
121127 uint32_t GetEncoding() const;
122128
123129 bool GetUsePayloadCompression() const;
@@ -132,7 +138,8 @@ namespace Transport · 8 unmodified lines
132138 const std::string& GetSubscriptionInfo() const;
133139 void SetSubscriptionInfo(const std::string& value);
134140
135− SignalIndexCache& GetSignalIndexCache();
141+ const SignalIndexCachePtr& GetSignalIndexCache() const;
142+ void SetSignalIndexCache(SignalIndexCachePtr signalIndexCache);
136143
137144 bool CipherKeysDefined() const;
138145 std::vector<uint8_t> Keys(int32_t cipherIndex);
@@ -170,6 +177,7 @@ namespace Transport · 31 unmodified lines
170177 GSF::Guid m_nodeID;
171178 GSF::Data::DataSetPtr m_allMetadata;
172179 GSF::Data::DataSetPtr m_activeMetadata;
180+ GSF::FilterExpressions::TableIDFieldsPtr m_tableIDFields;
173181 std::unordered_set<ClientConnectionPtr> m_clientConnections;
174182 GSF::Mutex m_clientConnectionsLock;
175183 SecurityMode m_securityMode;
@@ -237,7 +245,7 @@ namespace Transport · 61 unmodified lines
237245 static void ErrorMessageDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
238246 static void ClientConnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
239247 static void ClientDisconnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
240− static void SerializeSignalIndexCache(const GSF::Guid& clientID, const SignalIndexCache& signalIndexCache, std::vector<uint8_t>& buffer);
248+ static void SerializeSignalIndexCache(const ClientConnectionPtr& connection, const SignalIndexCachePtr& signalIndexCache, std::vector<uint8_t>& buffer);
241249
242250 std::string DecodeClientString(const ClientConnectionPtr& connection, const uint8_t* data, uint32_t offset, uint32_t length) const;
243251 std::vector<uint8_t> EncodeClientString(const ClientConnectionPtr& connection, const std::string& value) const;
Source/Libraries/TimeSeriesPlatformLibrary/Transport/PublisherInstance.cpp+4−4
@@ -57,13 +57,13 @@ void PublisherInstance::HandleErrorMessage(DataPublisher* source, const string& · 56 unmodified lines
5757 instance->ErrorMessage(message);
5858 }
5959
60−void PublisherInstance::HandleClientConnected(DataPublisher* source, const Guid& subscriberID, const std::string& connectionID)
60+void PublisherInstance::HandleClientConnected(DataPublisher* source, const GSF::Guid& subscriberID, const std::string& connectionID)
6161 {
6262 PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
6363 instance->ClientConnected(subscriberID, connectionID);
6464 }
6565
66−void PublisherInstance::HandleClientDisconnected(DataPublisher* source, const Guid& subscriberID, const std::string& connectionID)
66+void PublisherInstance::HandleClientDisconnected(DataPublisher* source, const GSF::Guid& subscriberID, const std::string& connectionID)
6767 {
6868 PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
6969 instance->ClientDisconnected(subscriberID, connectionID);
@@ -79,12 +79,12 @@ void PublisherInstance::ErrorMessage(const string& message) · 9 unmodified lines
7979 cerr << message << endl << endl;
8080 }
8181
82−void PublisherInstance::ClientConnected(const Guid& subscriberID, const string& connectionID)
82+void PublisherInstance::ClientConnected(const GSF::Guid& subscriberID, const string& connectionID)
8383 {
8484 cout << "Client \"" << connectionID << "\" with subscriber ID " << ToString(subscriberID) << " connected..." << endl << endl;
8585 }
8686
87−void PublisherInstance::ClientDisconnected(const Guid& subscriberID, const std::string& connectionID)
87+void PublisherInstance::ClientDisconnected(const GSF::Guid& subscriberID, const std::string& connectionID)
8888 {
8989 cout << "Client \"" << connectionID << "\" with subscriber ID " << ToString(subscriberID) << " disconnected..." << endl << endl;
9090 }
Source/Libraries/TimeSeriesPlatformLibrary/Transport/SignalIndexCache.h+2−0
@@ -84,6 +84,8 @@ namespace Transport · 83 unmodified lines
8484 // Gets the mapped signal count
8585 uint32_t Count() const;
8686 };
87+
88+ typedef SharedPtr<SignalIndexCache> SignalIndexCachePtr;
8789 }}}
8890
8991 #endif

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t