public void Perform_MustAbortIfUserDeniesAutoTermination()
{
var initialization = new InitializationResult();
var args = default(ActionRequiredEventArgs);
initialization.RunningApplications.Add(new RunningApplication(default(string)));
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(initialization);
sut.ActionRequired += (a) =>
{
args = a;
if (a is ApplicationTerminationEventArgs t)
{
t.TerminateProcesses = false;
}
};
var result = sut.Perform();
monitor.Verify(m => m.Initialize(It.Is <ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
monitor.VerifyNoOtherCalls();
Assert.AreEqual(OperationResult.Aborted, result);
Assert.IsInstanceOfType(args, typeof(ApplicationTerminationEventArgs));
}
public async Task InitializeAsync(
CTLConfig config,
CosmosClient cosmosClient,
ILogger logger)
{
if (!TryParseReadWriteQueryPercentages(config.ReadWriteQueryPercentage, out this.readWriteQueryPercentage))
{
logger.LogError("Cannot correctly parse {0} = {1}", nameof(config.ReadWriteQueryPercentage), config.ReadWriteQueryPercentage);
return;
}
this.initializationResult = await CreateDatabaseAndContainersAsync(config, cosmosClient);
if (this.initializationResult.CreatedDatabase)
{
logger.LogInformation("Created database for execution");
}
if (this.initializationResult.CreatedContainers.Count > 0)
{
logger.LogInformation("Created {0} collections for execution", this.initializationResult.CreatedContainers.Count);
}
logger.LogInformation("Pre-populating {0} documents", config.Operations);
this.createdDocuments = await PopulateDocumentsAsync(config, logger, this.initializationResult.Containers);
}
public void Perform_MustTerminateRunningApplications()
{
var application1 = new RunningApplication(default(string));
var application2 = new RunningApplication(default(string));
var application3 = new RunningApplication(default(string));
var initialization = new InitializationResult();
var args = default(ActionRequiredEventArgs);
initialization.RunningApplications.Add(application1);
initialization.RunningApplications.Add(application2);
initialization.RunningApplications.Add(application3);
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(initialization);
monitor.Setup(m => m.TryTerminate(It.IsAny <RunningApplication>())).Returns(true);
sut.ActionRequired += (a) =>
{
args = a;
if (a is ApplicationTerminationEventArgs t)
{
t.TerminateProcesses = true;
}
};
var result = sut.Perform();
monitor.Verify(m => m.Initialize(It.Is <ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
monitor.Verify(m => m.TryTerminate(It.Is <RunningApplication>(a => a == application1)), Times.Once);
monitor.Verify(m => m.TryTerminate(It.Is <RunningApplication>(a => a == application2)), Times.Once);
monitor.Verify(m => m.TryTerminate(It.Is <RunningApplication>(a => a == application3)), Times.Once);
Assert.AreEqual(OperationResult.Success, result);
Assert.IsInstanceOfType(args, typeof(ApplicationTerminationEventArgs));
}
private void InitializeWhitelist(ApplicationSettings settings, InitializationResult result)
{
foreach (var application in settings.Whitelist)
{
whitelist.Add(application);
}
logger.Debug($"Initialized whitelist with {whitelist.Count} applications{(whitelist.Any() ? $": {string.Join(", ", whitelist.Select(a => a.ExecutableName))}" : ".")}");
foreach (var process in processes)
{
foreach (var application in whitelist)
{
var isWhitelisted = BelongsToApplication(process, application);
if (isWhitelisted)
{
if (!application.AllowRunning && !application.AutoTerminate)
{
AddForTermination(application.ExecutableName, process, result);
}
else if (!application.AllowRunning && application.AutoTerminate && !TryTerminate(process))
{
AddFailed(application.ExecutableName, process, result);
}
break;
}
}
}
}
/// <summary>
/// Initializes the MC9808.
/// </summary>
/// <returns>Returns an InitializationResult value indicating if the
/// initialization was success or not.</returns>
public async Task <InitializationResult> Initialize()
{
InitializationResult returnValue = InitializationResult.None;
// ***
// *** Get a selector string that will return all I2C controllers on the system
// ***
string aqs = I2cDevice.GetDeviceSelector();
// ***
// *** Find the I2C bus controller device with our selector string
// ***
var dis = await DeviceInformation.FindAllAsync(aqs).AsTask();
if (dis.Count > 0)
{
var settings = new I2cConnectionSettings(this.DeviceAddress);
settings.BusSpeed = this.BusSpeed;
// ***
// *** Create an I2cDevice with our selected bus controller and I2C settings
// ***
this.Device = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (this.Device != null)
{
IsInitialized = true;
// ***
// *** Check the Manufacturing and Device ID
// ***
if (this.ManufacturingId == 0x54 && this.DeviceId.Id == 0x04)
{
returnValue = InitializationResult.Successful;
}
else
{
IsInitialized = false;
returnValue = InitializationResult.DeviceNotFound;
}
}
else
{
// ***
// *** Slave address n on I2C Controller is currently in use by
// *** another application. Please ensure that no other applications are using I2C.
// ***
returnValue = InitializationResult.DeviceInUse;
}
}
else
{
// ***
// *** No I2C controllers were found on the system
// ***
returnValue = InitializationResult.NoI2cController;
}
return(returnValue);
}
public InitializationResult Initialize(ApplicationSettings settings)
{
var result = new InitializationResult();
InitializeProcesses();
InitializeBlacklist(settings, result);
InitializeWhitelist(settings, result);
return(result);
}
/// <summary>
/// Create the database and the required number of collections.
/// </summary>
private static async Task <InitializationResult> CreateDatabaseAndContainersAsync(
CTLConfig config,
CosmosClient cosmosClient)
{
List <string> createdContainers = new List <string>();
List <Container> containers = new List <Container>();
InitializationResult result = new InitializationResult()
{
CreatedDatabase = false
};
Database database;
try
{
database = await cosmosClient.GetDatabase(config.Database).ReadAsync();
}
catch (CosmosException exception) when(exception.StatusCode == System.Net.HttpStatusCode.NotFound)
{
DatabaseResponse databaseResponse = await cosmosClient.CreateDatabaseAsync(config.Database, config.Throughput);
result.CreatedDatabase = true;
database = databaseResponse.Database;
}
int collectionCount = config.CollectionCount;
if (collectionCount <= 0)
{
collectionCount = 1;
}
for (int i = 1; i <= collectionCount; i++)
{
string containerName = $"{config.Collection}_{i}";
Container container;
try
{
container = await database.GetContainer(containerName).ReadContainerAsync();
}
catch (CosmosException exception) when(exception.StatusCode == System.Net.HttpStatusCode.NotFound)
{
container = await database.CreateContainerAsync(containerName, ReadWriteQueryScenario.DefaultPartitionKeyPath);
createdContainers.Add(containerName);
}
containers.Add(container);
}
result.CreatedContainers = createdContainers;
result.Containers = containers;
return(result);
}
private void AddFailed(string name, IProcess process, InitializationResult result)
{
var application = result.FailedAutoTerminations.FirstOrDefault(a => a.Name == name);
if (application == default(RunningApplication))
{
application = new RunningApplication(name);
result.FailedAutoTerminations.Add(application);
}
application.Processes.Add(process);
logger.Error($"Process {process} belongs to application '{application.Name}' and could not be terminated automatically!");
}
private void AddForTermination(string name, IProcess process, InitializationResult result)
{
var application = result.RunningApplications.FirstOrDefault(a => a.Name == name);
if (application == default(RunningApplication))
{
application = new RunningApplication(name);
result.RunningApplications.Add(application);
}
application.Processes.Add(process);
logger.Debug($"Process {process} belongs to application '{application.Name}' and needs to be terminated.");
}
} // Is32BitWindow
public static AppUiConfiguration LoadRegistrySettings(out InitializationResult initializationResult)
{
Is32BitWindows = WindowsBitness.Is32BitWindows();
var result = AppUiConfiguration.LoadRegistryAppConfiguration(out initializationResult);
#if DEBUG
RedistFolder = Path.Combine(result.Folders.Base, "Bin\\Redist");
#else
RedistFolder = Path.Combine(result.Folders.Install, "Redist");
#endif
return(result);
} // LoadRegistrySettings
public Boolean Initialize(
String taskName,
IDictionary <String, TaskPropertyInfo> parameterGroup,
String taskBody,
IBuildEngine taskFactoryLoggingHost
)
{
InitializationResult initResult = null;
try
{
var taskBodyElement = XElement.Parse(taskBody);
initResult = InitializeAsync(
new InitializationArgs(
taskBodyElement.ElementAnyNS(NUGET_FW)?.Value,
taskBodyElement.ElementAnyNS(NUGET_RID)?.Value,
taskBodyElement.ElementAnyNS(NUGET_FW_PACKAGE_ID)?.Value,
taskBodyElement.ElementAnyNS(NUGET_FW_PACKAGE_VERSION)?.Value,
false,
taskBodyElement.ElementAnyNS(NUGET_CONFIG_FILE)?.Value,
taskBodyElement.ElementAnyNS(PACKAGE_ID)?.Value,
taskBodyElement.ElementAnyNS(PACKAGE_VERSION)?.Value,
taskBodyElement.ElementAnyNS(PACKAGE_ID_IS_SELF)?.Value?.ParseAsBooleanSafe() ?? false,
taskBodyElement.ElementAnyNS(ASSEMBLY_PATH)?.Value,
(taskBodyElement.ElementAnyNS(TASK_NAME)?.Value).DefaultIfNullOrEmpty(taskName),
taskBodyElement.ElementAnyNS(TASK_METHOD_NAME)?.Value,
taskFactoryLoggingHost
)
).GetAwaiter().GetResult();
}
catch (Exception exc)
{
if (taskFactoryLoggingHost == null)
{
Console.Error.WriteLine("Error in initialization: " + exc);
}
else
{
taskFactoryLoggingHost.LogErrorEvent("NMSBT001".AsNuGetMSBuildError(
taskFactoryLoggingHost.ProjectFileOfTaskNode,
null,
exc: exc
));
}
}
this._initResult = initResult;
return(initResult != null);
}
public InitializationResult InitializeService(string url, string token, MasterServiceData data, EncryptionInfo encryptionInfo)
{
StatusServiceClient client = StatusServiceClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedData = _objectSerializationProvider.Serialize(data);
string encryptedData = _symmetricEncryptionProvider.Encrypt(serializedData, encryptionInfo);
string result = client.InitializeService(encryptedToken, encryptedData);
string decryptedResult = _symmetricEncryptionProvider.Decrypt(result, encryptionInfo);
InitializationResult initializationResult = _objectSerializationProvider.Deserialize <InitializationResult>(decryptedResult);
return(initializationResult);
}
void Ready()
{
Receive <StartProjection>(sp =>
{
try
{
var props = PropsFactory.Create(sp.ProjectionType);
var projection = Context.ActorOf(props);
projection.Ask(new InitializeProjection(_projectionStreams, _options)).PipeTo(Sender);
}
catch (Exception ex)
{
Sender.Tell(InitializationResult.Failed(ex));
}
});
}
public void Perform_MustFailIfAutoTerminationFails()
{
var initialization = new InitializationResult();
var args = default(ActionRequiredEventArgs);
initialization.FailedAutoTerminations.Add(new RunningApplication(default(string)));
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(initialization);
sut.ActionRequired += (a) => args = a;
var result = sut.Perform();
monitor.Verify(m => m.Initialize(It.Is <ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
monitor.VerifyNoOtherCalls();
Assert.AreEqual(OperationResult.Failed, result);
Assert.IsInstanceOfType(args, typeof(ApplicationTerminationFailedEventArgs));
}
public static async Task <InitializationResult> CreateDatabaseAndContainerAsync(
CTLConfig config,
CosmosClient cosmosClient)
{
InitializationResult result = new InitializationResult()
{
CreatedDatabase = false,
CreatedContainer = false
};
Database database;
try
{
database = await cosmosClient.GetDatabase(config.Database).ReadAsync();
}
catch (CosmosException exception) when(exception.StatusCode == HttpStatusCode.NotFound)
{
await cosmosClient.CreateDatabaseAsync(config.Database, config.DatabaseThroughput);
result.CreatedDatabase = true;
database = cosmosClient.GetDatabase(config.Database);
}
Container container;
try
{
container = await database.GetContainer(config.Collection).ReadContainerAsync();
}
catch (CosmosException exception) when(exception.StatusCode == HttpStatusCode.NotFound)
{
if (config.Throughput > 0)
{
await database.CreateContainerAsync(config.Collection, $"/{config.CollectionPartitionKey}", config.Throughput);
}
else
{
await database.CreateContainerAsync(config.Collection, $"/{config.CollectionPartitionKey}");
}
result.CreatedContainer = true;
}
return(result);
}
private async void InitializeForJobAsync(Job job)
{
using (Trace.Log())
{
initialized = false;
activeJob = job;
InitializationResult initResult;
try
{
initResult = await connection.Initialize(job.Config).ConfigureAwait(true);
if (initResult.success)
{
Console.WriteLine($"Agent initialized {Identifier}");
initialized = true;
Capacity = initResult.capacity;
CapacityChanged?.Invoke(this, Capacity);
RequestTasks();
return;
}
}
catch (Exception e)
{
initResult = new InitializationResult
{
success = false,
errorMessage = e.ToString()
};
}
Console.WriteLine($"Agent initialization error {Identifier}");
Console.WriteLine(initResult.errorMessage);
dispatcher.ReleaseAgent(Identifier);
}
}
public bool InitializeService(Service service)
{
string token = _packingService.PackToken(service.GetManagementToken());
StatusRequestResult statusResult = _serviceStatusProvider.GetServiceStatus(service.ManagementUrl, token, GetManagementStandardEncryptionInfo(service));
if (statusResult.IsInitialized == true)
{
return(false);
}
if (statusResult.IsActive == true)
{
return(false);
}
if (statusResult.IsRequestValid == false)
{
return(false);
}
MasterServiceData masterData = new MasterServiceData();
masterData.ServiceId = service.UniquePad;
masterData.Token = service.Token;
masterData.Initialized = true;
masterData.ClientInboundKey = service.GetClientInboundKeyPart1();
masterData.ClientOutboundKey = service.GetClientOutboundKeyPart1();
masterData.ManagementInboundKey = service.GetManagementInboundKeyPart1();
masterData.ManagementOutboundKey = service.GetManagementOutboundKeyPart1();
InitializationResult result = _serviceStatusProvider.InitializeService(service.ManagementUrl, token, masterData,
GetManagementStandardEncryptionInfo(service));
if (!result.WasInitializionSucessful)
{
return(false);
}
return(true);
}
public async Task <InitializationResult> InitializeAsync()
{
var result = new InitializationResult()
{
PermissionStatus = PermissionStatus.Unknown,
Success = false
};
// Android uses location permissions for BLE
var status = await Xamarin.Essentials.Permissions.CheckStatusAsync <Xamarin.Essentials.Permissions.LocationWhenInUse>();
result.PermissionStatus = status;
if (status != PermissionStatus.Granted)
{
status = await Xamarin.Essentials.Permissions.RequestAsync <Xamarin.Essentials.Permissions.LocationWhenInUse>();
result.PermissionStatus = status;
}
result.Success = result.PermissionStatus == PermissionStatus.Granted;
if (result.Success)
{
var adapter = BluetoothAdapter.DefaultAdapter;
if (adapter == null)
{
result.Success = false;
result.PermissionStatus = PermissionStatus.Disabled;
}
else
{
if (!adapter.IsEnabled)
{
result.Success = false;
result.PermissionStatus = PermissionStatus.Disabled;
}
}
}
return(result);
}
public async Task <InitializationResult> InitializeAsync()
{
var status = await Xamarin.Essentials.Permissions.CheckStatusAsync <BluetoothCentralPermissions>();
if (status != PermissionStatus.Granted)
{
status = await Xamarin.Essentials.Permissions.RequestAsync <BluetoothCentralPermissions>();
if (status != PermissionStatus.Granted)
{
return(new InitializationResult()
{
PermissionStatus = status,
Success = status == PermissionStatus.Granted
});
}
}
var peripheralStatus = await Xamarin.Essentials.Permissions.CheckStatusAsync <BluetoothPeripheralPermissions>();
if (peripheralStatus != PermissionStatus.Granted)
{
peripheralStatus = await Xamarin.Essentials.Permissions.RequestAsync <BluetoothPeripheralPermissions>();
return(new InitializationResult()
{
PermissionStatus = peripheralStatus,
Success = status == PermissionStatus.Granted
});
}
var result = new InitializationResult()
{
PermissionStatus = peripheralStatus,
Success = status == PermissionStatus.Granted
};
return(result);
}
public string InitializeService(string token, string data)
{
InitializationResult result = new InitializationResult();
try
{
if (!_controlService.ValidateManagementToken(token))
{
result.WasInitializionSucessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
string decryptedData = _controlService.DecryptSymmetricResponse(data);
MasterServiceData masterData = _serializationProvider.Deserialize <MasterServiceData>(decryptedData);
MasterServiceData masterData1 = _masterService.SetMasterServiceData(masterData);
if (masterData1 == null)
{
result.WasInitializionSucessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
result.WasInitializionSucessful = true;
string path = _commonService.GetPath();
if (File.Exists(path + "\\AllowDatabaseTest.emp"))
{
File.Delete(path + "\\AllowDatabaseTest.emp");
}
}
catch (Exception ex)
{
LoggingHelper.LogException(ex);
}
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
public async Task InitializeAsync(
CTLConfig config,
CosmosClient cosmosClient,
ILogger logger)
{
this.initializationResult = await CreateDatabaseAndContainerAsync(config, cosmosClient);
if (this.initializationResult.CreatedDatabase)
{
logger.LogInformation("Created database for execution");
}
if (this.initializationResult.CreatedContainer)
{
logger.LogInformation("Created collection for execution");
}
if (config.PreCreatedDocuments > 0)
{
logger.LogInformation("Pre-populating {0} documents", config.PreCreatedDocuments);
await Utils.PopulateDocumentsAsync(config, logger, new List <Container>() { cosmosClient.GetContainer(config.Database, config.Collection) });
}
}
public async Task InitializeAsync(
CTLConfig config,
CosmosClient cosmosClient,
ILogger logger)
{
this.initializationResult = await CreateDatabaseAndContainerAsync(config, cosmosClient);
if (this.initializationResult.CreatedDatabase)
{
logger.LogInformation("Created database for execution");
}
if (this.initializationResult.CreatedContainer)
{
logger.LogInformation("Created collection for execution");
}
if (config.Operations > 0)
{
logger.LogInformation("Pre-populating {0} documents", config.Operations);
await PopulateDocumentsAsync(config, cosmosClient, logger);
}
}
private void Uninitialized()
{
Receive <InitializeProjection>(async ini =>
{
try
{
_streams = ini.ProjectionStreams;
_options = ini.Options;
var query = BuildQuery();
ProjectionStream = query.ProjectionStream;
await OnInit();
var lastKnownState = await GetLastKnownState();
// if the projection is new or id is changed, the projection needs to be rebuilt
if (lastKnownState != null && !ProjectionStream.Equals(lastKnownState.ProjectionStream))
{
await PrepareToRebuild();
}
var request = new ProjectionSubscriptionRequest(query, lastKnownState?.ProjectionSequence ?? 0);
_lastRequestId = request.RequestID;
_streams.Tell(request);
Become(Replaying);
Sender.Tell(InitializationResult.Successful());
}
catch (Exception ex)
{
Sender.Tell(InitializationResult.Failed(ex));
throw;
}
});
}
private async Task ExecuteOperationsAsync(
CTLConfig config,
ILogger logger,
IMetrics metrics,
InitializationResult initializationResult,
ReadWriteQueryPercentage readWriteQueryPercentage,
CancellationToken cancellationToken)
{
logger.LogInformation("Initializing counters and metrics.");
CounterOptions readSuccessMeter = new CounterOptions {
Name = "#Read Successful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
CounterOptions readFailureMeter = new CounterOptions {
Name = "#Read Unsuccessful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
CounterOptions writeSuccessMeter = new CounterOptions {
Name = "#Write Successful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
CounterOptions writeFailureMeter = new CounterOptions {
Name = "#Write Unsuccessful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
CounterOptions querySuccessMeter = new CounterOptions {
Name = "#Query Successful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
CounterOptions queryFailureMeter = new CounterOptions {
Name = "#Query Unsuccessful Operations", Context = nameof(WorkloadType.ReadWriteQuery)
};
TimerOptions readLatencyTimer = new TimerOptions
{
Name = "Read latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = nameof(WorkloadType.ReadWriteQuery),
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
TimerOptions writeLatencyTimer = new TimerOptions
{
Name = "Write latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = nameof(WorkloadType.ReadWriteQuery),
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
TimerOptions queryLatencyTimer = new TimerOptions
{
Name = "Query latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = nameof(WorkloadType.ReadWriteQuery),
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
SemaphoreSlim concurrencyControlSemaphore = new SemaphoreSlim(config.Concurrency);
Stopwatch stopwatch = Stopwatch.StartNew();
int writeRange = readWriteQueryPercentage.ReadPercentage + readWriteQueryPercentage.WritePercentage;
long diagnosticsThresholdDuration = (long)config.DiagnosticsThresholdDurationAsTimespan.TotalMilliseconds;
List <Task> operations = new List <Task>((int)config.Operations);
for (long i = 0; ShouldContinue(stopwatch, i, config); i++)
{
long index = (long)i % 100;
if (index < readWriteQueryPercentage.ReadPercentage)
{
operations.Add(CTLOperationHandler <ItemResponse <Dictionary <string, string> > > .PerformOperationAsync(
semaphoreSlim: concurrencyControlSemaphore,
diagnosticsLoggingThreshold: diagnosticsThresholdDuration,
createTimerContext: () => metrics.Measure.Timer.Time(readLatencyTimer),
resultProducer: new SingleExecutionResultProducer <ItemResponse <Dictionary <string, string> > >(() => this.CreateReadOperation(
operation: i,
containers: initializationResult.Containers,
createdDocumentsPerContainer: this.createdDocuments)),
onSuccess: () => metrics.Measure.Counter.Increment(readSuccessMeter),
onFailure: (Exception ex) =>
{
metrics.Measure.Counter.Increment(readFailureMeter);
logger.LogError(ex, "Failure during read operation");
},
logDiagnostics: (ItemResponse <Dictionary <string, string> > response) => logger.LogInformation("Read request took more than latency threshold {0}, diagnostics: {1}", config.DiagnosticsThresholdDuration, response.Diagnostics.ToString()),
cancellationToken: cancellationToken));
}
else if (index < writeRange)
{
operations.Add(CTLOperationHandler <ItemResponse <Dictionary <string, string> > > .PerformOperationAsync(
semaphoreSlim: concurrencyControlSemaphore,
diagnosticsLoggingThreshold: diagnosticsThresholdDuration,
createTimerContext: () => metrics.Measure.Timer.Time(writeLatencyTimer),
resultProducer: new SingleExecutionResultProducer <ItemResponse <Dictionary <string, string> > >(() => this.CreateWriteOperation(
operation: i,
containers: initializationResult.Containers,
isContentResponseOnWriteEnabled: config.IsContentResponseOnWriteEnabled)),
onSuccess: () => metrics.Measure.Counter.Increment(writeSuccessMeter),
onFailure: (Exception ex) =>
{
metrics.Measure.Counter.Increment(writeFailureMeter);
logger.LogError(ex, "Failure during write operation");
},
logDiagnostics: (ItemResponse <Dictionary <string, string> > response) => logger.LogInformation("Write request took more than latency threshold {0}, diagnostics: {1}", config.DiagnosticsThresholdDuration, response.Diagnostics.ToString()),
cancellationToken: cancellationToken));
}
else
{
operations.Add(CTLOperationHandler <FeedResponse <Dictionary <string, string> > > .PerformOperationAsync(
semaphoreSlim: concurrencyControlSemaphore,
diagnosticsLoggingThreshold: diagnosticsThresholdDuration,
createTimerContext: () => metrics.Measure.Timer.Time(queryLatencyTimer),
resultProducer: new IteratorResultProducer <Dictionary <string, string> >(this.CreateQueryOperation(
operation: i,
containers: initializationResult.Containers)),
onSuccess: () => metrics.Measure.Counter.Increment(querySuccessMeter),
onFailure: (Exception ex) =>
{
metrics.Measure.Counter.Increment(queryFailureMeter);
logger.LogError(ex, "Failure during query operation");
},
logDiagnostics: (FeedResponse <Dictionary <string, string> > response) => logger.LogInformation("Query request took more than latency threshold {0}, diagnostics: {1}", config.DiagnosticsThresholdDuration, response.Diagnostics.ToString()),
cancellationToken: cancellationToken));
}
}
await Task.WhenAll(operations);
stopwatch.Stop();
logger.LogInformation("[{0}] operations performed in [{1}] seconds.",
config.Operations, stopwatch.Elapsed.TotalSeconds);
}
private async Task ExecuteOperationsAsync(
CTLConfig config,
ILogger logger,
IMetrics metrics,
string loggingContextIdentifier,
InitializationResult initializationResult,
ReadWriteQueryPercentage readWriteQueryPercentage,
CancellationToken cancellationToken)
{
logger.LogInformation("Initializing counters and metrics.");
CounterOptions readSuccessMeter = new CounterOptions {
Name = "#Read Successful Operations", Context = loggingContextIdentifier
};
CounterOptions readFailureMeter = new CounterOptions {
Name = "#Read Unsuccessful Operations", Context = loggingContextIdentifier
};
CounterOptions writeSuccessMeter = new CounterOptions {
Name = "#Write Successful Operations", Context = loggingContextIdentifier
};
CounterOptions writeFailureMeter = new CounterOptions {
Name = "#Write Unsuccessful Operations", Context = loggingContextIdentifier
};
CounterOptions querySuccessMeter = new CounterOptions {
Name = "#Query Successful Operations", Context = loggingContextIdentifier
};
CounterOptions queryFailureMeter = new CounterOptions {
Name = "#Query Unsuccessful Operations", Context = loggingContextIdentifier
};
TimerOptions readLatencyTimer = new TimerOptions
{
Name = "Read latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = loggingContextIdentifier,
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
TimerOptions writeLatencyTimer = new TimerOptions
{
Name = "Write latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = loggingContextIdentifier,
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
TimerOptions queryLatencyTimer = new TimerOptions
{
Name = "Query latency",
MeasurementUnit = Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = loggingContextIdentifier,
Reservoir = () => new App.Metrics.ReservoirSampling.Uniform.DefaultAlgorithmRReservoir()
};
SemaphoreSlim concurrencyControlSemaphore = new SemaphoreSlim(config.Concurrency);
Stopwatch stopwatch = Stopwatch.StartNew();
int writeRange = readWriteQueryPercentage.ReadPercentage + readWriteQueryPercentage.WritePercentage;
List <Task> operations = new List <Task>();
for (long i = 0; ShouldContinue(stopwatch, i, config); i++)
{
await concurrencyControlSemaphore.WaitAsync(cancellationToken);
long index = i % 100;
if (index < readWriteQueryPercentage.ReadPercentage)
{
operations.Add(CTLOperationHandler <ItemResponse <Dictionary <string, string> > > .PerformOperationAsync(
createTimerContext: () => metrics.Measure.Timer.Time(readLatencyTimer),
resultProducer: new SingleExecutionResultProducer <ItemResponse <Dictionary <string, string> > >(() => this.CreateReadOperation(
operation: i,
partitionKeyAttributeName: config.CollectionPartitionKey,
containers: initializationResult.Containers,
createdDocumentsPerContainer: this.createdDocuments)),
onSuccess: () =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(readSuccessMeter);
},
onFailure: (Exception ex) =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(readFailureMeter);
Utils.LogError(logger, loggingContextIdentifier, ex, "Failure during read operation");
},
logDiagnostics: (ItemResponse <Dictionary <string, string> > response, TimeSpan latency) => Utils.LogDiagnostics(
logger: logger,
operationName: "Read",
timerContextLatency: latency,
config: config,
cosmosDiagnostics: response.Diagnostics)));
}
else if (index < writeRange)
{
operations.Add(CTLOperationHandler <ItemResponse <Dictionary <string, string> > > .PerformOperationAsync(
createTimerContext: () => metrics.Measure.Timer.Time(writeLatencyTimer),
resultProducer: new SingleExecutionResultProducer <ItemResponse <Dictionary <string, string> > >(() => this.CreateWriteOperation(
operation: i,
partitionKeyAttributeName: config.CollectionPartitionKey,
containers: initializationResult.Containers,
isContentResponseOnWriteEnabled: config.IsContentResponseOnWriteEnabled)),
onSuccess: () =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(writeSuccessMeter);
},
onFailure: (Exception ex) =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(writeFailureMeter);
Utils.LogError(logger, loggingContextIdentifier, ex, "Failure during write operation");
},
logDiagnostics: (ItemResponse <Dictionary <string, string> > response, TimeSpan latency) => Utils.LogDiagnostics(
logger: logger,
operationName: "Write",
timerContextLatency: latency,
config: config,
cosmosDiagnostics: response.Diagnostics)));
}
else
{
operations.Add(CTLOperationHandler <FeedResponse <Dictionary <string, string> > > .PerformOperationAsync(
createTimerContext: () => metrics.Measure.Timer.Time(queryLatencyTimer),
resultProducer: new IteratorResultProducer <Dictionary <string, string> >(this.CreateQueryOperation(
operation: i,
containers: initializationResult.Containers)),
onSuccess: () =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(querySuccessMeter);
},
onFailure: (Exception ex) =>
{
concurrencyControlSemaphore.Release();
metrics.Measure.Counter.Increment(queryFailureMeter);
Utils.LogError(logger, loggingContextIdentifier, ex, "Failure during query operation");
},
logDiagnostics: (FeedResponse <Dictionary <string, string> > response, TimeSpan latency) => Utils.LogDiagnostics(
logger: logger,
operationName: "Query",
timerContextLatency: latency,
config: config,
cosmosDiagnostics: response.Diagnostics)));
}
}
await Task.WhenAll(operations);
stopwatch.Stop();
logger.LogInformation("[{0}] operations performed in [{1}] seconds.",
operations.Count, stopwatch.Elapsed.TotalSeconds);
}
/// <summary>
/// Initializes the I2C device.
/// </summary>
/// <returns>Returns an InitializationResult value indicating if the
/// initialization was success or not.</returns>
public async Task <InitializationResult> InitializeAsync()
{
InitializationResult returnValue = InitializationResult.None;
// ***
// *** Get a selector string that will return all I2C controllers on the system
// ***
string aqs = I2cDevice.GetDeviceSelector();
// ***
// *** Find the I2C bus controller device with our selector string
// ***
var dis = await DeviceInformation.FindAllAsync(aqs).AsTask();
if (dis.Count > 0)
{
var settings = new I2cConnectionSettings(this.DeviceAddress);
settings.BusSpeed = this.BusSpeed;
// ***
// *** Create an I2cDevice with our selected bus controller and I2C settings
// ***
this.Device = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (this.Device != null)
{
IsInitialized = true;
try
{
await this.OnInitializeAsync();
}
catch (Exception ex)
{
// ***
// *** Looking for: "The system cannot find the file specified. Slave address was not acknowledged."
// ***
if (ex.Message.Contains("Slave address was not acknowledged"))
{
throw new InvalidAddressException();
}
else
{
throw;
}
}
}
else
{
// ***
// *** Slave address n on I2C Controller is currently in use by
// *** another application. Please ensure that no other applications are using I2C.
// ***
returnValue = InitializationResult.DeviceInUse;
}
}
else
{
// ***
// *** No I2C controllers were found on the system
// ***
returnValue = InitializationResult.NoI2cController;
}
return(returnValue);
}
private static async Task <InitializationResult> InitializeAsync(
InitializationArgs args
)
{
using (var cancellationTokenSource = new CancellationTokenSource())
{
var token = cancellationTokenSource.Token;
void OnCancel(Object sender, ConsoleCancelEventArgs e)
{
cancellationTokenSource.Cancel();
}
Console.CancelKeyPress += OnCancel;
using (var usingHelper = new UsingHelper(() => Console.CancelKeyPress -= OnCancel))
{
var be = args.BuildEngine;
var projectFilePath = be?.ProjectFileOfTaskNode;
var env = await _cache.DetectEnvironmentAsync(new EnvironmentKeyInfo(
new EnvironmentKey(
args.Framework,
args.RuntimeID,
args.SDKPackageID,
args.SDKPackageVersion,
args.SettingsLocation,
args.PackageIDIsSelf ? projectFilePath : args.PackageID,
args.PackageVersion
),
args.PackageIDIsSelf,
projectFilePath
),
be,
token);
InitializationResult initializationResult = null;
if (env.Errors.Length > 0)
{
if (be == null)
{
Console.Error.WriteLine("Errors in environment detection: " + String.Join(";", env.Errors));
}
else
{
foreach (var error in env.Errors.Select(errorCode => errorCode.AsNuGetMSBuildError(projectFilePath, args)))
{
be.LogErrorEvent(error);
}
}
initializationResult = null;
}
else
{
await be.LogMessageOrWriteToConsoleOut($"Detected current NuGet framework to be \"{env.ThisFramework}\", with RID \"{env.ThisRuntimeID}\".");
var inspection = await _cache.InspectPackageAsync(env, new InspectionKey(
env.ThisFramework,
args.SettingsLocation,
env.PackageID,
env.PackageVersion,
args.AssemblyPath
),
args.RestoreSDKPackage,
be,
token
);
var epType = args.TypeName;
var epMethod = args.MethodName;
if (epType.IsNullOrEmpty() && epMethod.IsNullOrEmpty())
{
// TODO load the assembly using System.Reflection.Metadata stuff and inspect it.
// OR just invoke the process which will use the existing stuff in NuGetUtils.Lib.Exec
throw new NotImplementedException("The scenario where both type and method names of entrypoint are not specified is not yet supported.");
}
Func <MethodInspectionInfo, Boolean> matcher;
if (epType.IsNullOrEmpty())
{
// Get the first method matching given method name
matcher = m => String.Equals(m.MethodName, epMethod);
}
else
{
if (epMethod.IsNullOrEmpty())
{
// Get the first method contained within given type
matcher = m => String.Equals(m.TypeName, epType);
}
else
{
// Get the first method matching given method name which is contained by type with given type name
matcher = m => String.Equals(m.MethodName, epMethod) && String.Equals(m.TypeName, epType);
}
}
var epInfo = inspection.SuitableMethods.FirstOrDefault(matcher);
if (epInfo == null)
{
throw new InvalidOperationException($"Could not find suitable method with the following information: entrypoint type {epType}, and entrypoing method {epMethod}.");
}
var typeGenResult = TaskTypeGenerator.Instance.GenerateTaskType(
true,
epInfo.InputParameters,
epInfo.OutputParameters
);
initializationResult = new InitializationResult(
typeGenResult,
() => (ITask)typeGenResult.GeneratedType.GetTypeInfo().DeclaredConstructors.First().Invoke(new[]
{
new TaskProxy(_cache.ProcessMonitor, args, env, inspection, epInfo, typeGenResult)
})
);
}
return(initializationResult);
}
}
}
