protected override void OnStop() { lock (ServiceLock) { Stopping = true; // TODO If agent service is killed make sure AgentListener also is killed try { if (AgentListener != null && !AgentListener.HasExited) { // Try to let the agent process know that we are stopping // TODO: This is not working, fix it AgentListener.StandardInput.WriteLine("\x03"); // Wait for the process to finish (give it up to 30 seconds) AgentListener.WaitForExit(30000); // if agent is still running, kill it if (!AgentListener.HasExited) { AgentListener.Kill(); } } } catch (Exception exception) { // InvalidOperationException is thrown when there is no process associated to the process object. // There is no process to kill, Log the exception and shutdown the service. // If we don't handle this here, the service get into a state where it can neither be stoped nor restarted (Error 1061) WriteException(exception); } } }
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 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 listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); listener.Dispose(); }
public async Task CanDisposeClosedListener() { using (var listener = await AgentListener.ListenAsync(endpoint)) { await listener.CloseAsync(); } }
/// <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; }
protected override void OnStop() { lock (ServiceLock) { Stopping = true; // throw exception during OnStop() will make SCM think the service crash and trigger recovery option. // in this way we can self-update the service host. if (_restart) { throw new Exception(Resource.CrashServiceHost); } // TODO If agent service is killed make sure AgentListener also is killed try { if (AgentListener != null && !AgentListener.HasExited) { // Try to let the agent process know that we are stopping //Attach service process to console of Agent.Listener process. This is needed, //because windows service doesn't use its own console. if (AttachConsole((uint)AgentListener.Id)) { //Prevent main service process from stopping because of Ctrl + C event with SetConsoleCtrlHandler SetConsoleCtrlHandler(null, true); try { //Generate console event for current console with GenerateConsoleCtrlEvent (processGroupId should be zero) GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0); //Wait for the process to finish (give it up to 30 seconds) AgentListener.WaitForExit(30000); } finally { //Disconnect from console and restore Ctrl+C handling by main process FreeConsole(); SetConsoleCtrlHandler(null, false); } } // if agent is still running, kill it if (!AgentListener.HasExited) { AgentListener.Kill(); } } } catch (Exception exception) { // InvalidOperationException is thrown when there is no process associated to the process object. // There is no process to kill, Log the exception and shutdown the service. // If we don't handle this here, the service get into a state where it can neither be stoped nor restarted (Error 1061) WriteException(exception); } } }
public async Task EndpointCanBeReUsedAfterDispose() { var listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); using (var newListener = await AgentListener.ListenAsync(endpoint)) { } }
public async Task TestAgentAddIdentityWorks() { var endpoint = "127.0.0.1:9601"; var myDidResult = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}"); var activeListener = await AgentListener.ListenAsync(endpoint); await activeListener.AddIdentityAsync(_pool, _wallet, myDidResult.Did); }
[Ignore] //Wait until proper error is implemented in SDK and handle. public async Task CanCloseAfterDispose() { var endpoint = "127.0.0.1:9617"; await PrepareForListener(endpoint); var listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); await listener.CloseAsync(); }
public async Task DisposeCanBeCalledRepeatedly() { var endpoint = "127.0.0.1:9615"; await PrepareForListener(endpoint); var listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); listener.Dispose(); }
public async Task CanDisposeClosedListener() { var endpoint = "127.0.0.1:9614"; await PrepareForListener(endpoint); using (var listener = await AgentListener.ListenAsync(endpoint)) { await listener.CloseAsync(); } }
private async Task SendSTTResultToUser(string text, IEnumerable <Participant> participants) { var to = participants.Single(x => x.Originator); var from = participants.First(x => !x.Originator); var jsonSpeech = JsonConvert.DeserializeObject <BingSpeechResponse>(text); var g = await this.takeAction(jsonSpeech.DisplayText); await AgentListener.Resume(to.Identity, to.DisplayName, from.Identity, from.DisplayName, to.Identity, g); }
public async Task TestAgentListenWorks() { var endpoint = "127.0.0.1:9607"; 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); await AgentListener.ListenAsync(endpoint); }
public async Task CanCloseAfterDispose() { var listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); var ex = await Assert.ThrowsExceptionAsync <IndyException>(() => listener.CloseAsync() ); Assert.AreEqual(ErrorCode.WalletAlreadyExistsError, 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); }
public async Task PrepareForConnection(string endpoint) { var myDidResult = await Signus.CreateAndStoreMyDidAsync(wallet, "{}"); _myDid = myDidResult.Did; var identityJson = string.Format(AGENT_IDENTITY_JSON_TEMPLATE, _myDid, myDidResult.Pk, myDidResult.VerKey, endpoint); await Signus.StoreTheirDidAsync(wallet, identityJson); _activeListener = await AgentListener.ListenAsync(endpoint); await _activeListener.AddIdentityAsync(pool, wallet, _myDid); }
public async Task TestAgentListenWorks() { var endpoint = "127.0.0.1:9607"; var didJson = "{\"seed\":\"indy_agent_connect_works_for_aaa\"}"; var myDidResult = await Signus.CreateAndStoreMyDidAsync(_wallet, didJson); var identityJson = string.Format("{{\"did\":\"{0}\", \"pk\":\"{1}\", \"verkey\":\"{2}\", \"endpoint\":\"{3}\"}}", myDidResult.Did, myDidResult.Pk, myDidResult.VerKey, endpoint); await Signus.StoreTheirDidAsync(_wallet, identityJson); await AgentListener.ListenAsync(endpoint); }
[Ignore]//Appears endpoint cannot be re-connected to. Requires further testing. public async Task EndpointCanBeReUsedAfterDispose() { var endpoint = "127.0.0.1:9616"; await PrepareForListener(endpoint); var listener = await AgentListener.ListenAsync(endpoint); listener.Dispose(); using (var newListener = await AgentListener.ListenAsync(endpoint)) { } }
public async Task PrepareForConnection() { var endpoint = "127.0.0.1:9603"; 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); activeListener = await AgentListener.ListenAsync(endpoint); await activeListener.AddIdentityAsync(_pool, _wallet, myDid.Did); }
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 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 async Task TestAgentAddIdentityWorksForMultiplyKeys() { var endpoint = "127.0.0.1:9602"; var myDid1 = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}"); var myDid2 = await Signus.CreateAndStoreMyDidAsync(_wallet, "{}"); CreateAndStoreMyDidResult[] didResults = { myDid1, myDid2 }; var activeListener = await AgentListener.ListenAsync(endpoint); foreach (var didResult in didResults) { await activeListener.AddIdentityAsync(_pool, _wallet, didResult.Did); } }
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); }
// this will send either Ctrl-C or Ctrl-Break to agent.listener // Ctrl-C will be used for OnStop() // Ctrl-Break will be used for OnShutdown() private void SendCtrlSignalToAgentListener(uint signal) { try { if (AgentListener != null && !AgentListener.HasExited) { // Try to let the agent process know that we are stopping //Attach service process to console of Agent.Listener process. This is needed, //because windows service doesn't use its own console. if (AttachConsole((uint)AgentListener.Id)) { //Prevent main service process from stopping because of Ctrl + C event with SetConsoleCtrlHandler SetConsoleCtrlHandler(null, true); try { //Generate console event for current console with GenerateConsoleCtrlEvent (processGroupId should be zero) GenerateConsoleCtrlEvent(signal, 0); //Wait for the process to finish (give it up to 30 seconds) AgentListener.WaitForExit(30000); } finally { //Disconnect from console and restore Ctrl+C handling by main process FreeConsole(); SetConsoleCtrlHandler(null, false); } } // if agent is still running, kill it if (!AgentListener.HasExited) { AgentListener.Kill(); } } } catch (Exception exception) { // InvalidOperationException is thrown when there is no process associated to the process object. // There is no process to kill, Log the exception and shutdown the service. // If we don't handle this here, the service get into a state where it can neither be stoped nor restarted (Error 1061) WriteException(exception); } }
protected override void OnStart(string[] args) { RunningLoop = Task.Run( () => { try { bool stopping; WriteInfo("Starting VSTS Agent Service"); TimeSpan timeBetweenRetries = TimeSpan.FromSeconds(5); lock (ServiceLock) { stopping = Stopping; } while (!stopping) { WriteInfo("Starting VSTS Agent listener"); lock (ServiceLock) { AgentListener = CreateAgentListener(); AgentListener.Start(); } AgentListener.WaitForExit(); int exitCode = AgentListener.ExitCode; // Handle error code 1? // If agent fails (because its not configured) also returns error code 1, in such case we dont want to run the service // Killing a process also returns error code 1, but we want to restart the process here. // TODO: change the error code for run method if agent is not configured? if (exitCode == 2) { // Agent wants to stop the service as well Stopping = true; WriteInfo(Resource.ServiceRequestedToStop); ExitCode = exitCode; Stop(); } else { // wait for few seconds before restarting the process Thread.Sleep(timeBetweenRetries); } } lock (ServiceLock) { AgentListener.Dispose(); AgentListener = null; } } catch (Exception exception) { WriteException(exception); ExitCode = 1; Stop(); } }); }
public static async Task Execute() { Console.WriteLine("Agent sample -> started"); var listenerWalletName = "listenerWallet"; var trusteeWalletName = "trusteeWallet"; var endpoint = "127.0.0.1:9801"; var message = "test"; var trusteeSeed = "000000000000000000000000Trustee1"; try { //1. Create Pool await PoolUtils.CreatePoolLedgerConfig(); //2. Create Listener Wallet await WalletUtils.CreateWalleatAsync(PoolUtils.DEFAULT_POOL_NAME, listenerWalletName, "default", null, null); //3. Create Trustee Wallet await WalletUtils.CreateWalleatAsync(PoolUtils.DEFAULT_POOL_NAME, trusteeWalletName, "default", null, null); //4. Open pool and wallets in using statements to ensure they are closed when finished. using (var pool = await Pool.OpenPoolLedgerAsync(PoolUtils.DEFAULT_POOL_NAME, "{}")) using (var listenerWallet = await Wallet.OpenWalletAsync(listenerWalletName, null, null)) using (var trusteeWallet = await Wallet.OpenWalletAsync(trusteeWalletName, null, null)) { var senderWallet = trusteeWallet; //5. Create My Did var createMyDidResult = await Signus.CreateAndStoreMyDidAsync(listenerWallet, "{}"); var listenerDid = createMyDidResult.Did; var listenerVerkey = createMyDidResult.VerKey; var listenerPk = createMyDidResult.Pk; //6. Create Their Did from Trustee seed var trusteeDidJson = string.Format("{{\"seed\":\"{0}\"}}", trusteeSeed); var trusteeDidResult = await Signus.CreateAndStoreMyDidAsync(trusteeWallet, trusteeDidJson); var trusteeDid = trusteeDidResult.Did; var senderDid = trusteeDid; //7. Prepare and Send NYM request with signing var nymRequest = await Ledger.BuildNymRequestAsync(trusteeDid, listenerDid, listenerVerkey, null, null); await Ledger.SignAndSubmitRequestAsync(pool, trusteeWallet, trusteeDid, nymRequest); //8. Prepare and Send Attrib for listener (will be requested from ledger and used by sender at start connection) var rawAttribJson = string.Format("{{\"endpoint\":{{\"ha\":\"{0}\",\"verkey\":\"{1}\"}}}}", endpoint, listenerPk); var attribRequest = await Ledger.BuildAttribRequestAsync(listenerDid, listenerDid, null, rawAttribJson, null); await Ledger.SignAndSubmitRequestAsync(pool, listenerWallet, listenerDid, attribRequest); //9. start listener on endpoint var activeListener = await AgentListener.ListenAsync(endpoint); //10. Allow listener accept incoming connection for specific DID (listener_did) await activeListener.AddIdentityAsync(pool, listenerWallet, listenerDid); //11. Initiate connection from sender to listener var sendingConnection = await AgentConnection.ConnectAsync(pool, senderWallet, senderDid, listenerDid); var connectionEvent = await activeListener.WaitForConnectionAsync(); var receivingConnection = connectionEvent.Connection; //12. Send test message from sender to listener await sendingConnection.SendAsync(message); var messageEvent = await receivingConnection.WaitForMessageAsync(); Debug.Assert(string.Equals(message, messageEvent.Message)); //13. Close connection await sendingConnection.CloseAsync(); //14. Close listener await activeListener.CloseAsync(); //15. Close wallets and pool await listenerWallet.CloseAsync(); await trusteeWallet.CloseAsync(); await pool.CloseAsync(); } } finally { // 16. Delete Pool ledger config and wallets await PoolUtils.DeletePoolLedgerConfigAsync(PoolUtils.DEFAULT_POOL_NAME); await WalletUtils.DeleteWalletAsync(listenerWalletName, null); await WalletUtils.DeleteWalletAsync(trusteeWalletName, null); } Console.WriteLine("Agent sample -> completed"); }
private void listener_ElementsReceived(AgentListener.MessageQueueElement[] elements) { if (InvokeRequired) { Invoke(receivedHandler, new object[] { elements }); return; } object source = dataGridView.DataSource; dataGridView.DataSource = null; dataSet.Tables[0].BeginLoadData(); foreach (AgentListener.MessageQueueElement msg in elements) { DataTable tbl = dataSet.Tables["messages"]; DataRow row = tbl.NewRow(); row.BeginEdit(); /* Common stuff */ row["Timestamp"] = new DateTime(msg.time.wYear, msg.time.wMonth, msg.time.wDay, msg.time.wHour, msg.time.wMinute, msg.time.wSecond, msg.time.wMilliseconds, DateTimeKind.Local); row["ProcessName"] = msg.process_name; row["ProcessId"] = msg.process_id; row["ThreadId"] = msg.thread_id; row["FunctionName"] = msg.function_name; row["Backtrace"] = msg.backtrace; UInt32 returnAddress = 0; string callerModName = ""; if (msg.backtrace.Length > 0) { string[] tokens = msg.backtrace.Split(new char[] { '\n' }, 2); if (tokens.Length >= 1) { string line = tokens[0]; string[] lineTokens = line.Split(new string[] { "::" }, 2, StringSplitOptions.None); if (lineTokens.Length == 2) { returnAddress = Convert.ToUInt32(lineTokens[1].Substring(2), 16); callerModName = lineTokens[0]; } } } row["ReturnAddress"] = returnAddress; row["CallerModuleName"] = callerModName; row["ResourceId"] = msg.resource_id; row["MsgType"] = msg.msg_type; row["MsgContext"] = msg.context; row["Domain"] = msg.domain; row["Severity"] = msg.severity; row["Message"] = msg.message; if (msg.context == MessageContext.MESSAGE_CTX_ACTIVESYNC_DEVICE) deviceLabel = msg.message; else if (msg.context == MessageContext.MESSAGE_CTX_ACTIVESYNC_STATUS) statusLabel = msg.message; else if (msg.context == MessageContext.MESSAGE_CTX_ACTIVESYNC_SUBSTATUS) subStatusLabel = msg.message; else if (msg.context == MessageContext.MESSAGE_CTX_ACTIVESYNC_WZ_STATUS) wizStatusLabel = msg.message; row["Direction"] = msg.direction; row["LocalAddress"] = msg.local_address; row["LocalPort"] = msg.local_port; row["PeerAddress"] = msg.peer_address; row["PeerPort"] = msg.peer_port; byte[] data = new byte[msg.len]; Array.Copy(msg.buf, data, data.Length); row["Data"] = data; row["AS_Device"] = deviceLabel; row["AS_Status"] = statusLabel; row["AS_SubStatus"] = subStatusLabel; row["AS_WizStatus"] = wizStatusLabel; row.EndEdit(); tbl.Rows.Add(row); } dataSet.Tables[0].EndLoadData(); dataGridView.DataSource = source; }
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(); }
protected override void OnStart(string[] args) { RunningLoop = Task.Run( () => { try { bool stopping; WriteInfo("Starting VSTS Agent Service"); TimeSpan timeBetweenRetries = TimeSpan.FromSeconds(5); lock (ServiceLock) { stopping = Stopping; } while (!stopping) { WriteInfo("Starting VSTS Agent listener"); lock (ServiceLock) { AgentListener = CreateAgentListener(); AgentListener.OutputDataReceived += AgentListener_OutputDataReceived; AgentListener.ErrorDataReceived += AgentListener_ErrorDataReceived; AgentListener.Start(); AgentListener.BeginOutputReadLine(); AgentListener.BeginErrorReadLine(); } AgentListener.WaitForExit(); int exitCode = AgentListener.ExitCode; // exit code 0 and 1 need stop service // exit code 2 and 3 need restart agent switch (exitCode) { case 0: Stopping = true; WriteInfo(Resource.AgentExitWithoutError); break; case 1: Stopping = true; WriteInfo(Resource.AgentExitWithTerminatedError); break; case 2: WriteInfo(Resource.AgentExitWithError); break; case 3: WriteInfo(Resource.AgentUpdateInProcess); var updateResult = HandleAgentUpdate(); if (updateResult == AgentUpdateResult.Succeed) { WriteInfo(Resource.AgentUpdateSucceed); } else if (updateResult == AgentUpdateResult.Failed) { WriteInfo(Resource.AgentUpdateFailed); Stopping = true; } else if (updateResult == AgentUpdateResult.SucceedNeedRestart) { WriteInfo(Resource.AgentUpdateRestartNeeded); _restart = true; ExitCode = int.MaxValue; Stop(); } break; default: WriteInfo(Resource.AgentExitWithUndefinedReturnCode); break; } if (Stopping) { ExitCode = exitCode; Stop(); } else { // wait for few seconds before restarting the process Thread.Sleep(timeBetweenRetries); } lock (ServiceLock) { AgentListener.OutputDataReceived -= AgentListener_OutputDataReceived; AgentListener.ErrorDataReceived -= AgentListener_ErrorDataReceived; AgentListener.Dispose(); AgentListener = null; stopping = Stopping; } } } catch (Exception exception) { WriteException(exception); ExitCode = 99; Stop(); } }); }