public static async void checkTemp(XBeeController controller, NodeData node, PictureBox pic, int index, int status, int tempmax)
{
var address = node.getAddress(index);
LongAddress x = new LongAddress(Convert.ToUInt32(address.Substring(0, 8), 16), Convert.ToUInt32(address.Substring(8, 8), 16));
NodeAddress a = new NodeAddress(x);
//NodeAddress x = new NodeAddress(serialNumber1);
var remoteNode = await controller.GetRemoteAsync(a);
var serialNumber2 = await remoteNode.GetTemperature();
/*if (!checkOver9(serialNumber2.ToString()))
* {*/
if (Convert.ToInt32(serialNumber2.ToString(), 16) >= tempmax)
{
node.statusUpdate(index, status);
}
/*}
* else
* {
* node.statusUpdate(index, 3);
* }*/
pic.Invalidate();
//MessageBox.Show(x.ToString());
}
public void Chart_ResetComboBoxAccount()
{
comboBoxGraphAccount.Items.Clear();
string selectedCat = (string)comboBoxGraphCategory.SelectedItem;
string selectedInstit = (string)comboBoxGraphInstitution.SelectedItem;
bool Activate = selectedInstit != ChartAllInstitutions &&
selectedInstit != ChartNone;
if (Activate)
{
comboBoxGraphAccount.Items.Add(ChartAllAccounts);
NodeAddress na = new NodeAddress(NodeType.Institution,
selectedCat + NodeAddress.Separator + selectedInstit);
var subNodes = Data.Map.GetSubNodes(na);
foreach (var item in subNodes)
{
comboBoxGraphAccount.Items.Add(item);
}
comboBoxGraphAccount.SelectedItem = ChartAllAccounts;
}
else
{
comboBoxGraphAccount.Items.Add(ChartNone);
comboBoxGraphAccount.SelectedItem = ChartNone;
}
}
public async Task TestThatThreeNodesRemainSynchronisedAfter10AddsToAllNodes()
{
_n1Address = new NodeAddress("127.0.0.1", 6131);
_n2Address = new NodeAddress("127.0.0.1", 6132);
_n3Address = new NodeAddress("127.0.0.1", 6133);
_addresses = new List <NodeAddress> {
_n1Address, _n2Address, _n3Address
};
_node1 = new Node(_n1Address, _addresses);
_node2 = new Node(_n2Address, _addresses);
_node3 = new Node(_n3Address, _addresses);
_state1.WireUpNode(_node1);
_state2.WireUpNode(_node2);
_state3.WireUpNode(_node3);
_state1.LocalAdd("someData1");
_state2.LocalAdd("someData2");
_state3.LocalAdd("someData3");
_state1.LocalAdd("someData4");
_state2.LocalAdd("someData5");
_state3.LocalAdd("someData6");
_state1.LocalAdd("someData7");
_state2.LocalAdd("someData8");
_state3.LocalAdd("someData9");
_state1.LocalAdd("someData10");
Assert.That(_state1.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo("someData10"));
Assert.That(_state2.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo("someData10"));
Assert.That(_state3.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo("someData10"));
}
public async Task TestThatThreeNodesRemainSynchronisedAfter3KAddsToAllNodesInSequence()
{
_n1Address = new NodeAddress("127.0.0.1", 6141);
_n2Address = new NodeAddress("127.0.0.1", 6142);
_n3Address = new NodeAddress("127.0.0.1", 6143);
_addresses = new List <NodeAddress> {
_n1Address, _n2Address, _n3Address
};
_node1 = new Node(_n1Address, _addresses);
_node2 = new Node(_n2Address, _addresses);
_node3 = new Node(_n3Address, _addresses);
_state1.WireUpNode(_node1);
_state2.WireUpNode(_node2);
_state3.WireUpNode(_node3);
var dataCounter = 0;
for (var i = 0; i < 1000; i++)
{
_state1.LocalAdd($"someData{dataCounter++}");
_state2.LocalAdd($"someData{dataCounter++}");
_state3.LocalAdd($"someData{dataCounter++}");
}
var expected = $"someData{dataCounter - 1}";
Assert.That(_state1.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo(expected));
Assert.That(_state2.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo(expected));
Assert.That(_state3.GetLatestBlock().Transaction.GetData <string>(), Is.EqualTo(expected));
}
public bool ChangeName(string before, string after, NodeAddress nodeTag)
{
bool test = false;
var data = GetData();
if (nodeTag.NodeType == NodeType.Category)
{
if (!data.ContainsKey(after))
{
Category cat = GetCategory(before);
cat.CategoryName = after;
//_Data[after] = _Data[before];
//_Data.Remove(before);
//_Data[after].CategoryName = after;
test = true;
}
}
else
{
test = GetCategory(nodeTag.Address[0]).ChangeName(before, after, nodeTag);
}
if (test)
{
_Map.ChangeName(nodeTag, after);
}
return(test);
}
internal XBeeSeries1(XBeeControllerBase controller,
HardwareVersion hardwareVersion = HardwareVersion.XBeeSeries1,
ushort firmwareVersion = 0,
XBeeProtocol protocol = XBeeProtocol.Unknown,
NodeAddress address = null) : base(controller, hardwareVersion, firmwareVersion, protocol, address)
{
}
internal XBeePro900HP(XBeeControllerBase controller,
HardwareVersion hardwareVersion,
ushort firmwareVersion,
XBeeProtocol protocol,
NodeAddress address = null) : base(controller, hardwareVersion, firmwareVersion, protocol, address)
{
}
public NodeAddress DeleteItem(NodeAddress na)
{
NodeAddress res;
if (na.NodeType == NodeType.Category)
{
if (_Data.Count > 1)
{
_Data.Remove(GetCategory(na.Address[0]));
res = _Map.DeleteNode(na);
}
else
{
res = na;
}
}
else
{
GetElement(na.GetParent()).Delete(na.GetLast());
res = _Map.DeleteNode(na);
}
if (res.IsEqual(na))
{
MessageBox.Show($"You cannot delete {na.GetLast()} as it is the last element of [{na.GetParent().GetLabelText()}]!");
}
return(res);
}
public override int ReadPayload(MemoryStream stream, int length)
{
//Debug.Assert(length == NodeAddress.LEN + sizeof(short), "G2PacketD : supposed to read " + (NodeAddress.LEN + sizeof(short)) + " but has to read " + length);
Node = NodeAddress.ReadNodeAddress(stream);
length = (short)BinaryUtils.getVariableIntLE(stream, 2);
return(NodeAddress.LEN + 2);
}
internal void FillNodeAddress()
{
na = new NodeAddress()
{
NodeAddressId = Handshake.NodeListeningPort, NodeUId = Handshake.NodeUID, EndPointSID = this.EndPointSID
};
}
public void SendToAll(eRaftSignalType signalType, byte[] data, NodeAddress senderNodeAddress, string entityName, bool highPriority = false)
{
try
{
List <TcpPeer> peers = null;
_sync.EnterReadLock();
try
{
peers = Peers.Values.ToList();
}
catch (Exception ex)
{
//throw;
}
finally
{
_sync.ExitReadLock();
}
foreach (var peer in peers)
{
peer.Write(cSprot1Parser.GetSprot1Codec(new byte[] { 00, 02 },
(
new TcpMsgRaft()
{
EntityName = entityName, RaftSignalType = signalType, Data = data
}
).SerializeBiser()), highPriority);
}
}
catch (Exception ex)
{
}
}
public G2PacketS(Header h)
: base(h)
{
this.type = G2PacketType.S;
Node = null;
Timestamp = -1;
}
/// <summary>
/// Create a node.
/// </summary>
/// <param name="address">The address of the node or null for the controller node.</param>
/// <param name="autodetectProtocol">If true query node for hardware version. Otherwise assume controller version.</param>
/// <returns>The specified node.</returns>
public async Task <XBeeNode> GetNodeAsync(NodeAddress address = null, bool autodetectProtocol = true)
{
await InitializeAsync().ConfigureAwait(false);
if (address == null)
{
return(Local);
}
HardwareVersion hardwareVersion;
ushort firmwareVersion;
if (autodetectProtocol)
{
hardwareVersion = await
TaskExtensions.Retry(async() => await GetHardwareVersionAsync(address), TimeSpan.FromSeconds(5),
typeof(TimeoutException), typeof(AtCommandException)).ConfigureAwait(false);
firmwareVersion = await
TaskExtensions.Retry(async() => await GetFirmwareVersionAsync(address), TimeSpan.FromSeconds(5),
typeof(TimeoutException), typeof(AtCommandException)).ConfigureAwait(false);
}
else
{
hardwareVersion = Local.HardwareVersion;
firmwareVersion = Local.FirmwareVersion;
}
return(CreateNode(hardwareVersion, firmwareVersion, address));
}
private async Task OnNodeDiscovered(AtCommandResponseFrame frame, CancellationToken cancellationToken)
{
var discoveryData = (NetworkDiscoveryResponseData)frame.Content.Data;
if (NodeDiscovered == null || discoveryData?.LongAddress == null || discoveryData.IsCoordinator)
{
return;
}
var address = new NodeAddress(discoveryData.LongAddress, discoveryData.ShortAddress);
// XBees have trouble recovering from discovery
await Task.Delay(1000, cancellationToken);
try
{
var node = await GetNodeAsync(address);
var signalStrength = discoveryData.ReceivedSignalStrengthIndicator?.SignalStrength;
NodeDiscovered?.Invoke(this,
new NodeDiscoveredEventArgs(discoveryData.Name, signalStrength,
node));
}
catch (TimeoutException)
{
/* if we timeout getting the remote node info, no need to bubble up.
* We just won't include the node in discovery */
}
}
private void CreateRemoteNode()
{
if (NodeAddressNumber >= RemoteAddressesList.Count)
{
throw new Exception("Node number is not correct, ");
}
NodeAddress = RemoteAddressesList[this.NodeAddressNumber];
if (NodeAddressNumber == 0)
{
MainNode = true;
}
WorkingRemoteServersCount = RemoteAddressesList.Count;
RemoteAddressesList.RemoveAt(NodeAddressNumber);
NodePort = NodeAddress.Split(new[] { ":" }, StringSplitOptions.None)[1];
foreach (var remoteServer in RemoteAddressesList)
{
var remotePushSocket = new PushSocket();
RemoteServerSockets[remoteServer] = remotePushSocket;
remotePushSocket.Connect("tcp://" + remoteServer);
}
}
/// <summary>Starts the WCF host.</summary>
/// <exception cref="InvalidOperationException">Occurs if you try to start the host when it is already running.</exception>
public void Start()
{
if (IsStarted())
{
throw new InvalidOperationException("Service is already running. Use Stop first.");
}
Contract.EndContractBlock();
try
{
StartService();
}
catch (Exception)
{
if ((StartupPolicy & StartupPolicy.FindNewAddressIfAlreadyInUse) == StartupPolicy.FindNewAddressIfAlreadyInUse)
{
localAddress = GetDefaultNode();
ResetLocal();
StartService();
}
else
{
throw;
}
}
}
internal async void TreeView_AfterLabelEdit(NodeLabelEditEventArgs e)
{
string before = e.Node.Text;
string after = e.Label;
await Task.Run(() =>
{
bool test = false;
if (after != null && after != "")
{
NodeAddress na = (NodeAddress)e.Node.Tag;
if (_ad.ChangeName(before, after, na))
{
na.ChangeAddress(after);
_view.ChangeActive(na);
test = true;
}
}
else
{
e.CancelEdit = true;
}
_view.SetUpTree(_ad.Map);
if (!test)
{
MessageBox.Show($"Unable to give the element [{before}] the name [{after}]");
}
});
}
/// <summary>Initializes a new instance of the <see cref="InProcessProxyNode"/> class.</summary>
/// <param name="address">The address.</param>
/// <param name="network">The network.</param>
internal InProcessProxyNode(NodeAddress address, InProcessNetwork network)
: base(address, network)
{
this.network = network;
Id = Guid.NewGuid();
}
private void RegisterIpAddresses(int nodeId, NodeViewModel node)
{
if (node.Ips != null)
{
foreach (var ip in node.Ips)
{
var newAddress = new NodeAddress
{
Ip = ip,
Port = node.Port,
NodeId = nodeId,
Type = Enum.Parse <NodeAddressType>(node.Type)
};
this.db.NodeAddresses.Add(newAddress);
this.db.SaveChanges();
}
}
else if (node.Ip != null)
{
var newAddress = new NodeAddress
{
Ip = node.Ip,
Port = node.Port,
NodeId = nodeId,
Type = Enum.Parse <NodeAddressType>(node.Type)
};
this.db.NodeAddresses.Add(newAddress);
this.db.SaveChanges();
}
}
public BlockchainDBRepository(
ILogger logger,
IAggregateState <ItemMetadata> aggregateState,
IOptions <NodeAppSettingsOptions> nodeAppSettingsOptions,
IOptions <NodeP2PSettingsOptions> nodeP2POptions,
IAzureBlobStore azureBlobStore
)
{
_logger = logger;
_nodeAppSettingsOptions = nodeAppSettingsOptions.Value;
_aggregateState = aggregateState;
_aggregateState.PersistChain = true;
_azureBlobStore = azureBlobStore;
_azureBlobStore.Connect();
var nodeAddress = new NodeAddress("127.0.0.1", nodeP2POptions.Value.Port);
var addressList = new List <NodeAddress>();
_p2PNode = new Node(nodeAddress, addressList);
// wire up P2P behaviours
_aggregateState.WireUpNode(_p2PNode);
// setup indices
_aggregateState.AddIndex(BlobRef_Idx, (item) => item.BlobRef);
_aggregateState.AddIndex(Metadata_Name_Idx, (item) => item.Name);
_aggregateState.AddIndex(Metadata_Value_Idx, (item) => item.Value);
_aggregateState.InitialiseChainFromBlobs();
}
private static TestServer SetupTestServerForNode(NodeAddress serverNode)
{
SampleResponse serverResponse = new SampleResponse(serverNode.Id.ToString());
var testServer = new TestServer(serverNode, serverResponse);
return(testServer);
}
/**
* Creates a new client end of a NetBarrier connected to the barrier with the given index on the given Node
*
* @param addr
* NodeAddres of the Node that the barrier is located
* @param vbn
* Index of the barrier to connect to
* @param enrolled
* The number of locally enrolled processes
* @return A new client end of a NetBarrier
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @//throws ArgumentException
* Thrown if the number of enrolled processes is outside the defined range.
*/
public static NetBarrier netBarrier(NodeAddress addr, int vbn, int enrolled)
{
// Get the Link with the given address
Link link = LinkFactory.getLink(addr);
NetBarrier barrierToReturn = null;
try
{
barrierToReturn = NetBarrier.create(new NetBarrierLocation(link.remoteID, vbn), enrolled);
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
catch (JCSPNetworkException e)
{
Console.WriteLine(e);
}
return(barrierToReturn);
// Create a new NetBarrier
//return NetBarrier.create(new NetBarrierLocation(link.remoteID, vbn), enrolled);
}
public void SendTo(NodeAddress nodeAddress, eRaftSignalType signalType, byte[] data, NodeAddress myNodeAddress)
{
Task.Run(() =>
{
foreach (var n in nodes)
{
if (!n.Value.IsRunning)
{
continue;
}
if (n.Value.NodeAddress.NodeAddressId == myNodeAddress.NodeAddressId)
{
continue; //Skipping sending to self
}
if (n.Value.NodeAddress.NodeAddressId == nodeAddress.NodeAddressId)
{
//May be put it all into new Threads or so
((IRaftComReceiver)n.Value).IncomingSignalHandler(myNodeAddress, signalType, data);
break;
}
}
});
}
public NodeAddress AddItem(NodeAddress nodeAddress)
{
switch (nodeAddress.NodeType)
{
case NodeType.All:
break;
case NodeType.Category:
Category newCat = AddNewCategory();
Map.AddItem(nodeAddress, newCat);
nodeAddress.ChangeAddress(newCat.CategoryName);
return(nodeAddress);
case NodeType.Institution:
Institution newInstit = GetCategory(nodeAddress.Address[0]).AddNewInstitution();
Map.AddItem(nodeAddress, newInstit);
nodeAddress.ChangeAddress(newInstit.InstitutionName);
return(nodeAddress);
case NodeType.Account:
Account newAccount = GetCategory(nodeAddress.Address[0]).GetInstitution(nodeAddress.Address[1]).AddNewAccount();
Map.AddItem(nodeAddress, newAccount);
nodeAddress.ChangeAddress(newAccount.AccountName);
return(nodeAddress);
default:
break;
}
throw new Exception("Issue");
}
private void TreeViewAccounting_AfterCollapse(object sender, TreeViewEventArgs e)
{
NodeAddress na = (NodeAddress)e.Node.Tag;
TreeViewMappingElement tvme = Data.Map.GetElement(na);
tvme.Expand = false;
}
/**
* Creates a new Link, or retrieves an existing one, from a NodeAddress
*
* @param addr
* The NodeAddress of the Node to connect to
* @return A new Link connected to the node at the given NodeAddress
* @//throws JCSPNetworkException
* Thrown if anything goes wrong during the connection
*/
public static Link getLink(NodeAddress addr)
////throws JCSPNetworkException
{
// Log start of creation
Node.log.log(typeof(LinkFactory), "Trying to get link to " + addr.toString());
// Create Link from address
Link toReturn = addr.createLink();
Console.WriteLine("Finished creating link NodeID " + toReturn.remoteID);
// Now attempt to connect the Link. If connect fails, then the opposite node already has a connection to us.
// This may occur during connection if the opposite end registered its Link prior to us doing so. In such
// a circumstance, the Link should eventually appear in the LinkManager.
if (!toReturn.connect())
{
// Connect failed. Get NodeID of remote Node (this will have been set during the connect operation)
NodeID remoteID = toReturn.getRemoteNodeID();
// Log failed connect
Node.log.log(typeof(LinkFactory), "Failed to connect to " + remoteID.toString());
Console.WriteLine("Failed to connect to " + remoteID.toString());
// Set the Link to return to null
toReturn = null;
// Loop until the Link is connected. This is a possible weakness. Although it is believed that the
// opposite end will eventually connect, we may have a problem if this continually loops. For information,
// log every attempt.
while (toReturn == null)
{
try
{
// Go to sleep for a bit, and give the Link a chance to register
Thread.Sleep(100);
// Log start of attempt
Node.log.log(typeof(LinkFactory), "Attempting to retrieve Link to " + remoteID.toString());
// Retrieve Link from LinkManager
toReturn = LinkManager.getInstance().requestLink(remoteID);
}
catch (ThreadInterruptedException ie)
{
// Ignore. Should never really happen
}
}
// Return the Link retrieved from the LinkManager
return(toReturn);
}
// Connection succeeded. Register Link with the LinkManager
toReturn.registerLink();
// Now start the Link
new ProcessManager(toReturn).start();
// Return the Link
return(toReturn);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the
* given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(Any2NetChannel.create(loc, Int32.MaxValue, filter));
}
public XBeeCellular(XBeeControllerBase controller,
HardwareVersion hardwareVersion,
ushort firmwareVersion,
XBeeProtocol protocol,
NodeAddress address = null)
: base(controller, hardwareVersion, firmwareVersion, protocol, address)
{
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the
* given poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(Any2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()));
}
internal NodeAddress DeleteNode(NodeAddress na)
{
NodeAddress refNode = na.GetParent();
TreeViewMappingElement tvme = GetElement(refNode);
refNode.AddLast(tvme.Delete(na.GetLast()));
return(refNode);
}
public BindingDefinition(NodeAddress _sourceNA, string _sourceMember, NodeAddress _targetNA, string _targetMember, string _targetName = "", bool _twoWay = false)
{
SourceNA = _sourceNA;
SourceMember = _sourceMember;
TargetNA = _targetNA;
TargetMember = _targetMember;
TargetName = _targetName;
TwoWay = _twoWay;
}
public MemberAddress(NodeAddress _address, MemberInfo _member)
{
Address = _address;
member = _member;
memberName = "";
if (member != null)
memberName = member.Name;
}
// public string Name {
// get { return memberName; }
// set { memberName = value; }
// }
public MemberAddress(NodeAddress _address, string _member, bool findMember = true)
{
Address = _address;
memberName = _member;
member = null;
if (Address == null)
return;
if (Address.Count == 0)
return;
if (!findMember)
return;
if (!tryFindMember ())
throw new Exception ("Member Not Found: " + memberName);
}
public static NodeAddress Parse(string addr)
{
var n = new NodeAddress();
if (addr.Contains(":"))
{
var spl = addr.Split(':');
n.Address = spl[0];
n.Port = int.Parse(spl[1]);
}
else
{
n.Address = addr;
n.Port = 1200;
}
return n;
}
public static void emitGetInstance(ILGenerator il, NodeAddress orig, NodeAddress dest)
{
int ptr = 0;
while (orig [ptr] == dest [ptr]) {
ptr++;
if (ptr == orig.Count || ptr == dest.Count)
break;
}
for (int i = 0; i < orig.Count - ptr; i++)
il.Emit (OpCodes.Callvirt, CompilerServices.miGetLogicalParent);
while (ptr < dest.Count) {
emitGetChild (il, dest [ptr-1].CrowType, dest [ptr].Index);
ptr++;
}
}
public EventBinding(NodeAddress _sourceNA, EventInfo _sourceEvt, NodeAddress _targetNA, string _targetMember, string _targetName = "")
: base(_sourceNA, _sourceEvt.Name, _targetNA, _targetMember, _targetName)
{
SourceEvent = _sourceEvt;
}
public void StorePropertyBinding(NodeAddress origNA, string origMember, NodeAddress destNA, string destMember)
{
Dictionary<string, List<MemberAddress>> nodeBindings = null;
if (Bindings.ContainsKey (origNA))
nodeBindings = Bindings [origNA];
else {
nodeBindings = new Dictionary<string, List<MemberAddress>> ();
Bindings [origNA] = nodeBindings;
}
if (!nodeBindings.ContainsKey (origMember))
nodeBindings [origMember] = new List<MemberAddress> ();
nodeBindings [origMember].Add (new MemberAddress (destNA, destMember));
}
/// <summary>
/// Emits cached delegate handler addition in the context of instantiator (ctx)
/// </summary>
public void emitCachedDelegateHandlerAddition(int index, EventInfo evt, NodeAddress address = null)
{
il.Emit(OpCodes.Ldloc_0);//load ref to current graphic object
CompilerServices.emitGetInstance (il, address);
il.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack
il.Emit(OpCodes.Ldfld, CompilerServices.fiCachedDel);
il.Emit(OpCodes.Ldc_I4, index);//load delegate index
il.Emit(OpCodes.Callvirt, CompilerServices.miGetDelegateListItem);
il.Emit(OpCodes.Callvirt, evt.AddMethod);//call add event
}
public static Delegate compileDynEventHandler(EventInfo sourceEvent, string expression, NodeAddress currentNode = null)
{
#if DEBUG_BINDING
Debug.WriteLine ("\tCompile Event {0}: {1}", sourceEvent.Name, expression);
#endif
Type lopType = null;
if (currentNode == null)
lopType = sourceEvent.DeclaringType;
else
lopType = currentNode.NodeType;
#region Retrieve EventHandler parameter type
MethodInfo evtInvoke = sourceEvent.EventHandlerType.GetMethod ("Invoke");
ParameterInfo [] evtParams = evtInvoke.GetParameters ();
Type handlerArgsType = evtParams [1].ParameterType;
#endregion
Type [] args = { CompilerServices.TObject, handlerArgsType };
DynamicMethod dm = new DynamicMethod ("dyn_eventHandler",
typeof(void),
args, true);
ILGenerator il = dm.GetILGenerator (256);
il.Emit (OpCodes.Nop);
string [] srcLines = expression.Trim ().Split (new char [] { ';' });
foreach (string srcLine in srcLines) {
string statement = srcLine.Trim ();
string [] operandes = statement.Split (new char [] { '=' });
if (operandes.Length < 2) //not an affectation
{
//maybe we could handle here handler function name
continue;
}
string rop = operandes [operandes.Length - 1].Trim ();
#region LEFT OPERANDES
string [] lopParts = operandes [0].Trim ().Split ('/');
MemberInfo lopMI = null;
il.Emit (OpCodes.Ldarg_0); //load sender ref onto the stack
if (lopParts.Length > 1) {
NodeAddress lopNA = getNodeAdressFromBindingExp (currentNode, lopParts);
CompilerServices.emitGetInstance (il, currentNode, lopNA);
lopType = lopNA.NodeType;
}
string [] bindTrg = lopParts.Last().Split ('.');
if (bindTrg.Length == 1)
lopMI = lopType.GetMember (bindTrg [0]).FirstOrDefault();
else if (bindTrg.Length == 2) {
//named target
//TODO:
il.Emit(OpCodes.Ldstr, bindTrg[0]);
il.Emit(OpCodes.Callvirt, miFindByName);
lopMI = lopType.GetMember (bindTrg [1]).FirstOrDefault();
} else
throw new Exception ("Syntax error in binding, expected 'go dot member'");
if (lopMI == null)
throw new Exception (string.Format ("IML BINDING: Member not found"));
OpCode lopSetOpCode;
dynamic lopSetMI;
Type lopT = null;
switch (lopMI.MemberType) {
case MemberTypes.Property:
lopSetOpCode = OpCodes.Callvirt;
PropertyInfo lopPi = lopMI as PropertyInfo;
lopT = lopPi.PropertyType;
lopSetMI = lopPi.GetSetMethod ();
break;
case MemberTypes.Field:
lopSetOpCode = OpCodes.Stfld;
FieldInfo dstFi = lopMI as FieldInfo;
lopT = dstFi.FieldType;
lopSetMI = dstFi;
break;
default:
throw new Exception (string.Format ("GOML:member type not handle"));
}
#endregion
#region RIGHT OPERANDES
if (rop.StartsWith ("\'")) {
if (!rop.EndsWith ("\'"))
throw new Exception (string.Format
("GOML:malformed string constant in handler: {0}", rop));
string strcst = rop.Substring (1, rop.Length - 2);
il.Emit (OpCodes.Ldstr, strcst);
} else {
if (lopT.IsEnum)
throw new NotImplementedException ();
MethodInfo lopParseMi = lopT.GetMethod ("Parse");
if (lopParseMi == null)
throw new Exception (string.Format
("GOML:no parse method found in: {0}", lopT.Name));
il.Emit (OpCodes.Ldstr, rop);
il.Emit (OpCodes.Callvirt, lopParseMi);
il.Emit (OpCodes.Unbox_Any, lopT);
}
#endregion
//emit left operand assignment
il.Emit (lopSetOpCode, lopSetMI);
}
il.Emit (OpCodes.Ret);
return dm.CreateDelegate (sourceEvent.EventHandlerType);
}
public static void emitGetInstance(ILGenerator il, NodeAddress dest)
{
if (dest == null)
return;
for (int i = 0; i < dest.Count - 1; i++)
emitGetChild (il, dest [i].CrowType, dest [i + 1].Index);
}
public BindingDefinition(NodeAddress _sourceNA, string _sourceMember)
{
SourceNA = _sourceNA;
SourceMember = _sourceMember;
}
/// <summary>
/// replace the target node address with corresponding named node address, and clear the target name once resolved
/// </summary>
/// <param name="newTargetNA">Named Node</param>
public void ResolveTargetName(NodeAddress newTargetNA)
{
TargetNA = newTargetNA;
TargetName = "";
}
private void InitProxy()
{
NodeAddress storeAddress = new NodeAddress();
storeAddress.Host = Configuration.Instance().Get<string>("ServiceStore", "Host", "localhost");
storeAddress.Port = Configuration.Instance().Get<int>("ServiceStore", "Port", 19995);
_proxy = new ServiceStore_Proxy(_transport.Connect(storeAddress.Host, storeAddress.Port));
}
/// <summary>
/// Gets the node adress from binding expression splitted with '/' starting at a given node
/// </summary>
public static NodeAddress getNodeAdressFromBindingExp(NodeAddress sourceAddr, string[] bindingExp)
{
int ptr = sourceAddr.Count - 1;
//if exp start with '/' => Graphic tree parsing start at source
if (string.IsNullOrEmpty (bindingExp [0])) {
//TODO:
} else if (bindingExp [0] == ".") { //search template root
ptr--;
while (ptr >= 0) {
if (typeof(TemplatedControl).IsAssignableFrom (sourceAddr [ptr].CrowType))
break;
ptr--;
}
} else if (bindingExp [0] == "..") { //search starting at current node
int levelUp = bindingExp.Length - 1;
if (levelUp > ptr + 1)
throw new Exception ("Binding error: try to bind outside IML source");
ptr -= levelUp;
}
//TODO:change Template special address identified with Nodecount = 0 to something not using array count to 0,
//here linq is working without limits checking in compile option
//but defining a 0 capacity array with limits cheking enabled, cause 'out of memory' error
return new NodeAddress (sourceAddr.Take(ptr+1).ToArray());//[ptr+1];
//Array.Copy (sourceAddr.ToArray (), targetNode, ptr + 1);
//return new NodeAddress (targetNode);
}
public async void EscanearRed()
{
try
{
if (instancia.ListNodes == null)
{
if (MonitoreoEvent != null) MonitoreoEvent(this, new MonitoreoEventArgs("Escaneando Red...", ETipoEvento.Exitoso, 0, ""));
instancia.ListNodes = new List<NodosXbee>();
}
string _macNodoEncontrado;
string _macImpresora = "";
int _tiempoEspera = 0;
int _idXbee = 0;
Enumeraciones.TipoDispositivo _tipDisp;
DataTable dtXbees;
using (Generales modGEN = new Generales())
{
dtXbees = modGEN.ObtenerTodosLosXbee();
}
foreach (DataRow _row in dtXbees.Rows)
{
_macNodoEncontrado = (string)_row["macXbee"];
_macImpresora = (string)_row["impresoraXbee"];
_tiempoEspera = (int)_row["tiempoEspXbee"];
_idXbee = (int)_row["idXbee"];
_tipDisp = (Enumeraciones.TipoDispositivo)_row["tipoXbee"];
NodosXbee newDispositivo = new NodosXbee(null, (string)_row["nomXbee"].ToString(), _macNodoEncontrado, _macImpresora, _tiempoEspera, _tipDisp, _idXbee);
//Buscar nodo en red
ulong _ulong = Convert.ToUInt64(_row["macXbee"].ToString(), 16);
NodeAddress Address = new NodeAddress(new LongAddress(_ulong));
XBeeNode nodoXbee = null;
nodoXbee = await instancia.Controller.GetRemoteAsync(Address);
if (nodoXbee != null)
{
newDispositivo.Nodo = nodoXbee;
if (MonitoreoEvent != null) MonitoreoEvent(this, new MonitoreoEventArgs("Se conectó el dispositivo: " + newDispositivo.Nombre + " MAC:" + _macNodoEncontrado + "", ETipoEvento.Exitoso, newDispositivo.IdXbee, ""));
if (_tipDisp == Enumeraciones.TipoDispositivo.Dispensador)
{
ActualizarDatosDispensador(newDispositivo.IdXbee);
}
}
instancia.AgregarNodo(newDispositivo);
}
}
catch (Exception e)
{
LocalLogManager.EscribeLog(e.Message, LocalLogManager.TipoImagen.TipoError);
if (MonitoreoEvent != null) MonitoreoEvent(this, new MonitoreoEventArgs("Se detectó un error:\n" + e.Message, ETipoEvento.Error, 0, ""));
}
}
void emitPropertyBindings(Context ctx, NodeAddress origine, Dictionary<string, List<MemberAddress>> bindings)
{
Type origineNodeType = origine.NodeType;
//value changed dyn method
DynamicMethod dm = new DynamicMethod ("dyn_valueChanged" + NewId,
typeof (void), CompilerServices.argsValueChange, true);
ILGenerator il = dm.GetILGenerator (256);
System.Reflection.Emit.Label endMethod = il.DefineLabel ();
il.DeclareLocal (CompilerServices.TObject);
il.Emit (OpCodes.Nop);
int i = 0;
foreach (KeyValuePair<string, List<MemberAddress>> bindingCase in bindings ) {
System.Reflection.Emit.Label nextTest = il.DefineLabel ();
#region member name test
//load source member name
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Ldfld, CompilerServices.fiVCMbName);
il.Emit (OpCodes.Ldstr, bindingCase.Key);//load name to test
il.Emit (OpCodes.Ldc_I4_4);//StringComparison.Ordinal
il.Emit (OpCodes.Callvirt, CompilerServices.stringEquals);
il.Emit (OpCodes.Brfalse, nextTest);//if not equal, jump to next case
#endregion
#region destination member affectations
PropertyInfo piOrig = origineNodeType.GetProperty (bindingCase.Key);
Type origineType = null;
if (piOrig != null)
origineType = piOrig.PropertyType;
foreach (MemberAddress ma in bindingCase.Value) {
//first we have to load destination instance onto the stack, it is access
//with graphic tree functions deducted from nodes topology
il.Emit (OpCodes.Ldarg_0);//load source instance of ValueChanged event
NodeAddress destination = ma.Address;
if (destination.Count == 0){//template reverse binding
//fetch destination instance (which is the template root)
for (int j = 0; j < origine.Count ; j++)
il.Emit(OpCodes.Callvirt, CompilerServices.miGetLogicalParent);
}else
CompilerServices.emitGetInstance (il, origine, destination);
if (origineType != null && destination.Count > 0){//else, prop less binding or reverse template bind, no init requiered
//for initialisation dynmeth, push destination instance loc_0 is root node in ctx
ctx.il.Emit(OpCodes.Ldloc_0);
CompilerServices.emitGetInstance (ctx.il, destination);
//init dynmeth: load actual value from origine
ctx.il.Emit (OpCodes.Ldloc_0);
CompilerServices.emitGetInstance (ctx.il, origine);
ctx.il.Emit (OpCodes.Callvirt, origineNodeType.GetProperty (bindingCase.Key).GetGetMethod());
}
//load new value
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Ldfld, CompilerServices.fiVCNewValue);
if (origineType == null)//property less binding, no init
CompilerServices.emitConvert (il, ma.Property.PropertyType);
else if (destination.Count > 0) {
if (origineType.IsValueType)
ctx.il.Emit(OpCodes.Box, origineType);
CompilerServices.emitConvert (ctx.il, origineType, ma.Property.PropertyType);
CompilerServices.emitConvert (il, origineType, ma.Property.PropertyType);
ctx.il.Emit (OpCodes.Callvirt, ma.Property.GetSetMethod());//set init value
} else {// reverse templateBinding
il.Emit (OpCodes.Ldstr, ma.memberName);//arg 3 of setValueWithReflexion
il.Emit (OpCodes.Call, CompilerServices.miSetValWithRefx);
continue;
}
il.Emit (OpCodes.Callvirt, ma.Property.GetSetMethod());//set value on value changes
}
#endregion
il.Emit (OpCodes.Br, endMethod);
il.MarkLabel (nextTest);
i++;
}
il.MarkLabel (endMethod);
il.Emit (OpCodes.Ret);
//store and emit Add in ctx
int dmIdx = cachedDelegates.Count;
cachedDelegates.Add (dm.CreateDelegate (typeof(EventHandler<ValueChangeEventArgs>)));
ctx.emitCachedDelegateHandlerAddition (dmIdx, CompilerServices.eiValueChange, origine);
}
/// <summary>
/// Splits the binding expression
/// </summary>
/// <returns><c>true</c>, if it's a two way binding, <c>false</c> otherwise.</returns>
/// <param name="sourceNA">Source Node address</param>
/// <param name="expression">Expression.</param>
/// <param name="targetNA">Target Node Address</param>
/// <param name="targetMember">Target member name</param>
/// <param name="targetName">Target node name</param>
BindingDefinition splitBindingExp(NodeAddress sourceNA, string sourceMember, string expression)
{
BindingDefinition bindingDef = new BindingDefinition(sourceNA, sourceMember);
if (string.IsNullOrEmpty (expression)) {
return bindingDef;
} else {
if (expression.StartsWith ("²")) {
bindingDef.TwoWay = true;
expression = expression.Substring (1);
}
string[] bindingExp = expression.Split ('/');
if (bindingExp.Length > 1)
bindingDef.TargetNA = CompilerServices.getNodeAdressFromBindingExp (sourceNA, bindingExp);
string [] bindTrg = bindingExp.Last().Split ('.');
if (bindTrg.Length == 1)
bindingDef.TargetMember = bindTrg [0];
else if (bindTrg.Length == 2) {
//named target
bindingDef.TargetName = bindTrg[0];
bindingDef.TargetMember = bindTrg [1];
} else
throw new Exception ("Syntax error in binding, expected 'go dot member'");
}
return bindingDef;
}
