/// <summary>
/// Begins the processing asynchronously.
/// </summary>
/// <returns>The async <see cref="Task"/>.</returns>
private async Task BeginProcessingAsync()
{
var runtimeContext = new RuntimeContext
{
AccountDetails = await CaasAuthentication.Authenticate(UserName, Password, Region),
LogProvider = new ConsoleLogProvider()
};
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(ResolvePath(Template), ResolvePath(Parameters));
var log = await taskExecutor.Execute(runtimeContext);
Console.WriteLine($"Result: {log.Status}");
WriteLog(log, ResolvePath(DeploymentLog));
Console.WriteLine($"Complete! Deployment log written to {DeploymentLog}.");
if (taskExecutor.Context.OutputParameters != null)
{
Console.WriteLine("OUTPUT PARAMETERS:");
foreach (var param in taskExecutor.Context.OutputParameters)
{
Console.WriteLine($"{param.Key}: {param.Value}");
}
}
}
protected override Task StopUpdatesNativeAsync()
{
_parentDevice.UpdatedCharacterteristicValue -= UpdatedNotify;
// JTS Added this if-statement. We found that on iOS, when you turn off Bluetooth during a connection it gets the characteristic into a stale state
// and the IsNotifying property remains True. Then attempting to reset it does not trigger the callback thus resulting in a deadlock.
if (_parentDevice.State == CBPeripheralState.Disconnected)
{
return(Task.FromResult(true));
}
return(TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs> >(
execute: () => _parentDevice.SetNotifyValue(false, _nativeCharacteristic),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
if (args.Characteristic.UUID != _nativeCharacteristic.UUID)
{
return;
}
if (args.Error != null)
{
reject(new Exception($"Stop Notifications: Error {args.Error.Description}"));
}
else
{
Trace.Message($"StopUpdates IsNotifying: {args.Characteristic.IsNotifying}");
complete(args.Characteristic.IsNotifying);
}
},
subscribeComplete: handler => _parentDevice.UpdatedNotificationState += handler,
unsubscribeComplete: handler => _parentDevice.UpdatedNotificationState -= handler));
}
public Task DisconnectDeviceAsync(IDevice device)
{
if (!ConnectedDevices.Contains(device))
{
Trace.Message("Disconnect async: device {0} not in the list of connected devices.", device.Name);
return(Task.FromResult(false));
}
return(TaskBuilder.FromEvent <bool, EventHandler <DeviceEventArgs>, EventHandler <DeviceErrorEventArgs> >(
execute: () => DisconnectDeviceNative(device),
getCompleteHandler: (complete, reject) => ((sender, args) =>
{
if (args.Device.Id == device.Id)
{
Trace.Message("DisconnectAsync Disconnected: {0} {1}", args.Device.Id, args.Device.Name);
complete(true);
}
}),
subscribeComplete: handler => DeviceDisconnected += handler,
unsubscribeComplete: handler => DeviceDisconnected -= handler,
getRejectHandler: reject => ((sender, args) =>
{
if (args.Device.Id == device.Id)
{
Trace.Message("DisconnectAsync", "Disconnect Error: {0} {1}", args.Device?.Id, args.Device?.Name);
reject(new Exception("Disconnect operation exception"));
}
}),
subscribeReject: handler => DeviceConnectionError += handler,
unsubscribeReject: handler => DeviceConnectionError -= handler));
}
public override async Task <Boolean> UpdateRssiAsync()
{
if (this._gatt == null || this._gattCallback == null)
{
Trace.Message(
"You can't read the RSSI value for disconnected devices except on discovery on Android. Device is {0}",
this.State);
return(false);
}
return(await TaskBuilder.FromEvent <Boolean, EventHandler <RssiReadCallbackEventArgs>, EventHandler>(
() => this._gatt.ReadRemoteRssi(),
(complete, reject) => (sender, args) =>
{
if (args.Error == null)
{
Trace.Message("Read RSSI for {0} {1}: {2}", this.Id, this.Name, args.Rssi);
this.Rssi = args.Rssi;
complete(true);
}
else
{
Trace.Message($"Failed to read RSSI for device {this.Id}-{this.Name}. {args.Error.Message}");
complete(false);
}
},
handler => this._gattCallback.RemoteRssiRead += handler,
handler => this._gattCallback.RemoteRssiRead -= handler,
reject => (sender, args) =>
{
reject(new Exception($"Device {this.Name} disconnected while updating rssi."));
},
handler => this._gattCallback.ConnectionInterrupted += handler,
handler => this._gattCallback.ConnectionInterrupted -= handler));
}
protected override Task <IEnumerable <IService> > GetServicesNativeAsync()
{
return(TaskBuilder.FromEvent <IEnumerable <IService>, EventHandler <NSErrorEventArgs> >(
execute: () => _nativeDevice.DiscoverServices(),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
// If args.Error was not null then the Service might be null
if (args.Error != null)
{
reject(new Exception($"Error while discovering services {args.Error.LocalizedDescription}"));
}
else if (_nativeDevice.Services == null)
{
// No service discovered.
reject(new Exception($"Error while discovering services: returned list is null"));
}
else
{
var services = _nativeDevice.Services
.Select(nativeService => new Service(nativeService, this))
.Cast <IService>().ToList();
complete(services);
}
},
subscribeComplete: handler => _nativeDevice.DiscoveredService += handler,
unsubscribeComplete: handler => _nativeDevice.DiscoveredService -= handler));
}
protected async Task StopUpdatesNativeAsync()
{
_gattCallback.CharacteristicValueUpdated -= OnCharacteristicValueChanged;
await TaskBuilder.EnqueueOnMainThreadAsync(() =>
{
if (!_gatt.SetCharacteristicNotification(NativeCharacteristic, false))
{
throw new CharacteristicReadException("GATT: SetCharacteristicNotification to false, FAILED.");
}
});
if (NativeCharacteristic.Descriptors.Count > 0)
{
var descriptors = await GetDescriptorsAsync();
var descriptor = descriptors.FirstOrDefault(d => d.Id.Equals(ClientCharacteristicConfigurationDescriptorId)) ??
descriptors.FirstOrDefault(); // fallback just in case manufacturer forgot
if (descriptor != null && (Properties.HasFlag(CharacteristicPropertyType.Notify) || Properties.HasFlag(CharacteristicPropertyType.Indicate)))
{
await descriptor.WriteAsync(BluetoothGattDescriptor.DisableNotificationValue.ToArray());
Trace.Message("Descriptor set value: DISABLE_NOTIFY");
}
}
else
{
Trace.Message("StopUpdatesNativeAsync descriptor set value FAILED: _nativeCharacteristic.Descriptors was empty");
}
}
public override async Task <bool> UpdateRssiAsync()
{
if (_gatt == null || _gattCallback == null)
{
Trace.Message("You can't read the RSSI value for disconnected devices except on discovery on Android. Device is {0}", State);
return(false);
}
return(await TaskBuilder.FromEvent <bool, EventHandler <RssiReadCallbackEventArgs>, EventHandler>(
execute : () => _gatt.ReadRemoteRssi(),
getCompleteHandler : (complete, reject) => ((sender, args) =>
{
if (args.Error == null)
{
Trace.Message("Read RSSI for {0} {1}: {2}", Id, Name, args.Rssi);
Rssi = args.Rssi;
complete(true);
}
else
{
Trace.Message($"Failed to read RSSI for device {Id}-{Name}. {args.Error.Message}");
complete(false);
}
}),
subscribeComplete : handler => _gattCallback.RemoteRssiRead += handler,
unsubscribeComplete : handler => _gattCallback.RemoteRssiRead -= handler,
getRejectHandler : reject => ((sender, args) =>
{
reject(new Exception($"Device {Name} disconnected while updating rssi."));
}),
subscribeReject : handler => _gattCallback.ConnectionInterrupted += handler,
unsubscribeReject : handler => _gattCallback.ConnectionInterrupted -= handler));
}
public void CircularDependency()
{
var templateFile = Path.Combine(_resourceFolder, "CircularDependency.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
}
public async Task ParseAndExecuteDeploymentTasks_Success()
{
var client = new FakeHttpClient();
client.AddResponse("/network/networkDomain/d5791a6d-2b69-47e2-be06-f26a2ec4bff8", "NetworkDomain_Get.json");
client.AddResponse("/network/vlan?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test VLAN", "GenericNotFound.json");
client.AddResponse("/network/deployVlan", "Vlan_Delpoy.json");
client.AddResponse("/network/vlan/997e2084-00b1-4d1d-96ce-099946679c6f", "Vlan_Get.json");
client.AddResponse("/imageWithDiskSpeed?name=RedHat 6 64-bit 2 CPU", "Image_Get.xml");
client.AddResponse("/server/server?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test Server", "GenericNotFound.json");
client.AddResponse("/server/deployServer", "Server_Deploy.json");
client.AddResponse("/server/server/b42b40e1-351a-4df9-b726-2ccff01f2767", "Server_Get.json");
client.AddResponse("/network/addPublicIpBlock", "PublicIpBlock_Add.json");
client.AddResponse("/network/publicIpBlock/996b066e-bdce-11e4-8c14-b8ca3a5d9ef8", "PublicIpBlock_Get.json");
client.AddResponse("/network/natRule?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&internalIp=10.0.0.8", "GenericNotFound.json");
client.AddResponse("/network/createNatRule", "NatRule_Create.json");
client.AddResponse("/network/natRule/a6b2e743-e330-4deb-a76e-0d9cb0b1d1bb", "NatRule_Get.json");
var templateFile = Path.Combine(_resourceFolder, "StandardTemplate.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Success, log.Status);
Assert.AreEqual("http://168.128.5.106/index.html", taskExecutor.Context.OutputParameters["ServerPublicUrl"]);
}
protected override Task WriteNativeAsync(byte[] data)
{
return(TaskBuilder.FromEvent <bool, EventHandler <DescriptorCallbackEventArgs>, EventHandler>(
execute: () => InternalWrite(data),
getCompleteHandler: (complete, reject) => ((sender, args) =>
{
if (args.Descriptor.Uuid != _nativeDescriptor.Uuid)
{
return;
}
if (args.Exception != null)
{
reject(args.Exception);
}
else
{
complete(true);
}
}),
subscribeComplete: handler => _gattCallback.DescriptorValueWritten += handler,
unsubscribeComplete: handler => _gattCallback.DescriptorValueWritten -= handler,
getRejectHandler: reject => ((sender, args) =>
{
reject(new Exception($"Device '{Characteristic.Service.Device.Id}' disconnected while writing descriptor with {Id}."));
}),
subscribeReject: handler => _gattCallback.ConnectionInterrupted += handler,
unsubscribeReject: handler => _gattCallback.ConnectionInterrupted -= handler));
}
public static async Task <IDevice> DiscoverDeviceAsync(this IAdapter adapter, Func <IDevice, bool> deviceFilter, CancellationToken cancellationToken = default)
{
var device = adapter.DiscoveredDevices.FirstOrDefault(deviceFilter);
if (device != null)
{
return(device);
}
if (adapter.IsScanning)
{
await adapter.StopScanningForDevicesAsync();
}
return(await TaskBuilder.FromEvent <IDevice, EventHandler <DeviceEventArgs>, EventHandler>(
execute : () => adapter.StartScanningForDevicesAsync(deviceFilter, cancellationToken),
getCompleteHandler : (complete, reject) => ((sender, args) =>
{
complete(args.Device);
adapter.StopScanningForDevicesAsync();
}),
subscribeComplete : handler => adapter.DeviceDiscovered += handler,
unsubscribeComplete : handler => adapter.DeviceDiscovered -= handler,
getRejectHandler : reject => ((sender, args) => { reject(new DeviceDiscoverException()); }),
subscribeReject : handler => adapter.ScanTimeoutElapsed += handler,
unsubscribeReject : handler => adapter.ScanTimeoutElapsed -= handler,
token : cancellationToken));
}
public async Task ParseAndExecuteDeploymentTasks_Success()
{
var client = new FakeHttpClient();
client.AddResponse("/network/networkDomain/d5791a6d-2b69-47e2-be06-f26a2ec4bff8", "NetworkDomain_Get.json");
client.AddResponse("/network/vlan?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test VLAN", "GenericNotFound.json");
client.AddResponse("/network/deployVlan", "Vlan_Delpoy.json");
client.AddResponse("/network/vlan/997e2084-00b1-4d1d-96ce-099946679c6f", "Vlan_Get.json");
client.AddResponse("/imageWithDiskSpeed?name=RedHat 6 64-bit 2 CPU", "Image_Get.xml");
client.AddResponse("/server/server?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test Server", "GenericNotFound.json");
client.AddResponse("/server/deployServer", "Server_Deploy.json");
client.AddResponse("/server/server/b42b40e1-351a-4df9-b726-2ccff01f2767", "Server_Get.json");
client.AddResponse("/network/addPublicIpBlock", "PublicIpBlock_Add.json");
client.AddResponse("/network/publicIpBlock/996b066e-bdce-11e4-8c14-b8ca3a5d9ef8", "PublicIpBlock_Get.json");
client.AddResponse("/network/natRule?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&internalIp=10.0.0.8", "GenericNotFound.json");
client.AddResponse("/network/createNatRule", "NatRule_Create.json");
client.AddResponse("/network/natRule/a6b2e743-e330-4deb-a76e-0d9cb0b1d1bb", "NatRule_Get.json");
var templateFile = Path.Combine(_resourceFolder, "StandardTemplate.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Success, log.Status);
Assert.AreEqual("http://168.128.5.106/index.html", taskExecutor.Context.OutputParameters["ServerPublicUrl"]);
}
protected override Task StopUpdatesNativeAsync()
{
_parentDevice.UpdatedCharacterteristicValue -= UpdatedNotify;
return(TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs> >(
execute: () => _parentDevice.SetNotifyValue(false, _nativeCharacteristic),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
if (args.Characteristic.UUID != _nativeCharacteristic.UUID)
{
return;
}
if (args.Error != null)
{
reject(new Exception($"Stop Notifications: Error {args.Error.Description}"));
}
else
{
Trace.Message($"StopUpdates IsNotifying: {args.Characteristic.IsNotifying}");
complete(args.Characteristic.IsNotifying);
}
},
subscribeComplete: handler => _parentDevice.UpdatedNotificationState += handler,
unsubscribeComplete: handler => _parentDevice.UpdatedNotificationState -= handler));
}
protected override Task <IList <ICharacteristic> > GetCharacteristicsNativeAsync()
{
return(TaskBuilder.FromEvent <IList <ICharacteristic>, EventHandler <CBServiceEventArgs> >(
execute: () => _device.DiscoverCharacteristics(_service),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
if (args.Error != null)
{
reject(new Exception($"Discover characteristics error: {args.Error.Description}"));
}
else
if (args.Service?.Characteristics == null)
{
reject(new Exception($"Discover characteristics error: returned list is null"));
}
else
{
var characteristics = args.Service.Characteristics
.Select(characteristic => new Characteristic(characteristic, _device, this))
.Cast <ICharacteristic>().ToList();
complete(characteristics);
}
},
subscribeComplete: handler => _device.DiscoveredCharacteristic += handler,
unsubscribeComplete: handler => _device.DiscoveredCharacteristic -= handler));
}
protected override Task StartUpdatesNativeAsync()
{
_parentDevice.UpdatedCharacterteristicValue -= UpdatedNotify;
_parentDevice.UpdatedCharacterteristicValue += UpdatedNotify;
//https://developer.apple.com/reference/corebluetooth/cbperipheral/1518949-setnotifyvalue
return(TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs> >(
execute: () => _parentDevice.SetNotifyValue(true, _nativeCharacteristic),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
if (args.Characteristic.UUID != _nativeCharacteristic.UUID)
{
return;
}
if (args.Error != null)
{
reject(new Exception($"Start Notifications: Error {args.Error.Description}"));
}
else
{
Trace.Message($"StartUpdates IsNotifying: {args.Characteristic.IsNotifying}");
complete(args.Characteristic.IsNotifying);
}
},
subscribeComplete: handler => _parentDevice.UpdatedNotificationState += handler,
unsubscribeComplete: handler => _parentDevice.UpdatedNotificationState -= handler));
}
public ServiceEventsHandler(DeploymentBoard deploymentBoard, FeedBoard feedBoard, DeploymentTaskProcessor taskProcessor, TaskBuilder builder)
{
_deploymentBoard = deploymentBoard;
_feedBoard = feedBoard;
_taskProcessor = taskProcessor;
_builder = builder;
}
public static async Task <IDevice> DiscoverDeviceAsync(this IAdapter adapter,
Func <IDevice, Boolean> deviceFilter, CancellationToken cancellationToken = default(CancellationToken))
{
IDevice device = adapter.DiscoveredDevices.FirstOrDefault(deviceFilter);
if (device != null)
{
return(device);
}
if (adapter.IsScanning)
{
await adapter.StopScanningForDevicesAsync();
}
return(await TaskBuilder.FromEvent <IDevice, EventHandler <DeviceEventArgs>, EventHandler>(
() => adapter.StartScanningForDevicesAsync(deviceFilter, cancellationToken),
(complete, reject) => (sender, args) =>
{
complete(args.Device);
adapter.StopScanningForDevicesAsync();
},
handler => adapter.DeviceDiscovered += handler,
handler => adapter.DeviceDiscovered -= handler,
reject => (sender, args) => { reject(new DeviceDiscoverException()); },
handler => adapter.ScanTimeoutElapsed += handler,
handler => adapter.ScanTimeoutElapsed -= handler,
cancellationToken));
}
// In here, we're defining a class, foo_Task, derived from our DefinedTask class. This allows us to write the bulk of the code
// in real C#, rather than attempting to build it here.
// This means that we have Task <- DefinedTask <- foo_Task.
// We also need a module and an assembly to hold the class, so we do that, too.
protected override void ExecuteTask()
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = _taskName + "_Assembly";
AssemblyBuilder assemblyBuilder =
AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(_taskName + "_Module");
// Now we've got an assembly and a module for the task to live in, we can define the actual task class.
TypeBuilder typeBuilder = moduleBuilder.DefineType(_taskName + "_Task", TypeAttributes.Public);
typeBuilder.SetParent(typeof(DefinedTask));
// It needs a [TaskName] attribute.
ConstructorInfo taskNameAttributeConstructor =
typeof(TaskNameAttribute).GetConstructor(new Type[] { typeof(string) });
CustomAttributeBuilder taskNameAttributeBuilder =
new CustomAttributeBuilder(taskNameAttributeConstructor, new object[] { _taskName });
typeBuilder.SetCustomAttribute(taskNameAttributeBuilder);
// We're done. Create it.
Type taskType = typeBuilder.CreateType();
// Stash the XML in our static. We'll need it in DefinedTask later.
DefinedTaskDefinitions.Add(_taskName, XmlNode);
// Hook that up into NAnt.
TaskBuilder taskBuilder = new TaskBuilder(taskType.Assembly, taskType.FullName);
TypeFactory.TaskBuilders.Add(taskBuilder);
}
private Task <bool> UpdateRssiNativeAsync()
{
return(TaskBuilder.FromEvent <bool, EventHandler <CBRssiEventArgs>, EventHandler <CBPeripheralErrorEventArgs> >(
execute: () => NativeDevice.ReadRSSI(),
getCompleteHandler: (complete, reject) => (sender, args) =>
{
if (args.Error != null)
{
reject(new Exception($"Error while reading rssi services {args.Error.LocalizedDescription}"));
}
else
{
Rssi = args.Rssi?.Int32Value ?? 0;
complete(true);
}
},
subscribeComplete: handler => NativeDevice.RssiRead += handler,
unsubscribeComplete: handler => NativeDevice.RssiRead -= handler,
getRejectHandler: reject => ((sender, args) =>
{
if (args.Peripheral.Identifier == NativeDevice.Identifier)
{
reject(new Exception($"Device {Name} disconnected while reading RSSI."));
}
}),
subscribeReject: handler => _bleCentralManagerDelegate.DisconnectedPeripheral += handler,
unsubscribeReject: handler => _bleCentralManagerDelegate.DisconnectedPeripheral -= handler));
}
public void Cancelled_Type_Task_T_Should_Be_Cancelled()
{
var target = TaskBuilder.GetCancelled(typeof(Task <int>));
target.IsCanceled.Should().BeTrue();
target.Should().BeOfType <Task <int> >();
}
public DeploymentTaskProcessor(TaskBuilder builder)
{
_builder = builder;
_taskQueue = new BlockingCollection <DeploymentTaskRequest>();
_cancellationSource = new CancellationTokenSource();
_processingTask = Task.Run((Action)ProcessInternal);
}
protected override Task <bool> WriteNativeAsync(byte[] data)
{
Task <bool> task;
if (CharacteristicWriteType == CBCharacteristicWriteType.WithResponse)
{
task = TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs> >(
execute: () => { },
getCompleteHandler: complete => (sender, args) =>
{
if (args.Characteristic.UUID != _nativeCharacteristic.UUID)
{
return;
}
complete(args.Error == null);
},
subscribeComplete: handler => _parentDevice.WroteCharacteristicValue += handler,
unsubscribeComplete: handler => _parentDevice.WroteCharacteristicValue -= handler);
}
else
{
task = Task.FromResult(true);
}
var nsdata = NSData.FromArray(data);
_parentDevice.WriteValue(nsdata, _nativeCharacteristic, CharacteristicWriteType);
return(task);
}
public void Cancelled_Type_Task_Should_Be_Cancelled()
{
var target = TaskBuilder.GetCancelled(typeof(Task));
target.IsCanceled.Should().BeTrue();
target.Should().BeAssignableTo <Task>();
}
protected override async Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType)
{
_nativeCharacteristic.WriteType = writeType.ToNative();
if (writeType == CharacteristicWriteType.WithoutResponse)
{
return(InternalWrite(data));
}
return(await TaskBuilder.FromEvent <bool, EventHandler <CharacteristicWriteCallbackEventArgs>, EventHandler>(
execute : () => InternalWrite(data),
getCompleteHandler : (complete, reject) => ((sender, args) =>
{
if (args.Characteristic.Uuid == _nativeCharacteristic.Uuid)
{
complete(args.Exception == null);
}
}),
subscribeComplete : handler => _gattCallback.CharacteristicValueWritten += handler,
unsubscribeComplete : handler => _gattCallback.CharacteristicValueWritten -= handler,
getRejectHandler : reject => ((sender, args) =>
{
reject(new Exception($"Device '{Service.Device.Id}' disconnected while writing characteristic with {Id}."));
}),
subscribeReject : handler => _gattCallback.ConnectionInterrupted += handler,
unsubscribeReject : handler => _gattCallback.ConnectionInterrupted -= handler));
}
protected override Task WriteNativeAsync(Byte[] data)
{
return(TaskBuilder.FromEvent <Boolean, EventHandler <DescriptorCallbackEventArgs>, EventHandler>(
() => this.InternalWrite(data),
(complete, reject) => (sender, args) =>
{
if (args.Descriptor.Uuid != this._nativeDescriptor.Uuid)
{
return;
}
if (args.Exception != null)
{
reject(args.Exception);
}
else
{
complete(true);
}
},
handler => this._gattCallback.DescriptorValueWritten += handler,
handler => this._gattCallback.DescriptorValueWritten -= handler,
reject => (sender, args) =>
{
reject(new Exception(
$"Device '{this.Characteristic.Service.Device.Id}' disconnected while writing descriptor with {this.Id}."));
},
handler => this._gattCallback.ConnectionInterrupted += handler,
handler => this._gattCallback.ConnectionInterrupted -= handler));
}
/// <summary>
/// Condition the specified builder and function.
/// </summary>
/// <returns>The condition.</returns>
/// <param name="builder">Builder.</param>
/// <param name="function">Function.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static TaskBuilder <T> Condition <T>
(
this TaskBuilder <T> builder,
TaskCondition <T> .Delegate function
)
{
return(builder.Push(new TaskCondition <T>(function)));
}
/// <summary>
/// Wait the specified builder and duration.
/// </summary>
/// <returns>The wait.</returns>
/// <param name="builder">Builder.</param>
/// <param name="duration">Duration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static TaskBuilder <T> Wait <T>
(
this TaskBuilder <T> builder,
float duration
)
{
return(builder.Push(new TaskWait <T>(duration)));
}
public void TestMethod1()
{
BilibiliVideoFetcher.Classes.BilibiliVideoInfo info;
Console.WriteLine(info = TaskBuilder.GetVideoInfoFromNativeApi(11292577));
Assert.AreEqual(info.Code, 0);
Console.WriteLine(info = TaskBuilder.GetVideoInfoFromNativeApi(11292578));
Assert.IsTrue(info.Code < 0);
}
/// <summary>
/// Action the specified builder and action.
/// </summary>
/// <returns>The action.</returns>
/// <param name="builder">Builder.</param>
/// <param name="action">Action.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static TaskBuilder <T> Action <T>
(
this TaskBuilder <T> builder,
TaskAction <T> .Delegate action
)
{
return(builder.Push(new TaskAction <T>(action)));
}
public void TestMethod1()
{
var file = Path.Combine(Directory.GetCurrentDirectory(), "../../../../../../tasks/VSTeamServicesTaskGenerator/bin/Debug/net452/win7-x64/VSTeamServicesTaskGenerator.exe");
if (File.Exists(file))
{
Console.WriteLine(TaskBuilder.BuildTask(file).ToString(Newtonsoft.Json.Formatting.Indented));
}
}
/// <summary>
/// Wait the specified builder, min and max.
/// </summary>
/// <returns>The wait.</returns>
/// <param name="builder">Builder.</param>
/// <param name="min">Minimum.</param>
/// <param name="max">Max.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static TaskBuilder <T> Wait <T>
(
this TaskBuilder <T> builder,
float min,
float max
)
{
return(builder.Push(new TaskWait <T>(min, max)));
}
public void WhenGivenATaskTypeWithServicesInConstructor_CanBuildIt()
{
var kernel = new StandardKernel();
kernel.Bind<IMyService>().To<TestMyService>();
var builder = new TaskBuilder(kernel);
var task = builder.BuildTask<TestTaskRequiringService> ();
Assert.IsNotNull (task);
Assert.IsInstanceOf(typeof(TestMyService), task.Service);
}
public async Task ParseAndExecuteDeploymentTasks_Failed()
{
var client = new FakeHttpClient();
client.AddResponse("/network/networkDomain/d5791a6d-2b69-47e2-be06-f26a2ec4bff8", "NetworkDomain_Get.json");
client.AddResponse("/network/vlan?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test VLAN", "GenericNotFound.json");
client.AddResponse("/network/deployVlan", "GenericError.json", HttpStatusCode.BadRequest);
var templateFile = Path.Combine(_resourceFolder, "StandardTemplate.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Failed, log.Status);
Assert.AreEqual(1, log.Resources.Count);
Assert.AreEqual(ResourceLogStatus.Failed, log.Resources[0].DeploymentStatus);
Assert.AreEqual("UNEXPECTED_ERROR", log.Resources[0].Error.ResponseCode);
}
public void CreateTask_ReturnsCorrect_DueDateAndSubjectAndTags()
{
string[] args = "Köp vin till festen -p -tm".Split(' ');
var argumentsParserMock = new Mock<IArgumentParser>();
argumentsParserMock.Setup(a => a.GetSubject(It.IsAny<string[]>())).Returns("Köp vin till festen");
var optionsParserMock = new Mock<IOptionsParser>();
optionsParserMock.SetupGet(o => o.DueDate).Returns(DateTime.Parse("2012-11-16"));
optionsParserMock.SetupGet(o => o.Tags).Returns(new List<string> {"Personal"});
ITaskBuilder tb = new TaskBuilder(args, argumentsParserMock.Object, optionsParserMock.Object);
ITaskDTO task = tb.CreateTask();
Assert.Equal(DateTime.Parse("2012-11-16"), task.DueDate);
Assert.Equal("Köp vin till festen", task.Subject);
argumentsParserMock.VerifyAll();
optionsParserMock.VerifyAll();
}
private static void Main(string[] args)
{
ContainerBootstrapper.BootstrapStructureMap(args);
IContainer container = ObjectFactory.Container;
IList<ITaskManager> taskManagers = container.GetAllInstances<ITaskManager>();
if (ShouldUsageBeShown(args)) {
ShowUsage(taskManagers);
return;
}
var argumentParser = ObjectFactory.GetInstance<IArgumentParser>();
var optionParser = ObjectFactory.GetInstance<IOptionsParser>();
ITaskBuilder taskBuilder = new TaskBuilder(args, argumentParser, optionParser);
ITaskDTO taskDto = taskBuilder.CreateTask();
bool taskCreated = false;
ITaskManager taskManagerToRun = ProviderMatcher.GetMatchingTaskManager(args, taskManagers);
taskManagerToRun.CreateTask(taskDto);
}
public void Task_can_be_added_to_BacklogItem()
{
var addViewTask = new TaskBuilder()
.WithName("Create asp.net mvc listview")
.OwnedBy("Stijn Volders")
.WithEstimatedHours(2)
.Build();
var createControllerMethodsTask = new TaskBuilder()
.WithName("Create BacklogItemController with listview support")
.OwnedBy("Stijn Volders")
.WithEstimatedHours(1)
.Build();
var backLogItem = _session.Load<BacklogItem>(1);
backLogItem.AddTask(addViewTask);
backLogItem.AddTask(createControllerMethodsTask);
_session.SaveChanges();
Assert.IsTrue(backLogItem.Tasks.Any());
}
public void WhenGivenATaskType_CanBuildIt()
{
var task = new TaskBuilder ().BuildTask<TestTask> ();
Assert.IsNotNull (task);
}
public async Task ParseAndExecuteDeletionTasks_Failed()
{
var client = new FakeHttpClient();
client.AddResponse("/network/deleteNatRule", "NatRule_Delete.json");
client.AddResponse("/network/natRule/a6b2e743-e330-4deb-a76e-0d9cb0b1d1bb", "NatRule_Get_NotFound.json", HttpStatusCode.BadRequest);
client.AddResponse("/network/removePublicIpBlock", "GenericError.json", HttpStatusCode.BadRequest);
var logFile = Path.Combine(_resourceFolder, "StandardTemplateLog.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentLog(logFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Failed, log.Status);
Assert.AreEqual(2, log.Resources.Count);
Assert.AreEqual(ResourceLogStatus.Deleted, log.Resources[0].DeploymentStatus);
Assert.AreEqual(ResourceLogStatus.Failed, log.Resources[1].DeploymentStatus);
Assert.AreEqual("UNEXPECTED_ERROR", log.Resources[1].Error.ResponseCode);
}
public void CircularDependency()
{
var templateFile = Path.Combine(_resourceFolder, "CircularDependency.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
}
public void Save(Loan loan, SqlTransaction transaction)
{
var taskBuilder = new TaskBuilder();
taskBuilder.CreateLoanApprovalTasks(loan);
}
public async Task ParseAndExecuteDeletionTasks_Success()
{
var client = new FakeHttpClient();
client.AddResponse("/network/deleteNatRule", "NatRule_Delete.json");
client.AddResponse("/network/natRule/a6b2e743-e330-4deb-a76e-0d9cb0b1d1bb", "NatRule_Get_NotFound.json", HttpStatusCode.BadRequest);
client.AddResponse("/network/removePublicIpBlock", "PublicIpBlock_Delete.json");
client.AddResponse("/network/publicIpBlock/996b066e-bdce-11e4-8c14-b8ca3a5d9ef8", "PublicIpBlock_Get_NotFound.json", HttpStatusCode.BadRequest);
client.AddResponse("/server/deleteServer", "Server_Delete.json");
client.AddResponse("/server/server/b42b40e1-351a-4df9-b726-2ccff01f2767", "Server_Get_NotFound.json", HttpStatusCode.BadRequest);
client.AddResponse("/network/deleteVlan", "Vlan_Delete.json");
client.AddResponse("/network/vlan/997e2084-00b1-4d1d-96ce-099946679c6f", "Vlan_Get_NotFound.json", HttpStatusCode.BadRequest);
var logFile = Path.Combine(_resourceFolder, "StandardTemplateLog.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentLog(logFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Success, log.Status);
}
