public async Task FailingInitClosesModuleClient() { // Arrange ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { }; DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask; var milestone = new SemaphoreSlim(0, 1); var moduleClient = new Mock <IModuleClient>(); moduleClient.Setup(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>())).Callback(() => milestone.Release()).Throws <TimeoutException>(); var moduleClientProvider = new Mock <IModuleClientProvider>(); moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler)).ReturnsAsync(moduleClient.Object); var requestManager = new Mock <IRequestManager>(); bool enableSubscriptions = true; // Act var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions); await milestone.WaitAsync(TimeSpan.FromSeconds(10)); await Task.Delay(TimeSpan.FromSeconds(0.5)); // the milestone is hit a bit earlier than the exception, so wait a tiny bit // Assert moduleClient.Verify(m => m.CloseAsync(), Times.Once); }
internal void ConnectModuleServer() { this.ModuleConnection = new Connection(); ModuleConnection.EnableSession = true; ModuleConnection.EnableSecureTunnel = true; Envelope rsp = this.GreeningConnection.SendRequest("DS.Base.GetPassportToken", new Envelope()); PassportSecurityToken stt = new PassportSecurityToken(rsp.Body.XmlString); ModuleConnection.Connect(_moduleURL, "developer", stt); }
/// <summary> /// Adds a new output to an existing decoder. /// </summary> /// <param name="output">An instance of <see cref="SwitchboardPanel"/> containing the data for the new panel.</param> public void Add(ModuleConnection output) { string sql = string.Empty; Logger.LogDebug(this, "[CLASS].Add([{0}])", output); try { // Check if related decoder exists CheckDecoderExists(output); Connect(); output.ID = (int)ExecuteScalar(sql); // Añade el registro sql = @"INSERT INTO " + ModuleConnectionManager.SQL_TABLE + @" (" + ModuleConnectionManager.SQL_FIELDS_INSERT + @") VALUES (@decoderid, @blockid, @name, @address, @switchtime, @out1, @out2)"; SetParameter("decoderid", output.DecoderID); SetParameter("blockid", output.BlockID); SetParameter("name", output.Name); SetParameter("address", output.Address); SetParameter("switchtime", output.SwitchTime); SetParameter("out1", output.Output1); SetParameter("out2", output.Output2); ExecuteNonQuery(sql); // Obtiene el nuevo ID sql = @"SELECT Max(id) As id FROM " + ModuleConnectionManager.SQL_TABLE; output.ID = (int)ExecuteScalar(sql); } catch (Exception ex) { Logger.LogError(this, ex); throw; } finally { Disconnect(); } }
/// <summary> /// Read a category from the current reader record. /// </summary> internal static ModuleConnection ReadEntityRecord(SQLiteDataReader reader) { ModuleConnection record = new ModuleConnection(); record.ID = reader.GetInt32(0); record.DecoderID = reader.GetInt32(1); record.BlockID = reader.IsDBNull(2) ? 0 : reader.GetInt32(2); record.Name = reader.IsDBNull(3) ? string.Empty : reader.GetString(3); record.Address = reader.IsDBNull(4) ? 0 : reader.GetInt32(4); record.SwitchTime = reader.IsDBNull(5) ? 0 : reader.GetInt32(5); record.Output1 = reader.IsDBNull(6) ? ModuleConnection.DecoderFunctionOutputStatus.Unknown : (ModuleConnection.DecoderFunctionOutputStatus)reader.GetInt32(6); record.Output2 = reader.IsDBNull(7) ? ModuleConnection.DecoderFunctionOutputStatus.Unknown : (ModuleConnection.DecoderFunctionOutputStatus)reader.GetInt32(7); return(record); }
/// <summary> /// Update the specified connection. /// </summary> /// <param name="output">An instance with the updated data.</param> public void Update(ModuleConnection output) { string sql = string.Empty; Logger.LogDebug(this, "[CLASS].Update([{0}])", output); try { // Check if related decoder exists CheckDecoderExists(output); Connect(); sql = @"UPDATE " + ModuleConnectionManager.SQL_TABLE + @" SET decoderid = @decoderid, blockid = @blockid, name = @name, address = @address, switchtime = @switchtime, out1 = @out1, out2 = @out2 WHERE id = @id"; SetParameter("decoderid", output.DecoderID); SetParameter("blockid", output.BlockID); SetParameter("name", output.Name); SetParameter("address", output.Address); SetParameter("switchtime", output.SwitchTime); SetParameter("out1", output.Output1); SetParameter("out2", output.Output2); SetParameter("id", output.ID); ExecuteNonQuery(sql); } catch (Exception ex) { Logger.LogError(this, ex); throw; } finally { Disconnect(); } }
private void CheckDecoderExists(ModuleConnection output) { // Check if the decoder is informed if (output.DecoderID <= 0) { throw new LayoutConfigurationException("Cannot create a decoder output without related decoder."); } // Check if the decoder is in database ControlModuleManager decManager = new ControlModuleManager(this.Settings); if (decManager.GetByID(output.DecoderID) == null) { throw new LayoutConfigurationException("Cannot create a decoder output: related decoder #{0} not found.", output.DecoderID); } }
private static ModuleConnectionDto GetModuleConnectionDto(ModuleConnection mc) { if (mc == null) { return(null); } return(new ModuleConnectionDto { Id = mc.Id, SourceConnectorName = mc.SourceConnectorName, SourceId = mc.SourceModuleId, TargetConnectorName = mc.TargetConnectorName, TargetId = mc.TargetModuleId }); }
/// <summary> /// Gets all blocks from a specified switchboard panel. /// </summary> /// <param name="decoderId">The switchboard panel unique identifier (DB).</param> /// <returns>The requested list of <see cref="BlockBase"/>.</returns> public List <ModuleConnection> GetByDecoder(int decoderId) { string sql = string.Empty; ModuleConnection item = null; List <ModuleConnection> items = new List <ModuleConnection>(); Logger.LogDebug(this, "[CLASS].GetByDecoder({0})", decoderId); try { Connect(); sql = @"SELECT " + ModuleConnectionManager.SQL_FIELDS_SELECT + @" FROM " + ModuleConnectionManager.SQL_TABLE + @" WHERE panelid = @panelid"; SetParameter("panelid", decoderId); using (SQLiteDataReader reader = ExecuteReader(sql)) { while (reader.Read()) { item = ModuleConnectionManager.ReadEntityRecord(reader); if (item != null) { items.Add(item); } } } return(items); } catch (Exception ex) { Logger.LogError(this, ex); throw; } finally { Disconnect(); } }
public Envelope SendModuleRequest(string srvName, Envelope request) { try { return(ModuleConnection.SendRequest(srvName, request)); } catch (DSAServerException ex) { if (ex.Status == "511") { ConnectModuleServer(); return(SendModuleRequest(srvName, request)); } else { throw ex; } } }
public async Task CreateAndInitTest() { // Arrange ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { }; DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask; var moduleClient = new Mock <IModuleClient>(); moduleClient.Setup(m => m.IsActive).Returns(true); var moduleClientProvider = new Mock <IModuleClientProvider>(); moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler)) .ReturnsAsync(moduleClient.Object); var requestManager = new Mock <IRequestManager>(); bool enableSubscriptions = true; // Act var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions); await Task.Delay(TimeSpan.FromSeconds(5)); Option <IModuleClient> resultModuleClientOption = moduleConnection.GetModuleClient(); // Assert Assert.True(resultModuleClientOption.HasValue); Assert.Equal(moduleClient.Object, resultModuleClientOption.OrDefault()); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); // Act IModuleClient resultModuleClient = await moduleConnection.GetOrCreateModuleClient(); // Assert Assert.NotNull(resultModuleClient); Assert.Equal(moduleClient.Object, resultModuleClient); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); }
public async Task CreateAndCloseTest() { // Arrange ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { }; DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask; Task <IModuleClient> GetModuleClient() => Task.FromResult(Mock.Of <IModuleClient>(m => m.IsActive)); var moduleClientProvider = new Mock <IModuleClientProvider>(); moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler)) .Returns(GetModuleClient); var requestManager = new Mock <IRequestManager>(); bool enableSubscriptions = true; // Act var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions); IModuleClient resultModuleClient = await moduleConnection.GetOrCreateModuleClient(); Option <IModuleClient> optionResultModuleClient = moduleConnection.GetModuleClient(); // Assert Assert.NotNull(resultModuleClient); Assert.True(optionResultModuleClient.HasValue); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once); Mock <IModuleClient> moduleClient = Mock.Get(resultModuleClient); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); // Act - Set the client to not active and try to get a Get a module client moduleClient.Setup(m => m.IsActive).Returns(false); optionResultModuleClient = moduleConnection.GetModuleClient(); // Assert Assert.False(optionResultModuleClient.HasValue); // Act resultModuleClient = await moduleConnection.GetOrCreateModuleClient(); optionResultModuleClient = moduleConnection.GetModuleClient(); // Assert Assert.NotNull(resultModuleClient); Assert.True(optionResultModuleClient.HasValue); moduleClient = Mock.Get(resultModuleClient); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(2)); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); // Act - Set the client to not active and raise the client closed event moduleClient.Setup(m => m.IsActive).Returns(false); moduleClient.Raise(m => m.Closed += null, new EventArgs()); await Task.Delay(TimeSpan.FromSeconds(3)); optionResultModuleClient = moduleConnection.GetModuleClient(); // Assert Assert.True(optionResultModuleClient.HasValue); moduleClient = Mock.Get(resultModuleClient); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(3)); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); // Act resultModuleClient = await moduleConnection.GetOrCreateModuleClient(); // Assert Assert.NotNull(resultModuleClient); moduleClient = Mock.Get(resultModuleClient); moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(3)); moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once); moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once); }
private void Awake() { moduleConnection = GameObject.FindObjectOfType <ModuleConnection>(); }
void Awake() { DontDestroyOnLoad(this.gameObject); moduleConnection = GameObject.FindObjectOfType <ModuleConnection>(); }