public async Task TestAgentCloseConnectionWorksForOutgoing()
{
var endpoint = "127.0.0.1:9604";
var myDid = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}");
var identityJson = string.Format("{{\"did\":\"{0}\", \"pk\":\"{1}\", \"verkey\":\"{2}\", \"endpoint\":\"{3}\"}}",
myDid.Did, myDid.Pk, myDid.VerKey, endpoint);
await Signus.StoreTheirDidAsync(_wallet, identityJson);
var activeListener = await AgentListener.ListenAsync(endpoint);
await activeListener.AddIdentityAsync(_pool, _wallet, myDid.Did);
await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did);
var connectionEvent = await activeListener.WaitForConnection();
var serverToClientConnection = connectionEvent.Connection;
await activeListener.CloseAsync();
var ex = await Assert.ThrowsExceptionAsync <IndyException>(() =>
serverToClientConnection.SendAsync("msg")
);
Assert.AreEqual(ErrorCode.CommonInvalidStructure, ex.ErrorCode);
}
public async Task CanDisposeClosedConnection()
{
using (var connection = await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did))
{
await connection.CloseAsync();
}
}
public async Task TestAgentCloseConnectionWorksForIncoming()
{
var endpoint = "127.0.0.1:9613";
var myDid = await Signus.CreateAndStoreMyDidAsync(wallet, "{}");
var identityJson = string.Format(AGENT_IDENTITY_JSON_TEMPLATE, myDid.Did, myDid.Pk, myDid.VerKey, endpoint);
await Signus.StoreTheirDidAsync(wallet, identityJson);
var activeListener = await AgentListener.ListenAsync(endpoint);
await activeListener.AddIdentityAsync(pool, wallet, myDid.Did);
var connection = await AgentConnection.ConnectAsync(pool, wallet, myDid.Did, myDid.Did);
var connectionEvent = await activeListener.WaitForConnectionAsync();
var serverToClientConnection = connectionEvent.Connection;
await serverToClientConnection.CloseAsync();
var ex = await Assert.ThrowsExceptionAsync <InvalidStructureException>(() =>
serverToClientConnection.SendAsync("msg")
);
}
public async Task DisposeCanBeCalledRepeatedly()
{
var connection = await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did);
connection.Dispose();
connection.Dispose();
}
public void MergeDataRows(AgentConnection agentConnection, AgentHealthState state, string message)
{
if (agentConnection == null || state == null)
{
return;
}
//Add and update nodes
var matchingNodes = from DataRow r in DataTable.Rows
let nodeInDataTable = (AgentConnection)r["Agent"]
where nodeInDataTable.Address == agentConnection.Address
select r;
if (!matchingNodes.Any())
{
object[] rowData = new object[2];
CreateColumnIfNotExist("Status", "", typeof(Bitmap), 16);
rowData[DataTable.Columns.IndexOf("Status")] = StatusIconProvider.GrayCircle;
CreateColumnIfNotExist("Agent", "Agent", typeof(AgentConnection), 60);
rowData[DataTable.Columns.IndexOf("Agent")] = agentConnection;
DataTable.Rows.Add(rowData);
}
}
public Connection()
{
var agentConnection = new AgentConnection();
var loggerFactory = new LoggerFactory();
_connection = new Srv.Agent.Command.Common.Connection((IComAgentConfiguration)agentConnection.Agent, loggerFactory);
}
/// <summary>
/// Initializes a new AgentConnectionEvent.
/// </summary>
/// <param name="listener">The listener the connection was established on.</param>
/// <param name="result">The result of the opening the connection.</param>
/// <param name="connection">The connection.</param>
/// <param name="senderDid">The DID of the sender.</param>
/// <param name="receiverDid">The DID of the receiver.</param>
internal AgentConnectionEvent(AgentListener listener, ErrorCode result, AgentConnection connection, string senderDid, string receiverDid) :
base(listener.Handle, result)
{
Connection = connection;
SenderDid = senderDid;
ReceiverDid = receiverDid;
Listener = listener;
}
[Ignore] //Wait until proper error is implemented in SDK and handle.
public async Task CanCloseAfterDispose()
{
await PrepareForConnection("127.0.0.1:9618");
var connection = await AgentConnection.ConnectAsync(pool, wallet, _myDid, _myDid);
connection.Dispose();
await connection.CloseAsync();
}
public async Task DisposeCanBeCalledRepeatedly()
{
await PrepareForConnection("127.0.0.1:9611");
var connection = await AgentConnection.ConnectAsync(pool, wallet, _myDid, _myDid);
connection.Dispose();
connection.Dispose();
}
public async Task CanDisposeClosedConnection()
{
await PrepareForConnection("127.0.0.1:9610");
using (var connection = await AgentConnection.ConnectAsync(pool, wallet, _myDid, _myDid))
{
await connection.CloseAsync();
}
}
public DispatcherBase(AgentConnection client, double interval)
{
Client = client;
_jobScheduler = new Timer();
_jobScheduler.Elapsed += PerformWork;
_jobScheduler.AutoReset = true;
Interval = interval;
}
private void NodeDataUpdated(AgentConnection agentConnection, NodeNetwork updatedNodes)
{
dataGridViewNodes.UpdateNodes(updatedNodes, clientConnectionManager.Session.Database);
toolStripStatusLabelDatabase.Text = "DB: " + clientConnectionManager.Session.Database.GetDatabaseFilesystemSize();
int totalNodes = managedNodes.Nodes.Count;
int runningNodes = managedNodes.Nodes.Count(n => n.Value.NodeState.Initialized && n.Value.NodeState.NodeOperationState.State == ProcessState.Running);
toolStripStatusLabelNodeState.Text = $"Nodes: {runningNodes} / {totalNodes}";
}
[Ignore] //Appears endpoint cannot be re-connected to. Requires further testing.
public async Task EndpointCanBeReUsedAfterDispose()
{
var connection = await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did);
await connection.CloseAsync();
connection.Dispose();
using (var newConnection = await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did))
{
}
}
public async Task CanCloseAfterDispose()
{
var connection = await AgentConnection.ConnectAsync(_pool, _wallet, myDid.Did, myDid.Did);
connection.Dispose();
var ex = await Assert.ThrowsExceptionAsync <IndyException>(() =>
connection.CloseAsync()
);
Assert.AreEqual(ErrorCode.CommonInvalidStructure, ex.ErrorCode);
}
public async Task TestAgentConnectWorksForRemoteData()
{
var endpoint = "127.0.0.1:9605";
var listenerWalletName = "listenerWallet";
var trusteeWalletName = "trusteeWallet";
await Wallet.CreateWalletAsync(_poolName, listenerWalletName, "default", null, null);
var listenerWallet = await Wallet.OpenWalletAsync(listenerWalletName, null, null);
await Wallet.CreateWalletAsync(_poolName, trusteeWalletName, "default", null, null);
var trusteeWallet = await Wallet.OpenWalletAsync(trusteeWalletName, null, null);
var senderWallet = trusteeWallet;
var createMyDidResult = await Signus.CreateAndStoreMyDidAsync(listenerWallet, "{}");
var listenerDid = createMyDidResult.Did;
var listenerVerkey = createMyDidResult.VerKey;
var listenerPk = createMyDidResult.Pk;
var trusteeDidJson = "{\"seed\":\"000000000000000000000000Trustee1\"}";
var trusteeDidResult = await Signus.CreateAndStoreMyDidAsync(trusteeWallet, trusteeDidJson);
var trusteeDid = trusteeDidResult.Did;
var senderDid = trusteeDid;
var nymRequest = await Ledger.BuildNymRequestAsync(trusteeDid, listenerDid, listenerVerkey, null, null);
await Ledger.SignAndSubmitRequestAsync(_pool, trusteeWallet, trusteeDid, nymRequest);
var attribRequest = await Ledger.BuildAttribRequestAsync(listenerDid, listenerDid, null,
string.Format("{{\"endpoint\":{{\"ha\":\"{0}\",\"verkey\":\"{1}\"}}}}", endpoint, listenerPk), null);
await Ledger.SignAndSubmitRequestAsync(_pool, listenerWallet, listenerDid, attribRequest);
var activeListener = await AgentListener.ListenAsync(endpoint);
await activeListener.AddIdentityAsync(_pool, listenerWallet, listenerDid);
await AgentConnection.ConnectAsync(_pool, senderWallet, senderDid, listenerDid);
await listenerWallet.CloseAsync();
await Wallet.DeleteWalletAsync(listenerWalletName, null);
await trusteeWallet.CloseAsync();
await Wallet.DeleteWalletAsync(trusteeWalletName, null);
}
[Ignore] //Appears endpoint cannot be re-connected to. Requires further testing.
public async Task EndpointCanBeReUsedAfterDispose()
{
await PrepareForConnection("127.0.0.1:9612");
var connection = await AgentConnection.ConnectAsync(pool, wallet, _myDid, _myDid);
await connection.CloseAsync();
connection.Dispose();
using (var newConnection = await AgentConnection.ConnectAsync(pool, wallet, _myDid, _myDid))
{
}
}
public async Task TestAgentConnectWorksForAllDataInWalletPresent()
{
var endpoint = "127.0.0.1:9606";
var myDidResult = await Signus.CreateAndStoreMyDidAsync(wallet, "{}");
var identityJson = string.Format(AGENT_IDENTITY_JSON_TEMPLATE, myDidResult.Did, myDidResult.Pk, myDidResult.VerKey, endpoint);
await Signus.StoreTheirDidAsync(wallet, identityJson);
var activeListener = await AgentListener.ListenAsync(endpoint);
await activeListener.AddIdentityAsync(pool, wallet, myDidResult.Did);
await AgentConnection.ConnectAsync(pool, wallet, myDidResult.Did, myDidResult.Did);
}
public void UpdateNodes(AgentConnection agentConnection, AgentHealthState state, string message)
{
Mapper.MergeDataRows(agentConnection, state, message);
Mapper.UpdateDataTable(agentConnection, state, message);
if (this.DataSource == null)
{
ConfigureDataGridView();
}
if (SelectedRows.Count > 0)
{
DataGridViewRow selectedRow = SelectedRows[0];
DataGridViewRowStateChangedEventArgs e = new DataGridViewRowStateChangedEventArgs(selectedRow, DataGridViewElementStates.None);
this.OnRowStateChanged(selectedRow.Index, e);
}
}
public async Task TestAgentConnectWorksForAllDataInWalletPresent()
{
var endpoint = "127.0.0.1:9606";
var myDidResult = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}");
var identityJson = string.Format("{{\"did\":\"{0}\", \"pk\":\"{1}\", \"verkey\":\"{2}\", \"endpoint\":\"{3}\"}}",
myDidResult.Did, myDidResult.Pk, myDidResult.VerKey, endpoint);
await Signus.StoreTheirDidAsync(_wallet, identityJson);
var activeListener = await AgentListener.ListenAsync(endpoint);
await activeListener.AddIdentityAsync(_pool, _wallet, myDidResult.Did);
await AgentConnection.ConnectAsync(_pool, _wallet, myDidResult.Did, myDidResult.Did);
}
public void run()
{
bool result;
AgentConnection agentConnection;
InstantiateRequest request;
//simulationState.stdout.Send("CH: entering main loop\n");
tcpListener.Start();
while (!quit)
{
Thread.Sleep(0);
tcpClient = tcpListener.AcceptTcpClient();
agentConnection = new AgentConnection(simulationState, tcpClient);
//simulationState.stdout.Send(String.Format("CH: accepted client.\n"));
if (agentConnection.init())
{
agentConnections.Add(agentConnection);
request = new InstantiateRequest(agentConnection);
simulationState.instantiateRequests.Send(request);
// Block until we get the signal that the agent has been instantiated in the simulation.
// Then, we can start running it's thread and it's perceive-act loop.
if (instantiationResults.Recv(out result))
{
if (result)
{
agentConnection.start();
}
else
{
Debug.Log("CH Error: instantiation unsuccesful.");
}
}
else
{
Debug.LogError("CH Error: instantiation empty.");
}
}
}
//simulationState.stdout.Send("CH: exit main loop.\n");
}
public static void Handle_RelayRegisterResult(AgentConnection con, PacketReader reader)
{
var result = reader.ReadBoolean();
if (result)
{
Log.Info("LoginServer successfully installed");
}
else
{
Log.Info("Some problems are appear while installing LoginServer");
}
if (result)
{
_mCurrentAgentServer = con;
}
}
public async Task TestAgentSendWorks()
{
var endpoint = "127.0.0.1:9609";
var myDidResult = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}");
var identityJson = string.Format("{{\"did\":\"{0}\", \"pk\":\"{1}\", \"verkey\":\"{2}\", \"endpoint\":\"{3}\"}}",
myDidResult.Did, myDidResult.Pk, myDidResult.VerKey, endpoint);
await Signus.StoreTheirDidAsync(_wallet, identityJson);
var listener = await AgentListener.ListenAsync(endpoint);
await listener.AddIdentityAsync(_pool, _wallet, myDidResult.Did);
var clientConnection = await AgentConnection.ConnectAsync(_pool, _wallet, myDidResult.Did, myDidResult.Did);
var connectionEvent = await listener.WaitForConnection();
var serverConnection = connectionEvent.Connection;
var waitListenerConnectionTask = listener.WaitForConnection(); //Start waiting for additional connections - we'll never get one in this test, however.
var clientToServerMessage = "msg_from_client";
var serverToClientMessage = "msg_from_server";
await clientConnection.SendAsync(clientToServerMessage);
var waitServerMessageTask = serverConnection.WaitForMessage();
var completedTask = await Task.WhenAny(waitListenerConnectionTask, waitServerMessageTask); //Wait for either an additional connection or message and proceed when one has arrived.
Assert.AreEqual(completedTask, waitServerMessageTask);
var serverMessageEvent = await waitServerMessageTask;
Assert.AreEqual(clientToServerMessage, serverMessageEvent.Message);
await serverConnection.SendAsync(serverToClientMessage);
var clientMessageEvent = await clientConnection.WaitForMessage();
Assert.AreEqual(serverToClientMessage, clientMessageEvent.Message);
}
public void run()
{
bool result;
AgentConnection agentConnection;
InstantiateRequest request;
//simulationState.stdout.Send("CH: entering main loop\n");
tcpListener.Start();
while (!quit) {
Thread.Sleep(0);
tcpClient = tcpListener.AcceptTcpClient();
agentConnection = new AgentConnection(simulationState, tcpClient);
//simulationState.stdout.Send(String.Format("CH: accepted client.\n"));
if (agentConnection.init()) {
agentConnections.Add(agentConnection);
request = new InstantiateRequest(agentConnection);
simulationState.instantiateRequests.Send(request);
// Block until we get the signal that the agent has been instantiated in the simulation.
// Then, we can start running it's thread and it's perceive-act loop.
if (instantiationResults.Recv(out result)) {
if (result) {
agentConnection.start();
}
else {
Debug.Log("CH Error: instantiation unsuccesful.");
}
}
else {
Debug.LogError("CH Error: instantiation empty.");
}
}
}
//simulationState.stdout.Send("CH: exit main loop.\n");
}
public NodeActionDispatcher(AgentConnection client, double interval) : base(client, interval)
{
actionQueue = new ConcurrentQueue <ActionRequest>();
}
public NodeStatusProcessor(AgentConnection agent) : base(agent)
{
}
public ClientRegistrationDispatcher(AgentConnection client, double interval) : base(client, interval)
{
}
public AgentRegistrationProcessor(AgentConnection agent) : base(agent)
{
}
public ResourceFromClientDispatcher(AgentConnection client, double interval) : base(client, interval)
{
deploymentQueue = new ConcurrentQueue <Resource>();
}
public InstantiateRequest(AgentConnection AC)
{
this.agentConnection = AC;
}
public async Task TestAgentDemo()
{
var endpoint = "127.0.0.1:9801";
var listenerWalletName = "listenerWallet";
var trusteeWalletName = "trusteeWallet";
var message = "test";
//1. Create and Open Pool
var poolName = PoolUtils.CreatePoolLedgerConfig();
var pool = await Pool.OpenPoolLedgerAsync(poolName, "{}");
//2. Create and Open Listener Wallet
await Wallet.CreateWalletAsync(poolName, listenerWalletName, "default", null, null);
var listenerWallet = await Wallet.OpenWalletAsync(listenerWalletName, null, null);
//3. Create and Open Trustee Wallet
await Wallet.CreateWalletAsync(poolName, trusteeWalletName, "default", null, null);
var trusteeWallet = await Wallet.OpenWalletAsync(trusteeWalletName, null, null);
var senderWallet = trusteeWallet;
//4. Create My Did
var createMyDidResult = await Signus.CreateAndStoreMyDidAsync(listenerWallet, "{}");
var listenerDid = createMyDidResult.Did;
var listenerVerkey = createMyDidResult.VerKey;
var listenerPk = createMyDidResult.Pk;
//5. Create Their Did from Trustee seed
var trusteeDidJson = "{\"seed\":\"000000000000000000000000Trustee1\"}";
var trusteeDidResult = await Signus.CreateAndStoreMyDidAsync(trusteeWallet, trusteeDidJson);
var trusteeDid = trusteeDidResult.Did;
var senderDid = trusteeDid;
// 6. Prepare and Send NYM request with signing
var nymRequest = await Ledger.BuildNymRequestAsync(trusteeDid, listenerDid, listenerVerkey, null, null);
await Ledger.SignAndSubmitRequestAsync(pool, trusteeWallet, trusteeDid, nymRequest);
// 7. Prepare and Send Attrib for listener (will be requested from ledger and used by sender at start connection)
var rawJson = string.Format("{{\"endpoint\":{{\"ha\":\"{0}\",\"verkey\":\"{1}\"}}}}", endpoint, listenerPk);
var attribRequest = await Ledger.BuildAttribRequestAsync(listenerDid, listenerDid, null, rawJson, null);
await Ledger.SignAndSubmitRequestAsync(pool, listenerWallet, listenerDid, attribRequest);
// 8. start listener on endpoint
var activeListener = await AgentListener.ListenAsync(endpoint);
// 9. Allow listener accept incoming connection for specific DID (listener_did)
await activeListener.AddIdentityAsync(pool, listenerWallet, listenerDid);
// 10. Initiate connection from sender to listener
var connection = await AgentConnection.ConnectAsync(pool, senderWallet, senderDid, listenerDid);
// 11. Send test message from sender to listener
await connection.SendAsync("test");
var serverConnectionEvent = await activeListener.WaitForConnection();
var serverConnection = serverConnectionEvent.Connection;
var messageEvent = await serverConnection.WaitForMessage();
Assert.AreEqual(message, messageEvent.Message);
// 12. Close connection
await connection.CloseAsync();
// 13. Close listener
await activeListener.CloseAsync();
// 14. Close and delete Issuer Wallet
await listenerWallet.CloseAsync();
await Wallet.DeleteWalletAsync(listenerWalletName, null);
// 15. Close and delete Prover Wallet
await trusteeWallet.CloseAsync();
await Wallet.DeleteWalletAsync(trusteeWalletName, null);
//16. Close Pool
await pool.CloseAsync();
}
/// <summary>
/// Initializes a new AgentMessageEvent.
/// </summary>
/// <param name="connection">The connection the message was received on.</param>
/// <param name="result">The result of receiving the message.</param>
/// <param name="message">The message.</param>
internal AgentMessageEvent(AgentConnection connection, ErrorCode result, string message) :
base(connection.Handle, result)
{
Connection = connection;
Message = message;
}
