/// <summary>
/// Updates the event types in cache with the most recent info fetched from the AE server.
/// </summary>
public void UpdateCache(ServerSystemContext context, ushort namespaceIndex)
{
// clear the existing nodes.
EventTypeNodes = new NodeIdDictionary <BaseObjectTypeState>();
Attributes = new Dictionary <int, int[]>();
TypeTable typeTable = context.TypeTable as TypeTable;
// rebuild from the recently fetched list.
for (int ii = 0; ii < EventTypes.Count; ii++)
{
// save the attributes for use when creating filters.
if (EventTypes[ii].EventTypeMapping != EventTypeMapping.ConditionClassType && !Attributes.ContainsKey(EventTypes[ii].CategoryId))
{
EventType eventType = EventTypes[ii];
int[] attributeIds = new int[eventType.Attributes.Count];
for (int jj = 0; jj < attributeIds.Length; jj++)
{
attributeIds[jj] = eventType.Attributes[jj].Id;
}
Attributes.Add(EventTypes[ii].CategoryId, attributeIds);
}
AeEventTypeState node = new AeEventTypeState(EventTypes[ii], namespaceIndex);
BaseObjectTypeState mappingNode = null;
if (!EventTypeNodes.TryGetValue(node.SuperTypeId, out mappingNode))
{
mappingNode = new AeEventTypeMappingState(node.EventType.EventTypeMapping, namespaceIndex);
EventTypeNodes.Add(mappingNode.NodeId, mappingNode);
// ensure the mapping node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(mappingNode.NodeId))
{
typeTable.AddSubtype(mappingNode.NodeId, mappingNode.SuperTypeId);
}
}
}
EventTypeNodes.Add(node.NodeId, node);
// ensure the type node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(node.NodeId))
{
typeTable.AddSubtype(node.NodeId, mappingNode.NodeId);
}
}
}
}
/// <summary>
/// Returns a unique handle for the node.
/// </summary>
protected override NodeHandle GetManagerHandle(ServerSystemContext context, NodeId nodeId, IDictionary <NodeId, NodeState> cache)
{
lock (Lock)
{
// quickly exclude nodes that are not in the namespace.
if (!IsNodeIdInNamespace(nodeId))
{
return(null);
}
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = true;
uint id = (uint)nodeId.Identifier;
// find register
int registerId = (int)((id & 0xFF000000) >> 24);
int index = (int)(id & 0x00FFFFFF);
if (registerId == 0)
{
MemoryRegister register = m_system.GetRegister(index);
if (register == null)
{
return(null);
}
handle.Node = ModelUtils.GetRegister(register, NamespaceIndex);
}
// find register variable.
else
{
MemoryRegister register = m_system.GetRegister(registerId);
if (register == null)
{
return(null);
}
// find register variable.
BaseDataVariableState variable = ModelUtils.GetRegisterVariable(register, index, NamespaceIndex);
if (variable == null)
{
return(null);
}
handle.Node = variable;
}
return(handle);
}
}
/// <summary>
/// Called after creating a MonitoredItem.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="handle">The handle for the node.</param>
/// <param name="monitoredItem">The monitored item.</param>
protected override void OnMonitoredItemCreated(ServerSystemContext context, NodeHandle handle, MonitoredItem monitoredItem)
{
if (handle.Node.GetHierarchyRoot() is BlockState block)
{
block.StartMonitoring(context);
// need to save the block to ensure that multiple monitored items use the same instance.
_blocks[block.NodeId] = block;
}
}
/// <summary>
/// Verifies that the specified node exists.
/// </summary>
protected override NodeState ValidateNode(ServerSystemContext context, NodeHandle handle, IDictionary <NodeId, NodeState> cache)
{
// not valid if no root.
if (handle == null)
{
return(null);
}
// check if previously validated.
return(handle.Validated ? handle.Node : null);
}
/// <summary>
/// Creates a refrigerator factory
/// </summary>
/// <param name="parentNode">The node that should old the refrigerators</param>
/// <param name="refrigeratorName">The name for the new refrigerator</param>
/// <param name="customManager">The node manager for the nodes created.</param>
public RefrigeratorFactory(NodeState parentNode, string refrigeratorName, CustomNodeManager2 customManager)
{
m_refrigeratorName = refrigeratorName;
m_namespaceindex = customManager.NamespaceIndex;
m_systemContext = customManager.SystemContext;
m_nodeFactory = new NodeFactory(customManager);
m_parentNode = parentNode;
_numGenerator = new Random();
CreateRefrigerator();
}
/// <summary>
/// Called after deleting a MonitoredItem.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="handle">The handle for the node.</param>
/// <param name="monitoredItem">The monitored item.</param>
protected override void OnMonitoredItemDeleted(ServerSystemContext context, NodeHandle handle, MonitoredItem monitoredItem)
{
if (handle.Node.GetHierarchyRoot() is BlockState block)
{
if (!block.StopMonitoring(context))
{
// can remove the block since all monitored items for the block are gone.
_blocks.Remove(block.NodeId);
}
}
}
/// <summary>
/// Returns a unique handle for the node.
/// </summary>
protected override NodeHandle GetManagerHandle(ServerSystemContext context, NodeId nodeId, IDictionary <NodeId, NodeState> cache)
{
lock (Lock) {
// quickly exclude nodes that are not in the namespace.
if (!IsNodeIdInNamespace(nodeId))
{
return(null);
}
// check for check for nodes that are being currently monitored.
if (MonitoredNodes.TryGetValue(nodeId, out var monitoredNode))
{
var handle = new NodeHandle {
NodeId = nodeId,
Validated = true,
Node = monitoredNode.Node
};
return(handle);
}
if (nodeId.IdType != IdType.String)
{
if (PredefinedNodes.TryGetValue(nodeId, out var node))
{
var handle = new NodeHandle {
NodeId = nodeId,
Node = node,
Validated = true
};
return(handle);
}
}
// parse the identifier.
var parsedNodeId = ParsedNodeId.Parse(nodeId);
if (parsedNodeId != null)
{
var handle = new NodeHandle {
NodeId = nodeId,
Validated = false,
Node = null,
ParsedNodeId = parsedNodeId
};
return(handle);
}
return(null);
}
}
/// <summary>
/// Called after deleting a MonitoredItem.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="handle">The handle for the node.</param>
/// <param name="monitoredItem">The monitored item.</param>
protected override void OnMonitoredItemDeleted(
ServerSystemContext context,
NodeHandle handle,
MonitoredItem monitoredItem)
{
// check for variables that need to be scanned.
if (SystemScanRequired(handle.MonitoredNode, monitoredItem))
{
m_system.StopMonitoringValue(monitoredItem.Id);
}
}
protected override void OnSetMonitoringModeComplete(ServerSystemContext context, IList <IMonitoredItem> monitoredItems)
{
List <DataSourceClient.MonitoringRequest> requests = null;
lock (Lock)
{
requests = CollectRequests(context, monitoredItems);
}
m_source.SetMonitoringMode(requests);
}
private ServiceResult OnRequestLock(
ISystemContext context,
MethodState method,
NodeId objectId,
IList <object> inputArguments,
IList <object> outputArguments)
{
DsatsDemo.LockConditionState node = (DsatsDemo.LockConditionState)FindPredefinedNode(objectId, typeof(DsatsDemo.LockConditionState));
if (!node.EnabledState.Id.Value)
{
return(StatusCodes.BadConditionDisabled);
}
if (node.LockState.CurrentState.Id.Value != new NodeId(DsatsDemo.Objects.LockStateMachineType_Unlocked, NamespaceIndex))
{
return(StatusCodes.BadConditionAlreadyShelved);
}
node.SessionId.Value = context.SessionId;
node.ClientUserId.Value = null;
node.SubjectName.Value = null;
// get the current user name.
if (context.UserIdentity != null)
{
node.ClientUserId.Value = context.UserIdentity.DisplayName;
}
X509Certificate2 certificate = null;
// get the client certificate subject name.
ServerSystemContext systemContext = context as ServerSystemContext;
if (systemContext != null && systemContext.OperationContext != null && systemContext.OperationContext.Session != null && systemContext.OperationContext.Session.ClientCertificate != null)
{
certificate = systemContext.OperationContext.Session.ClientCertificate;
node.SubjectName.Value = certificate.Subject;
}
node.RequestLock(context);
// admins get locks immediately.
if (CheckAdminAccess(context) || (certificate != null && node.HasPermission(certificate)))
{
GrantLockToSession(context, node.SessionId.Value, objectId);
node.SetLock(context);
}
node.ReportEvent(context, node);
node.ClearChangeMasks(context, true);
return(ServiceResult.Good);
}
/// <summary>
/// Called when a monitored item is deleted
/// </summary>
protected override void OnMonitoredItemDeleted(ServerSystemContext context, NodeHandle handle, MonitoredItem monitoredItem)
{
// check if monitored item requires scaning.
if (!IsScanRequired(handle, monitoredItem))
{
return;
}
// delete monitored item.
StopScan(handle, monitoredItem);
}
/// <summary>
/// Called after modifying a MonitoredItem.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="handle">The handle for the node.</param>
/// <param name="monitoredItem">The monitored item.</param>
protected override void OnMonitoredItemModified(
ServerSystemContext context,
NodeHandle handle,
MonitoredItem monitoredItem) {
if (SystemScanRequired(handle.MonitoredNode, monitoredItem)) {
if (monitoredItem.MonitoringMode != MonitoringMode.Disabled) {
BaseVariableState source = handle.Node as BaseVariableState;
m_system.StopMonitoringValue(monitoredItem.Id);
m_system.StartMonitoringValue(monitoredItem.Id, monitoredItem.SamplingInterval, source);
}
}
}
/// <summary>
/// Queues the value to the monitored item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <param name="initialUpdate">if set to <c>true</c> [initial update].</param>
public void QueueValues(ServerSystemContext context, HdaReadRequest request, bool initialUpdate)
{
for (int ii = 0; ii < m_monitoredItems.Count; ii++)
{
QueueValue(context, request, m_monitoredItems[ii]);
}
if (!initialUpdate)
{
IncrementSampleTime();
}
}
/// <summary>
/// Tells the node manager to refresh any conditions associated with the specified monitored items.
/// </summary>
/// <remarks>
/// This method is called when the condition refresh method is called for a subscription.
/// The node manager must create a refresh event for each condition monitored by the subscription.
/// </remarks>
public override ServiceResult ConditionRefresh(
OperationContext context,
IList <IEventMonitoredItem> monitoredItems)
{
ServerSystemContext serverSystemContext = SystemContext.Copy(context);
foreach (MonitoredItem monitoredItem in monitoredItems)
{
if (monitoredItem == null)
{
continue;
}
List <IFilterTarget> events = new List <IFilterTarget>();
List <NodeState> nodesToRefresh = new List <NodeState>();
lock (Lock)
{
// check for server subscription.
if (monitoredItem.NodeId == ObjectIds.Server)
{
if (_rootNotifiers != null)
{
nodesToRefresh.AddRange(_rootNotifiers);
}
}
else
{
if (!MonitoredNodes.TryGetValue(monitoredItem.NodeId, out MonitoredNode2 monitoredNode))
{
continue;
}
// get the refresh events.
nodesToRefresh.Add(monitoredNode.Node);
}
}
foreach (var node in nodesToRefresh)
{
node.ConditionRefresh(SystemContext, events, true);
}
foreach (var @event in events)
{
monitoredItem.QueueEvent(@event);
}
}
return(ServiceResult.Good);
}
/// <summary>
/// Returns a unique handle for the node.
/// </summary>
protected override NodeHandle GetManagerHandle(ServerSystemContext context, NodeId nodeId, IDictionary <NodeId, NodeState> cache)
{
lock (Lock)
{
// quickly exclude nodes that are not in the namespace.
if (!IsNodeIdInNamespace(nodeId))
{
return(null);
}
NodeState node = null;
// check cache (the cache is used because the same node id can appear many times in a single request).
if (cache != null)
{
if (cache.TryGetValue(nodeId, out node))
{
return(new NodeHandle(nodeId, node));
}
}
// look up predefined node.
if (PredefinedNodes.TryGetValue(nodeId, out node))
{
NodeHandle handle = new NodeHandle(nodeId, node);
if (cache != null)
{
cache.Add(nodeId, node);
}
return(handle);
}
#region Task #A5 - Add Support for External Nodes
// parse the node id and return an unvalidated handle.
if (nodeId.IdType == IdType.String)
{
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = false;
handle.ParsedNodeId = ParsedNodeId.Parse(nodeId);
return(handle);
}
#endregion
// node not found.
return(null);
}
}
/// <summary>
/// Returns the history data source for a node.
/// </summary>
protected virtual ServiceResult GetHistoryDataSource(
ServerSystemContext context,
BaseVariableState variable,
out IHistoryDataSource datasource)
{
datasource = _system.GetHistoryFile(variable);
if (datasource == null)
{
return(StatusCodes.BadNotReadable);
}
return(ServiceResult.Good);
}
/// <summary>
/// Starts the monitoring the block.
/// </summary>
/// <param name="context">The context.</param>
public void StartMonitoring(ServerSystemContext context)
{
if (_monitoringCount == 0)
{
if (context.SystemHandle is UnderlyingSystem system)
{
var block = system.FindBlock(_blockId);
block?.StartMonitoring(OnTagsChanged);
}
}
_monitoringCount++;
}
/// <summary>
/// Called when a monitored item is created.
/// </summary>
protected override void OnMonitoredItemCreated(ServerSystemContext context, NodeHandle handle, MonitoredItem monitoredItem)
{
// check if monitored item requires scaning.
if (!IsScanRequired(handle, monitoredItem))
{
return;
}
// only scan enabled items.
if (monitoredItem.MonitoringMode != MonitoringMode.Disabled)
{
StartScan(handle, monitoredItem);
}
}
/// <summary>
/// Verifies that the specified node exists.
/// </summary>
protected override NodeState ValidateNode(
ServerSystemContext context,
NodeHandle handle,
IDictionary <NodeId, NodeState> cache)
{
// not valid if no root.
if (handle == null)
{
return(null);
}
// check if previously validated.
if (handle.Validated)
{
return(handle.Node);
}
// lookup in operation cache.
NodeState target = FindNodeInCache(context, handle, cache);
if (target != null)
{
handle.Node = target;
handle.Validated = true;
return(handle.Node);
}
#region Task #A5 - Add Support for External Nodes
ParsedNodeId nodeId = (ParsedNodeId)handle.ParsedNodeId;
BaseObjectState node = CreateFolderNode(nodeId.RootId);
if (node == null)
{
return(null);
}
target = node;
#endregion
// put root into operation cache.
if (cache != null)
{
cache[handle.NodeId] = target;
}
handle.Node = target;
handle.Validated = true;
return(handle.Node);
}
protected override NodeState ValidateNode(
ServerSystemContext context,
NodeHandle handle,
IDictionary<NodeId, NodeState> cache)
{
if (handle == null)
{
return null;
}
if (handle.Validated)
{
return handle.Node;
}
return null;
}
/// <summary>
/// Restores a previously cached history reader.
/// </summary>
protected virtual HistoryDataReader RestoreDataReader(ServerSystemContext context, byte[] continuationPoint)
{
if (context == null || context.OperationContext == null || context.OperationContext.Session == null)
{
return(null);
}
if (!(context.OperationContext.Session.RestoreHistoryContinuationPoint(continuationPoint) is HistoryDataReader reader))
{
return(null);
}
return(reader);
}
/// <summary>
/// Removes the specified monitored item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="monitoredItem">The monitored item.</param>
public void Remove(ServerSystemContext context, MonitoredItem monitoredItem)
{
// remove the monitored item.
if (monitoredItem != null && m_monitoredItems != null)
{
for (int ii = 0; ii < m_monitoredItems.Count; ii++)
{
if (Object.ReferenceEquals(m_monitoredItems[ii], monitoredItem))
{
m_monitoredItems.RemoveAt(ii);
break;
}
}
}
}
/// <summary>
/// Adds the specified monitored item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="monitoredItem">The monitored item.</param>
public void Add(ServerSystemContext context, MonitoredItem monitoredItem)
{
if (monitoredItem == null)
{
return;
}
// save the monitored item.
if (m_monitoredItems == null)
{
m_monitoredItems = new List <MonitoredItem>();
}
m_monitoredItems.Add(monitoredItem);
}
/// <summary>
/// 重写节点验证 方式
/// </summary>
/// <param name="context"></param>
/// <param name="handle"></param>
/// <param name="cache"></param>
/// <returns></returns>
protected override NodeState ValidateNode(ServerSystemContext context, NodeHandle handle,
IDictionary <NodeId, NodeState> cache)
{
//如果handle没有root节点 not valid
if (handle == null)
{
return(null);
}
//检查是否已验证过
if (handle.Validated)
{
return(handle.Node);
}
return(null);
}
/// <summary>
/// Returns the type identified by the category id and condition name.
/// </summary>
public AeEventTypeState FindType(ServerSystemContext context, NodeId nodeId)
{
if (NodeId.IsNull(nodeId))
{
return(null);
}
BaseObjectTypeState eventType = null;
if (!EventTypeNodes.TryGetValue(nodeId, out eventType))
{
return(null);
}
return(eventType as AeEventTypeState);
}
/// <summary>
/// Stop the monitoring the block.
/// </summary>
/// <param name="context">The context.</param>
public bool StopMonitoring(ServerSystemContext context)
{
_monitoringCount--;
if (_monitoringCount == 0)
{
if (context.SystemHandle is UnderlyingSystem system)
{
var block = system.FindBlock(_blockId);
block?.StopMonitoring();
}
}
return(_monitoringCount != 0);
}
/// <summary>
/// Verifies that the specified node exists.
/// </summary>
protected override NodeState ValidateNode(
ServerSystemContext context,
NodeHandle handle,
IDictionary <NodeId, NodeState> cache)
{
// not valid if no root.
if (handle == null)
{
return(null);
}
// check if previously validated.
if (handle.Validated)
{
return(handle.Node);
}
// lookup in operation cache.
NodeState target = FindNodeInCache(context, handle, cache);
if (target != null)
{
handle.Node = target;
handle.Validated = true;
return(handle.Node);
}
#region Task #A5 - Add Support for External Nodes
// checkf if the id actually referes to a valid node id.
target = ValidateExternalNode(context, handle);
if (target == null)
{
return(null);
}
#endregion
// put root into operation cache.
if (cache != null)
{
cache[handle.NodeId] = target;
}
handle.Node = target;
handle.Validated = true;
return(handle.Node);
}
/// <summary>
/// Saves a history continuation point.
/// </summary>
private byte[] SaveContinuationPoint(
ServerSystemContext context,
HistoryReadRequest request)
{
Session session = context.OperationContext.Session;
if (session == null)
{
return(null);
}
Guid id = Guid.NewGuid();
session.SaveHistoryContinuationPoint(id, request);
request.ContinuationPoint = id.ToByteArray();
return(request.ContinuationPoint);
}
public static void RegistPublishers(this
MachineState machineState,
ServerSystemContext systemContext)
{
//regist machine log publisher push.
var machineLogPublisher = new MachineLogPublisher();
machineLogPublisher.Regist(machineState, systemContext);
Publishers.Add(machineLogPublisher);
Logstash.Service.Logstash.Startup();
//regist machine performance publisher push.
var machinePerformancePublisher = new MachinePerformancePublisher();
machinePerformancePublisher.Regist(machineState, systemContext);
Publishers.Add(machinePerformancePublisher);
}
/// <summary>
/// Returns a unique handle for the node.
/// </summary>
protected override NodeHandle GetManagerHandle(ServerSystemContext context, NodeId nodeId, IDictionary <NodeId, NodeState> cache)
{
lock (Lock)
{
// quickly exclude nodes that are not in the namespace.
if (!IsNodeIdInNamespace(nodeId))
{
return(null);
}
// check for predefined nodes.
if (PredefinedNodes != null)
{
NodeState node = null;
if (PredefinedNodes.TryGetValue(nodeId, out node))
{
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = true;
handle.Node = node;
return(handle);
}
}
// parse the identifier.
DaParsedNodeId parsedNodeId = DaParsedNodeId.Parse(nodeId);
if (parsedNodeId != null)
{
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = false;
handle.Node = null;
handle.ParsedNodeId = parsedNodeId;
return(handle);
}
return(null);
}
}
