/// <summary>
/// Creates/updates a node from a ReferenceDescription.
/// </summary>
/// <param name="reference">The reference.</param>
/// <returns>Node</returns>
public INode Import(ReferenceDescription reference)
{
// find any existing node.
INode target = Find(reference.NodeId);
// create a new object.
if (target == null)
{
if (reference.NodeId.ServerIndex != 0)
{
RemoteNode node = new RemoteNode(this, reference.NodeId);
InternalAdd(node);
target = node;
}
else
{
Node node = new Node();
node.NodeId = ExpandedNodeId.ToNodeId(reference.NodeId, m_namespaceUris);
InternalAdd(node);
target = node;
}
}
// update local node attributes.
Node targetNode = target as Node;
if (targetNode != null)
{
targetNode.NodeClass = reference.NodeClass;
targetNode.BrowseName = reference.BrowseName;
targetNode.DisplayName = reference.DisplayName;
if (!NodeId.IsNull(reference.TypeDefinition))
{
targetNode.ReferenceTable.Add(ReferenceTypeIds.HasTypeDefinition, false, reference.TypeDefinition);
}
return(targetNode);
}
// update remote node attributes.
RemoteNode remoteNode = target as RemoteNode;
if (remoteNode != null)
{
remoteNode.NodeClass = reference.NodeClass;
remoteNode.BrowseName = reference.BrowseName;
remoteNode.DisplayName = reference.DisplayName;
remoteNode.TypeDefinitionId = reference.TypeDefinition;
return(remoteNode);
}
// should never get here.
return(null);
}
/// <summary>
/// Adds the remote node to the table.
/// </summary>
/// <param name="node">The node.</param>
private void InternalAdd(RemoteNode node)
{
if (node == null || node.NodeId == null)
{
return;
}
m_remoteNodes[node.NodeId] = node;
}
/// <summary>
/// Removes the remote node from the table.
/// </summary>
/// <param name="node">The node.</param>
private void InternalRemove(RemoteNode node)
{
if (node == null || node.NodeId == null)
{
return;
}
m_remoteNodes.Remove(node.NodeId);
}
private void HandleBlockHeaders(RemoteNode remoteNode, IImmutableList <BlockHeader> blockHeaders)
{
var handler = this.OnBlockHeaders;
if (handler != null)
{
handler(remoteNode, blockHeaders);
}
}
private void HandleBlock(RemoteNode remoteNode, Block block)
{
var handler = this.OnBlock;
if (handler != null)
{
handler(remoteNode, block);
}
}
/// <summary>
/// Add remote node
/// </summary>
/// <param name="nodeId"></param>
/// <param name="serviceUri"></param>
public void AddRemoteNode(string nodeId, Uri serviceUri)
{
if (!_nodes.Exists(e => e.Id == nodeId || e.ServiceUri == serviceUri))
{
var rpcClient = _rpcClientProvider.GetRpcClient(serviceUri);
var remoteNode = new RemoteNode(nodeId, serviceUri, rpcClient);
_nodes.Add(remoteNode);
Console.WriteLine($"Add remote node: nodeId={nodeId}, serviceUri={serviceUri}");
}
}
/// <summary>
/// Removes node from the table.
/// </summary>
/// <param name="nodeId">The node identifier.</param>
/// <returns>The result of removal.</returns>
public bool Remove(ExpandedNodeId nodeId)
{
// find the target.
INode source = Find(nodeId);
if (source == null)
{
return(false);
}
ILocalNode sourceNode = source as ILocalNode;
// can only directly remove local nodes.
if (sourceNode == null)
{
return(false);
}
// remove references.
foreach (IReference reference in sourceNode.References)
{
INode target = InternalFind(reference.TargetId);
if (target == null)
{
continue;
}
// remove remote node if nothing else references it.
RemoteNode remoteNode = target as RemoteNode;
if (remoteNode != null)
{
if (remoteNode.Release() == 0)
{
InternalRemove(remoteNode);
}
continue;
}
// remote inverse references.
ILocalNode targetNode = target as ILocalNode;
if (targetNode != null)
{
targetNode.References.Remove(reference.ReferenceTypeId, reference.IsInverse, sourceNode.NodeId);
}
}
InternalRemove(sourceNode);
return(true);
}
public async Task <(IRemoteNode, VersionPayload)> ConnectAsync(IPEndPoint endPoint, uint nonce, uint startHeight, CancellationToken token = default)
{
var pipelineSocket = provider.GetRequiredService <IPipelineSocket>();
var networkOptions = provider.GetRequiredService <IOptions <NetworkOptions> >();
var nodeOptions = provider.GetRequiredService <IOptions <NodeOptions> >();
var logger = provider.GetService <ILogger <RemoteNode> >();
var node = new RemoteNode(pipelineSocket, networkOptions, nodeOptions, logger);
var remoteVersion = await node.ConnectAsync(endPoint, nonce, startHeight, token);
return(node, remoteVersion);
}
private void WireNode(RemoteNode remoteNode)
{
remoteNode.Receiver.OnMessage += OnMessage;
remoteNode.Receiver.OnInventoryVectors += OnInventoryVectors;
remoteNode.Receiver.OnBlock += OnBlock;
remoteNode.Receiver.OnBlockHeader += OnBlockHeader;
remoteNode.Receiver.OnReceivedAddresses += OnReceivedAddresses;
remoteNode.OnGetBlocks += OnGetBlocks;
remoteNode.OnGetHeaders += OnGetHeaders;
remoteNode.OnPing += OnPing;
remoteNode.OnDisconnect += OnDisconnect;
}
private void UnwireNode(RemoteNode remoteNode)
{
remoteNode.Receiver.OnMessage -= OnMessage;
remoteNode.Receiver.OnInventoryVectors -= OnInventoryVectors;
remoteNode.Receiver.OnBlock -= OnBlock;
remoteNode.Receiver.OnBlockHeader -= OnBlockHeader;
remoteNode.Receiver.OnReceivedAddresses -= OnReceivedAddresses;
remoteNode.OnGetBlocks -= OnGetBlocks;
remoteNode.OnGetHeaders -= OnGetHeaders;
remoteNode.OnPing -= OnPing;
remoteNode.OnDisconnect -= OnDisconnect;
}
private void ChangePhase(ISystemContext context, NodeId phaseId)
{
m_currentPhase = phaseId;
m_rig.CurrentPhase.Value = phaseId;
m_rig.CurrentPhase.ClearChangeMasks(context, false);
try
{
// build the requests.
List <DataSourceClient.WriteRequest> requests = new List <DataSourceClient.WriteRequest>();
for (int ii = 0; ii < m_tools.Count; ii++)
{
NodeId lockId = m_tools[ii].GetLockForPhase(m_currentPhase);
if (NodeId.IsNull(lockId) || m_tools[ii].ActiveLockId == null)
{
continue;
}
m_tools[ii].ActiveLockId.Value = lockId.ToString();
RemoteNode remoteNode = null;
if (m_remoteNodes.TryGetValue(m_tools[ii].ActiveLockId.NodeId, out remoteNode))
{
DataSourceClient.WriteRequest request = new DataSourceClient.WriteRequest();
request.Index = 0;
request.RemoteId = remoteNode.RemoteId;
request.WriteValue = new WriteValue();
request.WriteValue.AttributeId = Attributes.Value;
request.WriteValue.Value.Value = lockId.ToString();
requests.Add(request);
}
}
// update the remote data source.
List <ServiceResult> results = m_source.Write(requests);
for (int ii = 0; ii < requests.Count; ii++)
{
if (ServiceResult.IsBad(results[ii]))
{
Utils.Trace("Update ActiveLockId failed: {0}", results[ii].ToString());
}
}
}
catch (Exception e)
{
Utils.Trace("Could not update ActiveLockIds: {0}", e.Message);
}
}
private void RemoteRenameBtn_Click(object sender, EventArgs e)
{
if (RemoteNode == null)
{
AddLog("未选中任何文件/文件夹");
return;
}
if (RemoteNode.Parent == null)
{
return;
}
RemoteNode.BeginEdit();
}
private void UnwireNode(RemoteNode remoteNode)
{
remoteNode.Receiver.OnMessage -= OnMessage;
remoteNode.Receiver.OnInventoryVectors -= OnInventoryVectors;
remoteNode.Receiver.OnBlock -= HandleBlock;
remoteNode.Receiver.OnBlockHeaders -= HandleBlockHeaders;
remoteNode.Receiver.OnTransaction -= OnTransaction;
remoteNode.Receiver.OnReceivedAddresses -= OnReceivedAddresses;
remoteNode.OnGetBlocks -= OnGetBlocks;
remoteNode.OnGetHeaders -= OnGetHeaders;
remoteNode.OnGetData -= OnGetData;
remoteNode.OnPing -= OnPing;
remoteNode.OnDisconnect -= OnDisconnect;
}
private void WireNode(RemoteNode remoteNode)
{
remoteNode.Receiver.OnMessage += OnMessage;
remoteNode.Receiver.OnInventoryVectors += OnInventoryVectors;
remoteNode.Receiver.OnBlock += HandleBlock;
remoteNode.Receiver.OnBlockHeaders += HandleBlockHeaders;
remoteNode.Receiver.OnTransaction += OnTransaction;
remoteNode.Receiver.OnReceivedAddresses += OnReceivedAddresses;
remoteNode.OnGetBlocks += OnGetBlocks;
remoteNode.OnGetHeaders += OnGetHeaders;
remoteNode.OnGetData += OnGetData;
remoteNode.OnPing += OnPing;
remoteNode.OnDisconnect += OnDisconnect;
}
private void OnGetBlocks(RemoteNode remoteNode, GetBlocksPayload payload)
{
var targetChainLocal = this.blockchainDaemon.TargetChain;
if (targetChainLocal == null)
{
return;
}
ChainedHeader matchingChainedHeader = null;
foreach (var blockHash in payload.BlockLocatorHashes)
{
ChainedHeader chainedHeader;
if (this.chainedHeaderCache.TryGetValue(blockHash, out chainedHeader))
{
if (chainedHeader.Height < targetChainLocal.Blocks.Count &&
chainedHeader.Hash == targetChainLocal.Blocks[chainedHeader.Height].Hash)
{
matchingChainedHeader = chainedHeader;
break;
}
}
}
if (matchingChainedHeader == null)
{
matchingChainedHeader = this.rules.GenesisChainedHeader;
}
var count = 0;
var limit = 500;
var invVectors = new InventoryVector[limit];
for (var i = matchingChainedHeader.Height; i < targetChainLocal.Blocks.Count && count <= limit; i++, count++)
{
var chainedHeader = targetChainLocal.Blocks[i];
invVectors[count] = new InventoryVector(InventoryVector.TYPE_MESSAGE_BLOCK, chainedHeader.Hash);
if (chainedHeader.Hash == payload.HashStop)
{
break;
}
}
Array.Resize(ref invVectors, count);
remoteNode.Sender.SendInventory(invVectors.ToImmutableArray()).Forget();
}
public Node GetNode(Uri uri)
{
string key = uri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped);
Node result;
if (_nodes.TryGetValue(key, out result))
return result;
ChunkWriter chunkWriter = GetWriter(uri);
result = new RemoteNode(new ShuntChannel(), chunkWriter, _fiberFactory, _scheduler, _serializer);
_nodes.Add(key, result);
return result;
}
private Task RequestTransaction(RemoteNode remoteNode, UInt256 txHash)
{
//TODO
//if (this.TransactionCache.ContainsKey(txHash))
// return null;
var now = DateTime.UtcNow;
var newRequestTime = now;
// check if transaction has already been requested
if (this.requestedTransactions.TryAdd(txHash, now))
{
var invVectors = ImmutableArray.Create <InventoryVector>(new InventoryVector(InventoryVector.TYPE_MESSAGE_TRANSACTION, txHash));
return(remoteNode.Sender.SendGetData(invVectors));
}
return(null);
}
private async Task ProcessRequestUpdates(JObject response, int rid)
{
var request = RequestManager.GetRequest(rid);
switch (request)
{
case ListRequest _:
var listRequest = (ListRequest)request;
var name = listRequest.Path.Split('/').Last();
var node = new RemoteNode(name, null, listRequest.Path);
node.FromSerialized(response["updates"].Value <JArray>());
await Task.Run(() => listRequest.Callback(new ListResponse(_link, rid, listRequest.Path, node)));
break;
case SetRequest _:
RequestManager.StopRequest(rid);
break;
case RemoveRequest _:
RequestManager.StopRequest(rid);
break;
case InvokeRequest _:
var invokeRequest = (InvokeRequest)request;
var path = invokeRequest.Path;
var columns = response.GetValue("columns") != null
? response["columns"].Value <JArray>()
: new JArray();
var updates = response.GetValue("updates") != null
? response["updates"].Value <JArray>()
: new JArray();
var meta = response.GetValue("meta") != null ? response["meta"].Value <JObject>() : new JObject();
var error = response.GetValue("error") != null ? response["error"].Value <JObject>() : new JObject();
await Task.Run(() =>
{
invokeRequest?.Callback(new InvokeResponse(_link, rid, path, columns, updates, meta,
error));
});
break;
}
}
void CreateLocalNode(Uri uri, UntypedChannel input)
{
string key = uri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped);
ChunkWriter chunkWriter = GetWriter(uri);
_localNode = new RemoteNode(input, chunkWriter, _fiberFactory, _scheduler, _serializer);
try
{
GetReader(uri, _localNode);
}
catch
{
_localNode.Dispose();
throw;
}
_nodes.Add(key, _localNode);
}
private void OnGetHeaders(RemoteNode remoteNode, GetBlocksPayload payload)
{
// if in comparison mode, synchronize all work before returning current headers
if (this.Type == LocalClientType.ComparisonToolTestNet)
{
this.blockchainDaemon.WaitForFullUpdate();
}
var currentBlockchainLocal = this.blockchainDaemon.CurrentBlockchain;
var blockHeaders = new List <BlockHeader>(currentBlockchainLocal.BlockCount);
foreach (var chainedBlock in currentBlockchainLocal.BlockList)
{
BlockHeader blockHeader;
if (this.blockchainDaemon.CacheContext.BlockHeaderCache.TryGetValue(chainedBlock.BlockHash, out blockHeader))
{
blockHeaders.Add(blockHeader);
}
else
{
Debugger.Break();
Debug.WriteLine("Couldn't generate getheaders response");
return;
}
}
var payloadStream = new MemoryStream();
using (var payloadWriter = new BinaryWriter(payloadStream))
{
payloadWriter.WriteVarInt((UInt64)blockHeaders.Count);
foreach (var blockHeader in blockHeaders)
{
NetworkEncoder.EncodeBlockHeader(payloadStream, blockHeader);
payloadWriter.WriteVarInt(0);
}
}
remoteNode.Sender.SendMessageAsync(Messaging.ConstructMessage("headers", payloadStream.ToArray())).Wait();
}
/// <summary>
/// Finds the specified node. Returns null if the node does node exist.
/// </summary>
/// <param name="nodeId">The node identifier.</param>
/// <returns></returns>
private INode InternalFind(ExpandedNodeId nodeId)
{
if (nodeId == null)
{
return(null);
}
// check for remote node.
if (nodeId.ServerIndex != 0)
{
RemoteNode remoteNode = null;
if (m_remoteNodes.TryGetValue(nodeId, out remoteNode))
{
return(remoteNode);
}
return(null);
}
// convert to locale node id.
NodeId localId = ExpandedNodeId.ToNodeId(nodeId, m_namespaceUris);
if (localId == null)
{
return(null);
}
ILocalNode node = null;
if (m_localNodes.TryGetValue(localId, out node))
{
return(node);
}
// node not found.
return(null);
}
private void setSockOpts()
{
m_Transport.NoDelay = RemoteNode.TcpNoDelay;
if (RemoteNode.TcpRcvBufSize > 0)
{
m_Transport.ReceiveBufferSize = RemoteNode.TcpRcvBufSize;
}
if (RemoteNode.TcpSndBufSize > 0)
{
m_Transport.SendBufferSize = RemoteNode.TcpSndBufSize;
}
// Use keepalive timer
m_Transport.SetSocketOption(
System.Net.Sockets.SocketOptionLevel.Socket,
System.Net.Sockets.SocketOptionName.KeepAlive, RemoteNode.TcpKeepAlive);
// Close socket without waiting for it to deliver all data
m_Transport.SetSocketOption(
System.Net.Sockets.SocketOptionLevel.Socket,
System.Net.Sockets.SocketOptionName.DontLinger, !RemoteNode.TcpLinger);
//set SSH params
RemoteNode.AppendSSHParamsToTransport(m_Transport);
}
private void OnGetData(RemoteNode remoteNode, InventoryPayload payload)
{
foreach (var invVector in payload.InventoryVectors)
{
switch (invVector.Type)
{
case InventoryVector.TYPE_MESSAGE_BLOCK:
Block block;
if (this.blockCache.TryGetValue(invVector.Hash, out block))
{
//remoteNode.Sender.SendBlock(block).Forget();
}
break;
case InventoryVector.TYPE_MESSAGE_TRANSACTION:
Transaction transaction;
if (this.transactionCache.TryGetValue(invVector.Hash, out transaction))
{
remoteNode.Sender.SendTransaction(transaction).Forget();
}
break;
}
}
}
private Task RequestBlock(RemoteNode remoteNode, UInt256 blockHash)
{
if (this.blockchainDaemon.CacheContext.BlockCache.ContainsKey(blockHash))
{
return(null);
}
var now = DateTime.UtcNow;
var newRequestTime = Tuple.Create(now, (DateTime?)null);
// check if block has already been requested
if (this.requestedBlockTimes.TryAdd(blockHash, newRequestTime))
{
this.requestedBlocks.TryAdd(blockHash);
var invVectors = ImmutableArray.Create <InventoryVector>(new InventoryVector(InventoryVector.TYPE_MESSAGE_BLOCK, blockHash));
return(remoteNode.Sender.SendGetData(invVectors));
}
else
{
// if block has already been requested, check if the request is old enough to send again
Tuple <DateTime, DateTime?> lastRequestTime;
if (this.requestedBlockTimes.TryGetValue(blockHash, out lastRequestTime))
{
if ((now - lastRequestTime.Item1) > TimeSpan.FromSeconds(15))
{
this.requestedBlocks.TryAdd(blockHash);
this.requestedBlockTimes.AddOrUpdate(blockHash, newRequestTime, (existingKey, existingValue) => newRequestTime);
var invVectors = ImmutableArray.Create <InventoryVector>(new InventoryVector(InventoryVector.TYPE_MESSAGE_BLOCK, blockHash));
return(remoteNode.Sender.SendGetData(invVectors));
}
}
}
return(null);
}
//------------------------------------------------------------------------------------------------------------------------
private void RemoteNode_OnChannelOpen(RemoteNode RemoteNode)
{
BrotherNodes.Add(RemoteNode.RemoteNodeKey, RemoteNode);
//raise event
if (OnRemoteNodeAssociation != null)
Task.Run(() => { try { OnRemoteNodeAssociation?.Invoke(RemoteNode); } catch (Exception ex) { DebugEx.Assert(ex, "Unhandled exception"); } });
}
void GetReader(Uri uri, RemoteNode node)
{
if ("pgm".Equals(uri.Scheme, StringComparison.InvariantCultureIgnoreCase)
|| "rm".Equals(uri.Scheme, StringComparison.InvariantCultureIgnoreCase))
{
var reader = new ReliableMulticastListener(uri, node);
reader.Start();
node.AddDisposable(reader);
return;
}
if ("loopback".Equals(uri.Scheme, StringComparison.InvariantCultureIgnoreCase))
{
var loopback = (LoopbackReaderWriter)GetWriter(uri);
loopback.Output = node;
return;
}
throw new StactException("Unsupported local address: " + uri);
}
/// <summary>
/// Adds a set of nodes to the table.
/// </summary>
/// <param name="nodeSet">The node set.</param>
/// <param name="externalReferences">The external references.</param>
/// <returns></returns>
public List <Node> Import(NodeSet nodeSet, IDictionary <NodeId, IList <IReference> > externalReferences)
{
List <Node> importedNodes = new List <Node>();
if (nodeSet == null)
{
return(importedNodes);
}
// add the nodes.
foreach (Node nodeToImport in nodeSet.Nodes)
{
// ignore empty nodes.
if (nodeToImport == null || NodeId.IsNull(nodeToImport.NodeId))
{
continue;
}
Node node = nodeSet.Copy(nodeToImport, m_namespaceUris, m_serverUris);
// assign a browse name.
if (QualifiedName.IsNull(node.BrowseName))
{
node.BrowseName = new QualifiedName(node.NodeId.ToString(), 1);
}
// assign a display name.
if (LocalizedText.IsNullOrEmpty(node.DisplayName))
{
node.DisplayName = new LocalizedText(node.BrowseName.Name);
}
// index references (the node ids in the references were translated by the Copy() call above).
foreach (ReferenceNode reference in node.References)
{
// ignore invalid references.
if (NodeId.IsNull(reference.ReferenceTypeId) || NodeId.IsNull(reference.TargetId))
{
continue;
}
// ignore missing targets.
ExpandedNodeId targetId = reference.TargetId;
if (NodeId.IsNull(targetId))
{
continue;
}
// index reference.
node.ReferenceTable.Add(reference.ReferenceTypeId, reference.IsInverse, targetId);
// see if a remote node needs to be created.
if (targetId.ServerIndex != 0)
{
RemoteNode remoteNode = Find(targetId) as RemoteNode;
if (remoteNode == null)
{
remoteNode = new RemoteNode(this, targetId);
InternalAdd(remoteNode);
}
remoteNode.AddRef();
}
}
// clear imported references.
node.References.Clear();
// add the node.
InternalAdd(node);
importedNodes.Add(node);
}
// import the nodes.
foreach (Node node in importedNodes)
{
// ignore invalid nodes.
if (node == null || NodeId.IsNull(node.NodeId))
{
continue;
}
// add reverse references.
foreach (IReference reference in node.ReferenceTable)
{
Node targetNode = Find(reference.TargetId) as Node;
if (targetNode == null)
{
if (reference.TargetId.ServerIndex != 0)
{
continue;
}
// return the reverse reference to a node outside the table.
if (externalReferences != null)
{
NodeId targetId = ExpandedNodeId.ToNodeId(reference.TargetId, m_namespaceUris);
if (targetId == null)
{
continue;
}
IList <IReference> referenceList = null;
if (!externalReferences.TryGetValue(targetId, out referenceList))
{
externalReferences[targetId] = referenceList = new List <IReference>();
}
ReferenceNode reverseReference = new ReferenceNode();
reverseReference.ReferenceTypeId = reference.ReferenceTypeId;
reverseReference.IsInverse = !reference.IsInverse;
reverseReference.TargetId = node.NodeId;
referenceList.Add(reverseReference);
}
continue;
}
// type definition and modelling rule references are one way.
if (reference.ReferenceTypeId != ReferenceTypeIds.HasTypeDefinition && reference.ReferenceTypeId != ReferenceTypeIds.HasModellingRule)
{
targetNode.ReferenceTable.Add(reference.ReferenceTypeId, !reference.IsInverse, node.NodeId);
}
}
// see if it is a type.
if (m_typeTree != null)
{
m_typeTree.Add(node);
}
}
return(importedNodes);
}
/// <summary>
/// Adds a node to the table (takes ownership of the object passed in).
/// </summary>
/// <param name="node">The node.</param>
/// <remarks>
/// Any existing node is removed.
/// </remarks>
public void Attach(ILocalNode node)
{
// remove duplicates.
if (Exists(node.NodeId))
{
Remove(node.NodeId);
}
// check if importing a node from a XML source (must copy references from References array to ReferenceTable).
Node serializedNode = node as Node;
if (serializedNode != null && serializedNode.References.Count > 0 && serializedNode.ReferenceTable.Count == 0)
{
// index references.
foreach (ReferenceNode reference in node.References)
{
// ignore invalid references.
if (NodeId.IsNull(reference.ReferenceTypeId) || NodeId.IsNull(reference.TargetId))
{
continue;
}
node.References.Add(reference.ReferenceTypeId, reference.IsInverse, reference.TargetId);
// see if a remote node needs to be created.
if (reference.TargetId.ServerIndex != 0)
{
RemoteNode remoteNode = Find(reference.TargetId) as RemoteNode;
if (remoteNode == null)
{
remoteNode = new RemoteNode(this, reference.TargetId);
InternalAdd(remoteNode);
}
remoteNode.AddRef();
}
}
// clear unindexed reference list.
node.References.Clear();
}
// add the node to the table.
InternalAdd(node);
// add reverse references.
foreach (IReference reference in node.References)
{
ILocalNode targetNode = Find(reference.TargetId) as ILocalNode;
if (targetNode == null)
{
continue;
}
// type definition and modelling rule references are one way.
if (reference.ReferenceTypeId != ReferenceTypeIds.HasTypeDefinition && reference.ReferenceTypeId != ReferenceTypeIds.HasModellingRule)
{
targetNode.References.Add(reference.ReferenceTypeId, !reference.IsInverse, node.NodeId);
}
}
// see if it is a type.
if (m_typeTree != null)
{
m_typeTree.Add(node);
}
}
void LoadDataSourceSources(
ISystemContext context,
ToolState tool,
DsatsDemo.DataSource.DataSource datasource,
DsatsDemo.DataSource.DeclarationType declaration)
{
if (declaration == null || declaration.Sources == null)
{
return;
}
// need to ensure the server's tables are not updated when loading this file.
ServerSystemContext context2 = new ServerSystemContext(this.Server);
context2.NamespaceUris = new NamespaceTable();
context2.ServerUris = new StringTable();
context2.NodeIdFactory = this;
context2.NamespaceUris.Append(context.ServerUris.GetString(0));
context2.ServerUris.Append(context.ServerUris.GetString(0));
foreach (DsatsDemo.DataSource.SourceType source in declaration.Sources)
{
BaseInstanceState child = tool.FindChildBySymbolicName(context, source.Path);
if (child == null)
{
continue;
}
if (source.DefaultValue != null)
{
BaseVariableState variable = child as BaseVariableState;
if (variable != null)
{
try
{
Variant value = datasource.Read(context, source.DefaultValue);
variable.WrappedValue = value;
}
catch (Exception)
{
Utils.Trace("Could not read Variant in file. {0}", source.DefaultValue.InnerXml);
}
}
}
if (source.RemoteId != null)
{
ExpandedNodeId remoteId = datasource.ReadExpandedNodeId(context2, source.RemoteId);
if (m_remoteNodes == null)
{
m_remoteNodes = new NodeIdDictionary<RemoteNode>();
}
RemoteNode remoteNode = new RemoteNode();
remoteNode.Tool = tool;
remoteNode.ServerUrl = context2.ServerUris.GetString(remoteId.ServerIndex);
remoteNode.LocalNode = child;
remoteNode.RemoteId = remoteId;
m_remoteNodes.Add(child.NodeId, remoteNode);
}
}
}
private void OnPing(RemoteNode remoteNode, ImmutableArray <byte> payload)
{
remoteNode.Sender.SendMessageAsync(Messaging.ConstructMessage("pong", payload.ToArray())).Wait();
}
//------------------------------------------------------------------------------------------------------------------------
private void RemoteNode_OnVBMReceived(RemoteNode RemoteNode, VirtualBlockEventMsg msg)
{
OnVBMReceived?.Invoke(RemoteNode.RemoteNodeKey, msg);
}
/// <summary>
/// Checks if the current user has write access to the remote node.
/// </summary>
private bool CheckWriteAccess(ServerSystemContext context, RemoteNode remoteNode)
{
// check if session has admin access.
//if (CheckAdminAccess(context))
//{
// return true;
//}
// check if the session holds any locks.
List<NodeId> locks = null;
if (!m_sessionLocks.TryGetValue(context.SessionId, out locks))
{
return false;
}
// check if the tool has locks for the current phase.
NodeId lockId = remoteNode.Tool.GetLockForPhase(m_currentPhase);
if (lockId == null)
{
return false;
}
// check if a lock is held.
if (SessionHasLock(context, lockId))
{
return true;
}
return false;
}
private void OnDisconnect(RemoteNode remoteNode)
{
DisconnectPeer(remoteNode.RemoteEndPoint, null);
}
private void OnGetHeaders(RemoteNode remoteNode, GetBlocksPayload payload)
{
if (this.Type == RulesEnum.ComparisonToolTestNet)
{
this.blockchainDaemon.ForceWorkAndWait();
}
var targetChainLocal = this.blockchainDaemon.TargetChain;
if (targetChainLocal == null)
{
return;
}
ChainedHeader matchingChainedHeader = null;
foreach (var blockHash in payload.BlockLocatorHashes)
{
ChainedHeader chainedHeader;
if (this.chainedHeaderCache.TryGetValue(blockHash, out chainedHeader))
{
if (chainedHeader.Height < targetChainLocal.Blocks.Count &&
chainedHeader.Hash == targetChainLocal.Blocks[chainedHeader.Height].Hash)
{
matchingChainedHeader = chainedHeader;
break;
}
}
}
if (matchingChainedHeader == null)
{
matchingChainedHeader = this.rules.GenesisChainedHeader;
}
var count = 0;
var limit = 500;
var blockHeaders = new BlockHeader[limit];
for (var i = matchingChainedHeader.Height; i < targetChainLocal.Blocks.Count && count <= limit; i++, count++)
{
var chainedHeader = targetChainLocal.Blocks[i];
BlockHeader blockHeader;
if (this.blockHeaderCache.TryGetValue(targetChainLocal.Blocks[i].Hash, out blockHeader))
{
blockHeaders[count] = blockHeader;
}
else
{
break;
}
if (chainedHeader.Hash == payload.HashStop)
{
break;
}
}
Array.Resize(ref blockHeaders, count);
remoteNode.Sender.SendHeaders(blockHeaders.ToImmutableArray()).Forget();
}
//------------------------------------------------------------------------------------------------------------------------
void hookNewRemoteNodeEvents(RemoteNode remInfo)
{
remInfo.OnChannelOpen += RemoteNode_OnChannelOpen;
remInfo.OnChannelClose += RemoteNode_OnChannelClose;
remInfo.OnVBMReceived += RemoteNode_OnVBMReceived;
}
//------------------------------------------------------------------------------------------------------------------------
private void _YPServer_OnNewChannel(Server Server, YPChannel.Channel Channel)
{
var id = new LANDiscoverer.RemoteEndpointID()
{
IPAddress = Channel.RemoteIdentifier,
ID = 0,
};
lock (RemoteNodes)
{
//get or create entry for remote node
var remInfo = RemoteNodes.TryGetOrDefault(id);
if (remInfo == null)
{
//create entry for remote node
remInfo = new RemoteNode(Node, this)
{
RemoteEndpointID = id,
DiscoveryMessage = null,
RemoteNodeKey = default(NodeKey),
};
//add to discovered remote nodes
RemoteNodes.ForceAdd(id, remInfo);
}
//hookevents
hookNewRemoteNodeEvents(remInfo);
//setup channel
remInfo.SetupChannel(Channel);
}
}
//------------------------------------------------------------------------------------------------------------------------
private void Discoverer_OnEndpointMsgRx(YPChannel.Transport.Sockets.LANDiscoverer.RemoteEndpointInfo endpoint, YPChannel.Transport.Sockets.IDiscoveryMessageBase __msg)
{
try
{
//get valid msg
var msg = __msg as DiscoveryMessage;
if (msg == null)
return;
//create remotenodekey
var rem_nodekey = API.Plegma.NodeKey.FromBytes(msg.NodeKey, 0);
if (rem_nodekey.IsInvalid)
return;
//examine existing association
lock (RemoteNodes)
{
var remInfo = RemoteNodes.TryGetOrDefault(endpoint.ID);
if (remInfo == null)
{
//inform
DebugEx.TraceLog($"NodeDiscoverer : Discovered new node. (ip:{endpoint.IPAddress} nodekey:{rem_nodekey})");
//create entry for remote node
remInfo = new RemoteNode(Node, this)
{
RemoteEndpointID = endpoint.ID,
DiscoveryMessage = msg,
RemoteNodeKey = rem_nodekey,
};
//add to discovered remote nodes
RemoteNodes.Add(endpoint.ID, remInfo);
//hookevents
hookNewRemoteNodeEvents(remInfo);
//Start a connection attempt
remInfo.StartConnectionTask();
//raise event
if (OnRemoteNodeDiscovery != null)
Task.Run(() => { try { OnRemoteNodeDiscovery?.Invoke(remInfo); } catch (Exception ex) { DebugEx.Assert(ex, "Unhandled exception"); } });
}
else
{
//start remote node connection
if (!remInfo.IsDisposed &&
(remInfo.ClientChannel == null || (remInfo.ClientChannel.State == YPChannel.ChannelStates.Closed && !remInfo.ConnectionTaskRunning)))
remInfo.StartConnectionTask();
}
}
}
catch (Exception ex) { DebugEx.TraceError(ex, "DiscoveryTaskEntryPoint error"); }
}
public byte[] GetBytes()
{
byte[] RecordBytes = new byte[41];
byte[] RemoteNodeEBCDIC;
byte[] LocalNodeEBCDIC;
byte[] BufferSizeBytes;
RemoteNodeEBCDIC = EbcdicEncoding.Convert(Encoding.ASCII, EbcdicEncoding.GetEncoding("EBCDIC-US"), Encoding.ASCII.GetBytes(RemoteNode.PadRight(8, ' ')));
LocalNodeEBCDIC = EbcdicEncoding.Convert(Encoding.ASCII, EbcdicEncoding.GetEncoding("EBCDIC-US"), Encoding.ASCII.GetBytes(LocalNode.PadRight(8, ' ')));
BufferSizeBytes = BitConverter.GetBytes(BufferSize);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(BufferSizeBytes);
}
RecordBytes[0] = 0x29;
Array.Copy(LocalNodeEBCDIC, 0, RecordBytes, 1, 8);
Array.Copy(RemoteNodeEBCDIC, 0, RecordBytes, 9, 8);
RecordBytes[18] = 0x64;
Array.Copy(BufferSizeBytes, 0, RecordBytes, 19, 2);
RecordBytes[38] = 0x15;
return(RecordBytes);
}
private async Task <bool> ConnectAndHandshake(RemoteNode remoteNode, bool isIncoming)
{
// wire node
WireNode(remoteNode);
// connect
await remoteNode.ConnectAsync();
if (remoteNode.IsConnected)
{
//TODO
RemoteNode ignore;
this.pendingPeers.TryRemove(remoteNode.RemoteEndPoint, out ignore);
this.connectedPeers.TryAdd(remoteNode.RemoteEndPoint, remoteNode);
// setup task to wait for verack
var verAckTask = remoteNode.Receiver.WaitForMessage(x => x.Command == "verack", HANDSHAKE_TIMEOUT_MS);
// setup task to wait for version
var versionTask = remoteNode.Receiver.WaitForMessage(x => x.Command == "version", HANDSHAKE_TIMEOUT_MS);
// start listening for messages after tasks have been setup
remoteNode.Receiver.Listen();
// send our local version
var nodeId = random.NextUInt64(); //TODO should be generated and verified on version message
var currentHeight = this.blockchainDaemon.CurrentChain.Height;
await remoteNode.Sender.SendVersion(Messaging.GetExternalIPEndPoint(), remoteNode.RemoteEndPoint, nodeId, (UInt32)currentHeight);
// wait for our local version to be acknowledged by the remote peer
// wait for remote peer to send their version
await Task.WhenAll(verAckTask, versionTask);
//TODO shouldn't have to decode again
var versionMessage = versionTask.Result;
var versionPayload = NodeEncoder.DecodeVersionPayload(versionMessage.Payload.ToArray(), versionMessage.Payload.Count);
var remoteAddressWithTime = new NetworkAddressWithTime
(
Time: DateTime.UtcNow.ToUnixTime(),
NetworkAddress: new NetworkAddress
(
Services: versionPayload.LocalAddress.Services,
IPv6Address: versionPayload.LocalAddress.IPv6Address,
Port: versionPayload.LocalAddress.Port
)
);
if (!isIncoming)
{
this.networkPeerCache[remoteAddressWithTime.GetKey()] = remoteAddressWithTime;
}
// acknowledge their version
await remoteNode.Sender.SendVersionAcknowledge();
this.headersRequestWorker.NotifyWork();
this.blockRequestWorker.NotifyWork();
this.statsWorker.NotifyWork();
return(true);
}
else
{
return(false);
}
}
//------------------------------------------------------------------------------------------------------------------------
private void RemoteNode_OnChannelClose(RemoteNode RemoteNode)
{
if (!RemoteNode.IsConnected)
BrotherNodes.Remove(RemoteNode.RemoteNodeKey);
}
private async Task PeerStartup(RemoteNode remoteNode)
{
await remoteNode.Sender.RequestKnownAddressesAsync();
}
