public void ConnectDevice4()
{
DeviceUsageEnum currentUsage = DeviceUsageEnum.出库;
var item = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == currentUsage);
DeviceSetting setting = item.Key;
if (!setting.IsSettingValid())
{
SV.Logger.Info($"{currentUsage.ToString()}设备: 配置无效，无法连接。");
return;
}
DeviceProxy deviceProxy = item.Value;
deviceProxy.Connected += () => { this.OnDeviceConnected(_frmExWarehouse); };
deviceProxy.Closing += () => { this.OnDeviceDisconnected(_frmExWarehouse); };
int status = deviceProxy.ConnectViaNetwork(item.Key.DeviceIpAddress, item.Key.DevicePort);
if (status == 0)
{
deviceProxy.IsConnected = true;
SV.Logger.Info($"{currentUsage.ToString()}设备: 成功建立连接。");
}
}
public async Task TestReceiveMessagingChannelAbandon()
{
IProtocolGatewayMessage msg = null;
IMessageConverter <IProtocolGatewayMessage> messageConverter = ProtocolGatewayMessageConverter.Value;
var dp = new DeviceProxy(Channel.Object, MockIdentity, messageConverter, ByteBufferConverter);
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(d => d.SendFeedbackMessageAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>())).Callback <string, FeedbackStatus>(
(mid, status) => { Assert.Equal(FeedbackStatus.Abandon, status); });
var connectionManager = new Mock <IConnectionManager>();
connectionManager.Setup(c => c.GetCloudConnection(It.IsAny <string>()))
.Returns(Task.FromResult(Option.Some(cloudProxy.Object)));
var deviceListner = new DeviceMessageHandler(MockIdentity, EdgeHub.Object, connectionManager.Object, DefaultMessageAckTimeout);
var messagingServiceClient = new MessagingServiceClient(deviceListner, messageConverter, ByteBufferConverter);
Channel.Setup(r => r.Handle(It.IsAny <IProtocolGatewayMessage>()))
.Callback <IProtocolGatewayMessage>(
m =>
{
msg = m;
messagingServiceClient.AbandonAsync(msg.Id);
});
messagingServiceClient.BindMessagingChannel(Channel.Object);
IMessage message = new EdgeMessage.Builder(new byte[] { 1, 2, 3 }).Build();
await dp.SendC2DMessageAsync(message);
Assert.NotNull(msg);
}
public void Create_Returns_Device_Proxy()
{
var device = Device.Create <Dummy>();
Assert.That(device, Is.InstanceOf <Dummy>());
Assert.That(DeviceProxy.IsProxy(device), Is.True);
}
public async Task TestReceiveMessagingChannelDispose()
{
IProtocolGatewayMessage msg = null;
IMessageConverter <IProtocolGatewayMessage> messageConverter = ProtocolGatewayMessageConverter.Value;
var dp = new DeviceProxy(Channel.Object, MockIdentity, messageConverter, ByteBufferConverter);
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(d => d.CloseAsync()).Callback(
() =>
{
});
var connectionManager = new Mock <IConnectionManager>();
connectionManager.Setup(c => c.GetCloudConnection(It.IsAny <string>()))
.Returns(Task.FromResult(Option.Some(cloudProxy.Object)));
var deviceListner = new DeviceMessageHandler(MockIdentity, EdgeHub.Object, connectionManager.Object);
var messagingServiceClient = new Mqtt.MessagingServiceClient(deviceListner, messageConverter, ByteBufferConverter);
Channel.Setup(r => r.Handle(It.IsAny <IProtocolGatewayMessage>()))
.Callback <IProtocolGatewayMessage>(
m =>
{
msg = m;
messagingServiceClient.DisposeAsync(new Exception("Some issue"));
});
messagingServiceClient.BindMessagingChannel(Channel.Object);
Core.IMessage message = new EdgeMessage.Builder(new byte[] { 1, 2, 3 }).Build();
await dp.SendC2DMessageAsync(message);
Assert.NotNull(msg);
}
public override bool?IsActivated(string deviceId)
{
Toolbox.Log.Trace("check activated...");
Toolbox.Log.LogDebug(nameof(IsActivated), $"deviceId: {deviceId}");
if (new Guid(deviceId) != Constants.Output1)
{
throw new MIPDriverException("E4.1 - Device does not support Output commands");
}
// TODO: If supported make request to device
try
{
string url = this.Container.ConnectionManager.Uri.AbsoluteUri; // ex http://localhost:5000
string switchId = this.Container.SettingsManager.GetSetting(new DeviceSetting(Constants.Switch1, deviceId, null)).Value;
string activatedState = this.Container.SettingsManager.GetSetting(new DeviceSetting(Constants.Switch1Activated, deviceId, null)).Value;
DeviceProxy proxy = new DeviceProxy();
Console.WriteLine("getting current state...");
string currentState = proxy.Get(url, switchId);
Console.WriteLine($"Got current state: {currentState}.");
Toolbox.Log.LogError(nameof(IsActivated), $"Just INFO! Got current state: {currentState}");
return(currentState == activatedState);
}
catch (ApplicationException ex)
{
Toolbox.Log.LogError(nameof(IsActivated), $"Most INFO! Coulden't get current state: {ex}");
return(null);
}
}
private void Init(DeviceConfigurationAdapter deviceConfig)
{
_deviceProxy = new DeviceProxy(deviceConfig);
_udpListener = new UdpListener(deviceConfig.UdpPort, SendMessage);
_webSocketClient = new WebSocketClient(deviceConfig.WebSocketClientConfig.ServerUrl, ReceiveMessage);
_healthThread = new HealthThread(CheckServerConnection, ReopenServerConnection);
}
/// <summary>
/// 检查设备状况
/// </summary>
private void CheckDeviceStatus()
{
var item = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == Function);
if (!item.Key.IsSettingValid())
{
pnlTopHint.Visible = true;
lblHint.Text = $"未正确配置{Function.ToString()}设备。";
}
else
{
if (_deviceProxy == null)
{
_deviceProxy = item.Value;
_deviceProxy.Closing += _deviceProxy_Closing;
}
if (!_deviceProxy.IsConnected)
{
pnlTopHint.Visible = true;
lblHint.Text = "设备已配置，但目前未建立连接。";
}
else
{
pnlTopHint.Visible = false;
}
}
}
public IHttpActionResult Save(DeviceProxy proxy)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (proxy.Id == 0)
{
db.DEVICES.Add(new DEVICES
{
IS_ENABLED = proxy.IsEnabled,
MAC_ADDRESS = proxy.MacAddress,
STORE = db.STORES.Find(proxy.Store.Id)
});
}
else
{
DEVICES row = db.DEVICES.Find(proxy.Id);
row.IS_ENABLED = proxy.IsEnabled;
row.MAC_ADDRESS = proxy.MacAddress;
row.STORE = db.STORES.Find(proxy.Store.Id);
}
try
{
db.SaveChanges();
return(Ok());
}
catch (Exception e)
{
string error = e.GetBaseException().ToString();
return(InternalServerError());
}
}
/// <summary>
/// 检查设备状况
/// </summary>
private void CheckDeviceStatus()
{
var item = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == POCO.DeviceUsageEnum.洗涤);
if (!item.Key.IsSettingValid())
{
pnlTopHint.Visible = true;
lblHint.Text = "未正确配置出库设备。";
}
else
{
if (_deviceProxy == null)
{
_deviceProxy = item.Value;
}
if (!_deviceProxy.IsConnected)
{
pnlTopHint.Visible = true;
lblHint.Text = "设备已配置，但目前尚未开始工作。";
}
else
{
pnlTopHint.Visible = false;
}
}
}
public void InterceptDevice_Associates_SetterIntercepter_With_Proxy()
{
var device = DeviceProxy.InterceptDevice(new Dummy()) as IProxyTargetAccessor;
var interceptors = device.GetInterceptors();
Assert.That(interceptors, Has.Length.EqualTo(1));
Assert.That(interceptors[0], Is.InstanceOf <SetterInterceptor>());
}
public void Create_Associates_SetterIntercepter_With_Proxy()
{
var device = DeviceProxy.Create <Dummy>();
var type = device.GetType();
var interceptors = type.GetField("__interceptors").GetValue(device) as IInterceptor[];
Assert.That(interceptors, Has.Length.EqualTo(1));
Assert.That(interceptors[0], Is.InstanceOf <SetterInterceptor>());
}
public void Map0_Populates_Transitions()
{
var dummy = DeviceProxy.Create <Dummy>();
Assert.That(dummy.Transitions, Contains.Key("zero"));
Assert.That(dummy.Transitions["zero"], Is.Not.Null);
var transitionValue = dummy.Transitions["zero"];
Assert.That(transitionValue.Handler, Is.Not.Null);
Assert.That(transitionValue.Fields, Is.Null);
}
public void Map6_Populates_Transitions()
{
var dummy = DeviceProxy.Create <Dummy>();
Assert.That(dummy.Transitions, Contains.Key("six"));
Assert.That(dummy.Transitions["six"], Is.Not.Null);
var transitionValue = dummy.Transitions["six"];
Assert.That(transitionValue.Handler, Is.Not.Null);
Assert.That(transitionValue.Fields, Has.Length.EqualTo(6));
}
private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bgw = sender as BackgroundWorker;
var deviceCache = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == Function);
DeviceProxy device = deviceCache.Value;
while (true)
{
if (bgw.CancellationPending)
{
break;
}
device.ClearIDBuffer();
List <string> tags = device.EPCMultiTagInventory();
foreach (string tagCode in tags)
{
TaskItem item = null;
if (!SV.TaskQueue.ContainsKey(tagCode))
{
//test only
item = new TaskItem()
{
TagCode = tagCode,
GoodsType = 1,
};
SV.TaskQueue.TryAdd(tagCode, item);
#if DEBUG
Console.WriteLine($"{Function.ToString()} ： " + tagCode);
#endif
}
else
{
item = SV.TaskQueue[tagCode];
if (item.StatesLog[TaskStates.Dry] != null)
{
// 表示已走过这个流程
}
else
{
bgw.ReportProgress(2, item);
}
}
}
Thread.Sleep(1000);
}
}
private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bgw = sender as BackgroundWorker;
var deviceCache = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == Function);
DeviceProxy device = deviceCache.Value;
while (true)
{
if (bgw.CancellationPending)
{
break;
}
device.ClearIDBuffer();
List <string> tags = device.EPCMultiTagInventory();
foreach (string tagCode in tags)
{
TaskItem item = null;
if (!SV.TaskQueue.ContainsKey(tagCode))
{
// test
item = new TaskItem()
{
TagCode = tagCode,
GoodsType = 1, //todo: 以后做判断
OrderSN = "ORDER_" + DateTime.Now.ToString("u", DateTimeFormatInfo.InvariantInfo)
};
SV.TaskQueue.TryAdd(tagCode, item);
//bgw.ReportProgress(2, item);
}
else
{
item = SV.TaskQueue[tagCode];
if (item.StatesLog[TaskStates.Wash] != null)
{
// 表示已走过这个流程
}
else
{
bgw.ReportProgress(2, item);
}
}
}
Thread.Sleep(1000);
}
}
public async Task Find_Intercepts_Found_Devices()
{
var server = new Server();
server.SetFindFunction((input) => {
return(Task.Run(() => (object)"[{\"id\":\"123\",\"type\":\"led\"}]"));
});
var results = await server.Find <LED>("n/a");
var led = results.First();
Assert.That(DeviceProxy.IsProxy(led), Is.True);
}
public void SetInactiveMakesInactive()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
Assert.True(sut.IsActive);
sut.SetInactive();
Assert.False(sut.IsActive);
}
public void Resolver_Removes_Proxy_Interceptors()
{
var resolver = new ZettaInteropContractResolver();
var device = Device.Create <LED>();
var settings = new JsonSerializerSettings();
settings.ContractResolver = resolver;
var json = JsonConvert.SerializeObject(device, settings);
var properties = JObject.Parse(json).Properties()
.Select((p) => p.Name).ToArray();
Assert.That(DeviceProxy.IsProxy(device), Is.True);
Assert.That(properties, Has.No.Member("__interceptors"));
}
public override void DeactivateOutput(string deviceId)
{
if (new Guid(deviceId) == Constants.Output1)
{
string url = this.Container.ConnectionManager.Uri.AbsoluteUri; // ex http://localhost:5000
string switchId = this.Container.SettingsManager.GetSetting(new DeviceSetting(Constants.Switch1, deviceId, null)).Value;
string state = this.Container.SettingsManager.GetSetting(new DeviceSetting(Constants.Switch1Deactivated, deviceId, null)).Value;
DeviceProxy proxy = new DeviceProxy();
Console.WriteLine("sending Dectivate...");
proxy.Send(url, switchId, state);
Console.WriteLine("Dectivate sent.");
Container.EventManager.NewEvent(deviceId, EventId.OutputDeactivated);
return;
}
throw new MIPDriverException("E5 - Device does not support Output commands");
}
public static IDevice Deserialize(IObject obj, string deviceString)
{
string[] tokens = deviceString.Split(';');
DeviceType type = DeviceType.Unknown;
string vendor = "Unknown";
if (tokens.Length > 2)
{
type = (DeviceType)Int32.Parse(tokens[2]);
}
if (tokens.Length > 1)
{
vendor = tokens[1];
}
IDevice d = new DeviceProxy(obj, tokens[0], "", vendor, type);
return(d);
}
public async Task Publishes_SetPropertyCommand_On_Device_Property_Set()
{
var source = new TaskCompletionSource <bool>();
var dummy = DeviceProxy.Create <Dummy>();
CommandBus.Instance.Subscribe <SetPropertyCommand>((command) => {
var c = (SetPropertyCommand)command;
Assert.That(c.PropertyName, Is.EqualTo("value"));
Assert.That(c.PropertyValue, Is.EqualTo(3));
source.SetResult(true);
});
dummy.Value = 3;
await source.Task;
}
public async Task CloseForwarded()
{
var connectionHandler = Mock.Of <IConnectionRegistry>();
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
Mock.Get(connectionHandler)
.Setup(h => h.CloseConnectionAsync(It.Is <IIdentity>(i => i == identity)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, true, connectionHandler, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.CloseAsync(new Exception());
Mock.Get(connectionHandler).VerifyAll();
}
async Task EnsureInitialized()
{
if (!this.isInitialized)
{
using (await this.initializationLock.LockAsync())
{
if (!this.isInitialized)
{
AmqpAuthentication amqpAuth;
// Check if Principal is SaslPrincipal
if (this.connection.Principal is SaslPrincipal saslPrincipal)
{
amqpAuth = saslPrincipal.AmqpAuthentication;
}
else
{
// Else the connection uses CBS authentication. Get AmqpAuthentication from the CbsNode
var cbsNode = this.connection.FindExtension <ICbsNode>();
if (cbsNode == null)
{
throw new InvalidOperationException("CbsNode is null");
}
amqpAuth = await cbsNode.GetAmqpAuthentication();
}
if (!amqpAuth.IsAuthenticated)
{
throw new InvalidOperationException("Connection not authenticated");
}
IClientCredentials identity = amqpAuth.ClientCredentials.Expect(() => new InvalidOperationException("Authenticated connection should have a valid identity"));
this.deviceListener = await this.connectionProvider.GetDeviceListenerAsync(identity);
var deviceProxy = new DeviceProxy(this, identity.Identity);
this.deviceListener.BindDeviceProxy(deviceProxy);
this.amqpAuthentication = amqpAuth;
this.isInitialized = true;
Events.InitializedConnectionHandler(identity.Identity);
}
}
}
}
public void DisconnectAllDevice()
{
foreach (var kp in SV.DeviceDictonary)
{
DeviceProxy deviceProxy = kp.Value;
if (deviceProxy.IsConnected)
{
int status = deviceProxy.Disconnect();
if (status == 0)
{
deviceProxy.IsConnected = false;
}
else
{
Debug.WriteLine("设备关闭失败。");
}
}
}
}
protected void InitializeControllerWrapper()
{
_controllerWrapper = new ControllerWrapper(_settings.MaxPlayers);
DeviceProxy deviceProxy = new DeviceProxy();
List <IMappableDevice> deviceList = deviceProxy.GetDevices(false);
MappingProxy mappingProxy = new MappingProxy();
foreach (PortMapping port in mappingProxy.PortMappings)
{
IMappableDevice device = deviceProxy.GetDevice(port.DeviceId, port.SubDeviceId, deviceList);
if (device != null)
{
RetroPadMapping mapping = mappingProxy.GetDeviceMapping(device);
device.Map(mapping);
_controllerWrapper.AddController(device, port.Port);
Logger.Debug("LibRetroFrontend: Mapped controller {0} to port {1}", device.DeviceName, port.Port);
}
}
}
public async Task DirectMethodCallForwarded()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var request = new DirectMethodRequest("123", "name", new byte[] { 1, 2, 3 }, TimeSpan.FromSeconds(60));
Mock.Get(directMethodHandler)
.Setup(h => h.CallDirectMethodAsync(It.Is <DirectMethodRequest>(m => m == request), It.Is <IIdentity>(i => i == identity)))
.Returns(Task.FromResult(new DirectMethodResponse("123", new byte[0], 200)));
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.InvokeMethodAsync(request);
Mock.Get(directMethodHandler).VerifyAll();
}
public async Task DesiredUpdateCallForwarded()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var desired = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(twinHandler)
.Setup(h => h.SendDesiredPropertiesUpdate(It.Is <IMessage>(m => m == desired), It.Is <IIdentity>(i => i == identity)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.OnDesiredPropertyUpdates(desired);
Mock.Get(directMethodHandler).VerifyAll();
}
public async Task Cloud2DeviceMessagesForwarded()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var message = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(c2dHandler)
.Setup(h => h.SendC2DMessageAsync(It.Is <IMessage>(m => m == message), It.Is <IIdentity>(i => i == identity)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.SendC2DMessageAsync(message);
Mock.Get(directMethodHandler).VerifyAll();
}
public async Task Save_Publishes_SaveCommand()
{
var source = new TaskCompletionSource <bool>();
var dummy = DeviceProxy.Create <Dummy>();
dummy.Id = "1234";
CommandBus.Instance.Subscribe <SaveCommand>((command) => {
var c = (SaveCommand)command;
Assert.That(c.DeviceId, Is.EqualTo("1234"));
CommandBus.Instance.RemoveAllSubscriptions();
source.SetResult(true);
});
await dummy.Save();
await source.Task;
}
public async Task EdgeHubIsIndirect()
{
var connectionHandler = Mock.Of <IConnectionRegistry>();
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new ModuleIdentity("hub", "device_id", "$edgeHub");
var twin = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(twinHandler)
.Setup(h => h.SendTwinUpdate(It.IsAny <IMessage>(), It.Is <IIdentity>(i => i == identity), It.Is <bool>(d => d == false)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, true, connectionHandler, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.SendTwinUpdate(twin);
Mock.Get(twinHandler).VerifyAll();
}
