public Core_Interception()
{
_providerDescriptor = new ProviderDescriptor
{
ProviderName = ProviderName
};
ProcessSettingsFile();
_deviceLibrary = new IceptDeviceLibrary(_providerDescriptor, _blockingEnabled);
if (_deviceLibrary.GetInputList().Devices?.Count > 0)
{
_isLive = true;
_errorMessage = string.Empty;
}
else
{
_isLive = false;
_errorMessage = "No Interception devices found, driver assumed to not be installed";
}
_deviceContext = ManagedWrapper.CreateContext();
StartPollingIfNeeded();
//_pollThreadDesired = true;
_timer = new MultimediaTimer()
{
Interval = _pollRate
};
_timer.Elapsed += DoPoll;
}
public MidiDeviceLibrary(ProviderDescriptor providerDescriptor)
{
_providerDescriptor = providerDescriptor;
BuildInputDeviceReportTemplate();
BuildOutputDeviceReportTemplate();
RefreshConnectedDevices();
}
private void CreateAccessor()
{
var nodeConfiguration = new NodeConfiguration();
var configuration = DomainConfigurationFactory.Create();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var storageDriver = StorageDriver.Create(driverFactory, configuration);
var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var accessor = new UpgradeServiceAccessor {
Configuration = configuration,
StorageDriver = storageDriver,
NameBuilder = nameBuilder,
HandlerFactory = handlerFactory
};
configuration.Lock();
var connection = storageDriver.CreateConnection(null);
connection.Open();
accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection));
if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
accessor.RegisterTemporaryResource(connection);
}
else
{
accessor.RegisterResource(connection);
}
accessor.Connection = connection;
accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor)));
this.accessor = accessor;
}
private DeviceConfiguration FindDeviceConfiguration(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor)
{
return(_deviceConfigurationList.Find(deviceConfiguration => deviceConfiguration.Device.ProviderName == providerDescriptor.ProviderName &&
deviceConfiguration.Device.DeviceHandle == deviceDescriptor.DeviceHandle &&
deviceConfiguration.Device.DeviceNumber == deviceDescriptor.DeviceInstance
));
}
private Device FindDevice(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor)
{
return(_deviceList.Find(d => d.ProviderName == providerDescriptor.ProviderName &&
d.DeviceHandle == deviceDescriptor.DeviceHandle &&
d.DeviceNumber == deviceDescriptor.DeviceInstance
));
}
private void BuildServices()
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
CreateConnection(services);
context.DefaultSchemaInfo = defaultSchemaInfo = services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
public DiDeviceLibrary(ProviderDescriptor providerDescriptor)
{
_providerDescriptor = providerDescriptor;
BuildPovBindingInfos();
BuildBindingReports();
RefreshConnectedDevices();
}
private void ProvidersPanel_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (e.AddedItems.Count > 0)
{
ProviderDescriptor descriptor = (ProviderDescriptor)e.AddedItems[0];
this.YearsPanel.ItemsSource = descriptor.ChildDescriptors;
}
}
private readonly object _lockObj = new object(); // When changing mode (Bind / Sub) or adding / removing devices, lock this object
public Core_SpaceMouse()
{
_providerDescriptor = new ProviderDescriptor {
ProviderName = ProviderName
};
_deviceLibrary = new SmDeviceLibrary(new ProviderDescriptor {
ProviderName = ProviderName
});
}
public IceptDeviceLibrary(ProviderDescriptor providerDescriptor)
{
_providerDescriptor = providerDescriptor;
_deviceContext = ManagedWrapper.CreateContext();
InitKeyReports();
InitMouseReports();
RefreshConnectedDevices();
}
private static SqlDriverFactory GetFactory(string provider)
{
lock (FactoryCache) {
SqlDriverFactory factory;
if (!FactoryCache.TryGetValue(provider, out factory))
{
var descriptor = ProviderDescriptor.Get(provider);
factory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
FactoryCache.Add(provider, factory);
}
return(factory);
}
}
public IOTester SubscribeOutput(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor, BindingDescriptor bindingDescriptor)
{
_output = new OutputSubscription()
{
ProviderDescriptor = providerDescriptor,
DeviceDescriptor = deviceDescriptor
};
_bindingDescriptor = bindingDescriptor;
if (!IOW.Instance.SubscribeOutput(_output))
{
throw new Exception("Could not subscribe to output");
}
return(this);
}
public DeviceReport GetOutputDeviceReport(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor)
{
var provider = GetProvider(providerDescriptor.ProviderName);
if (provider != null)
{
if (!(provider is IOutputProvider prov))
{
return(null);
}
return(prov.GetOutputDeviceReport(deviceDescriptor));
}
return(null);
}
public void Should_throw_exception_when_provider_type_not_set()
{
var settings = MockRepository.GenerateMock <IProviderSettings>();
var fooProviderName = "Foo Provider";
var fooProviderGroup = "FooProviders";
Type fooProviderType = null;
var isFooProviderEnabled = true;
var providerDescriptor = new ProviderDescriptor(
fooProviderName,
fooProviderGroup,
fooProviderType,
settings,
isFooProviderEnabled
);
}
private void InputChanged(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor, BindingReport bindingReport, int value)
{
if (!DeviceBinding.MapCategory(bindingReport.Category).Equals(_deviceBinding.DeviceBindingCategory))
{
return;
}
if (!IsInputValid(bindingReport.Category, value))
{
return;
}
var device = FindDevice(providerDescriptor, deviceDescriptor);
_deviceBinding.SetDeviceGuid(device.Guid);
_deviceBinding.SetKeyTypeValue((int)bindingReport.BindingDescriptor.Type, bindingReport.BindingDescriptor.Index, bindingReport.BindingDescriptor.SubIndex);
EndBindMode();
}
public void ConntectionTest()
{
var descriptor = ProviderDescriptor.Get(provider);
var factory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var configuration = new SqlDriverConfiguration {
EnsureConnectionIsAlive = true
};
var driver = factory.GetDriver(new ConnectionInfo(Url), configuration);
var connection = driver.CreateConnection();
connection.Open();
var anotherConnection = driver.CreateConnection();
anotherConnection.OpenAndInitialize("Use [DO-Tests-1]");
}
public SeriesInformation(string providerFolder)
{
ProviderDescriptor descriptor = new ProviderDescriptor(providerFolder);
var filePaths = descriptor.YearDescriptors
.SelectMany(y => y.MonthDescriptors
.SelectMany(m => m.DayDescriptors
.Select(d => d.Path)));
DateTime dateTime;
decimal ask, bid;
SeriesReader.CreateReaderForSingleFile(filePaths.First()).Next(out dateTime, out ask, out bid);
Begin = dateTime;
var reader = SeriesReader.CreateReaderForSingleFile(filePaths.Last());
while (reader.Next(out dateTime, out ask, out bid))
{
End = dateTime;
}
}
public IOTester(string name, ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor, BindingDescriptor bindingDescriptor, bool block = false)
{
// Input
_input = new InputSubscription
{
ProviderDescriptor = providerDescriptor,
DeviceDescriptor = deviceDescriptor,
BindingDescriptor = bindingDescriptor,
Block = block,
Callback = new Action <short>(value =>
{
Console.WriteLine("{0} State: {1}", name, value);
if (_output != null)
{
IOW.Instance.SetOutputstate(_output, _bindingDescriptor, value);
}
})
};
}
public Core_Interception()
{
_providerDescriptor = new ProviderDescriptor
{
ProviderName = ProviderName
};
_deviceLibrary = new IceptDeviceLibrary(_providerDescriptor);
ProcessSettingsFile();
_deviceContext = ManagedWrapper.CreateContext();
StartPollingIfNeeded();
//_pollThreadDesired = true;
_timer = new MultimediaTimer()
{
Interval = _pollRate
};
_timer.Elapsed += DoPoll;
}
private async ValueTask BuildServices(bool isAsync, CancellationToken token = default)
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = isAsync
? await StorageDriver.CreateAsync(driverFactory, configuration, token).ConfigureAwait(false)
: StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
await CreateConnection(services, isAsync, token).ConfigureAwait(false);
context.DefaultSchemaInfo = defaultSchemaInfo = isAsync
? await services.StorageDriver.GetDefaultSchemaAsync(services.Connection, token).ConfigureAwait(false)
: services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
public void Should_not_throw_exception_when_settings_not_set()
{
IProviderSettings settings = null;
var fooProviderName = "Foo Provider";
var fooProviderGroup = "FooProviders";
var fooProviderType = typeof(FooProvider);
var isFooProviderEnabled = true;
var providerDescriptor = new ProviderDescriptor(
fooProviderName,
fooProviderGroup,
fooProviderType,
settings,
isFooProviderEnabled
);
Assert.That(providerDescriptor, Is.Not.Null);
Assert.That(providerDescriptor.ProviderName, Is.EqualTo(fooProviderName));
Assert.That(providerDescriptor.ProviderGroup, Is.EqualTo(fooProviderGroup));
Assert.That(providerDescriptor.ProviderType, Is.EqualTo(fooProviderType));
Assert.That(providerDescriptor.IsEnabled, Is.EqualTo(isFooProviderEnabled));
}
private void BuildServices(UpgradeContext context)
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
BuildExternalServices(services, context);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
public void Should_initialise_provider_descriptor()
{
var settings = MockRepository.GenerateMock <IProviderSettings>();
var fooProviderName = "Foo Provider";
var fooProviderGroup = "FooProviders";
var fooProviderType = typeof(FooProvider);
var isFooProviderEnabled = true;
var providerDescriptor = new ProviderDescriptor(
fooProviderName,
fooProviderGroup,
fooProviderType,
settings,
isFooProviderEnabled
);
Assert.That(providerDescriptor, Is.Not.Null);
Assert.That(providerDescriptor.ProviderName, Is.EqualTo(fooProviderName));
Assert.That(providerDescriptor.ProviderGroup, Is.EqualTo(fooProviderGroup));
Assert.That(providerDescriptor.ProviderType, Is.EqualTo(fooProviderType));
Assert.That(providerDescriptor.IsEnabled, Is.EqualTo(isFooProviderEnabled));
}
public void Should_not_throw_exception_when_provider_group_not_set()
{
var settings = MockRepository.GenerateMock <IProviderSettings>();
var fooProviderName = "Foo Provider";
var fooProviderGroup = "";
var fooProviderType = typeof(FooProvider);
var isFooProviderEnabled = true;
var providerDescriptor = new ProviderDescriptor(
fooProviderName,
fooProviderGroup,
fooProviderType,
settings,
isFooProviderEnabled
);
Assert.That(providerDescriptor, Is.Not.Null);
Assert.That(providerDescriptor.ProviderName, Is.EqualTo(fooProviderName));
Assert.That(providerDescriptor.ProviderGroup, Is.EqualTo(fooProviderGroup));
Assert.That(providerDescriptor.ProviderType, Is.EqualTo(fooProviderType));
Assert.That(providerDescriptor.IsEnabled, Is.EqualTo(isFooProviderEnabled));
}
public void SqlServerConnectionCheckTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var descriptor = ProviderDescriptor.Get(provider);
var factory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var configuration = new SqlDriverConfiguration()
{
EnsureConnectionIsAlive = false
};
var driver = factory.GetDriver(new ConnectionInfo(Url), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
configuration = configuration.Clone();
configuration.EnsureConnectionIsAlive = true;
driver = factory.GetDriver(new ConnectionInfo(Url), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.True);
configuration = configuration.Clone();
configuration.EnsureConnectionIsAlive = true;
driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";pooling=false"), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
configuration = configuration.Clone();
configuration.EnsureConnectionIsAlive = true;
driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";Pooling=False"), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
configuration = configuration.Clone();
configuration.EnsureConnectionIsAlive = true;
driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";pooling = false"), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
configuration = configuration.Clone();
configuration.EnsureConnectionIsAlive = true;
driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";Pooling = False"), configuration);
Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
}
public static void ProcessBindMode(ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor,
BindingReport bindingDescriptor, short state)
{
Console.WriteLine($"IOWrapper| BindMode: Proivider: {providerDescriptor.ProviderName}, Handle {deviceDescriptor.DeviceHandle}/{deviceDescriptor.DeviceInstance}" +
$", Type: {bindingDescriptor.BindingDescriptor.Type}, Index: {bindingDescriptor.BindingDescriptor.Index}/{bindingDescriptor.BindingDescriptor.SubIndex}, State: {state}");
}
private static void BindModeHandler(ProviderDescriptor provider, DeviceDescriptor device, BindingReport binding, short value)
{
Console.WriteLine($"BIND MODE: Provider: {provider.ProviderName} | Device: {device.DeviceHandle}/{device.DeviceInstance} | Binding: {binding.BindingDescriptor.Type}/{binding.BindingDescriptor.Index}/{binding.BindingDescriptor.SubIndex} | Title: {binding.Title} | Path: {binding.Path} | Value: {value}");
}
public async Task ConnectionAccessorAsyncTest()
{
var accessorInstance = new TestConnectionAccessor();
var accessorsArray = new[] { accessorInstance };
var descriptor = ProviderDescriptor.Get(provider);
var factory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));
var configuration = new SqlDriverConfiguration(accessorsArray);
_ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);
Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));
configuration = new SqlDriverConfiguration(accessorsArray)
{
EnsureConnectionIsAlive = true
};
_ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);
Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(2));
Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(2));
if (provider == WellKnown.Provider.SqlServer)
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(1));
}
else
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
}
Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(2));
Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(2));
Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));
configuration = new SqlDriverConfiguration(accessorsArray)
{
ConnectionInitializationSql = InitQueryPerProvider(provider)
};
_ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);
Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(3));
if (provider == WellKnown.Provider.SqlServer)
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(2));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(2));
}
else
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(1));
}
Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));
configuration = new SqlDriverConfiguration(accessorsArray)
{
ConnectionInitializationSql = "dummy string to trigger error"
};
try {
_ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);
}
catch {
//skip it
}
Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(4));
Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(4));
if (provider == WellKnown.Provider.SqlServer)
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(3));
}
else
{
Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(2));
Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(2));
}
Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(3));
Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(1));
Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(1));
}
public void SetDetectionMode(DetectionMode detectionMode, ProviderDescriptor providerDescriptor, DeviceDescriptor deviceDescriptor, Action <ProviderDescriptor, DeviceDescriptor, BindingReport, short> callback = null)
{
var provider = GetProvider <IBindModeProvider>(providerDescriptor.ProviderName);
provider.SetDetectionMode(detectionMode, deviceDescriptor, callback);
}
public XiDeviceLibrary(ProviderDescriptor providerDescriptor)
{
_providerDescriptor = providerDescriptor;
BuildInputList();
BuildDeviceList();
}
