public CalculationRules(
IEntityStore<Campaigns.Model.Attribute> attributesDb,
IEntityStore<AttributeContribution> contributionsDb,
IEnumerable<AttributeAllocation> allocations)
{
if (null == attributesDb) throw new ArgumentNullException("attributesDb");
if (null == contributionsDb) throw new ArgumentNullException("contributionsDb");
if (null == allocations) throw new ArgumentNullException("allocations");
_attributesDb = attributesDb;
_contributionsDb = contributionsDb;
_allocations = allocations;
foreach (var attrib in _attributesDb.AsQueryable.Where(IsStandard))
{
_memDb.AddAttribute(attrib);
}
foreach (var alloc in _allocations)
{
if (!_memDb.Attributes.Contains(alloc.Attribute))
{
_memDb.AddAttribute(alloc.Attribute);
}
if (alloc.Value.HasValue)
{
var contribution =
AttributeContributions.ConstantContributionTo(
null, alloc.Attribute, alloc.Value.Value);
_memDb.AddContribution(contribution);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Gnosis Repository Test");
try
{
artistCache = new Cache<Artist>();
workCache = new Cache<Work>();
artistStore = new SQLiteArtistDatabase();
workStore = new SQLiteWorkDatabase(artistCache, workCache);
repository = new Repository(artistCache, artistStore, workCache, workStore);
repository.Initialize();
//cache = new GlobalCache();
//database = new GlobalDatabase();
//database.Initialize(cache);
//repository = new GlobalRepository(cache, database);
//AddAlbum();
DisplayInfo();
Console.WriteLine("Artist Count: {0}", artistCache.Entities.Count());
Console.WriteLine("Work Count: {0}", workCache.Entities.Count());
}
catch (Exception ex)
{
Console.WriteLine("ERROR");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
Console.WriteLine("Press ENTER to close");
Console.ReadLine();
}
internal NHNestedObjectSpace(ITypesInfo typesInfo, IEntityStore entityStore, IPersistenceManager persistenceManager,
Dictionary<object, ObjectSpaceInstanceInfo> instances, NHObjectSpace parentObjectSpace) :
base(typesInfo, entityStore, persistenceManager, instances, null)
{
this.parentObjectSpace = parentObjectSpace;
}
public void Run(IEntityStore provider)
{
if (this.IsFirstRun)
{
OnBeforeRun(provider);
}
else
{
provider.DeleteAll<Category>();
provider.DeleteAll<Customer>();
provider.DeleteAll<Employee>();
provider.DeleteAll<Shipper>();
provider.DeleteAll<Order>();
provider.DeleteAll<OrderDetail>();
provider.DeleteAll<CustomerCustomerDemo>();
provider.DeleteAll<Region>();
provider.DeleteAll<Territory>();
provider.DeleteAll<EmployeeTerritory>();
}
provider.StoreAll(NorthwindData.Categories);
provider.StoreAll(NorthwindData.Customers);
provider.StoreAll(NorthwindData.Employees);
provider.StoreAll(NorthwindData.Shippers);
provider.StoreAll(NorthwindData.Orders);
provider.StoreAll(NorthwindData.OrderDetails);
provider.StoreAll(NorthwindData.CustomerCustomerDemos);
provider.StoreAll(NorthwindData.Regions);
provider.StoreAll(NorthwindData.Territories);
provider.StoreAll(NorthwindData.EmployeeTerritories);
}
public AuthorizationService()
{
_store = ServiceLocator.GetInstance<IEntityStoreManager>().CreateStore("authorization");
_store.RegisterEntity<AuthorizationKeyStatusModel>();
_keys["/"] = new AuthorizationKeyImpl(this, null, "/", "Raiz", 0);
SetStatus("user", "admin", "/", AuthorizationStatus.Grant);
}
public void Initialize(IWorkerServiceContext context)
{
_store = context.Services.GetInstance<IEntityStoreManager>().CreateStore("LogData");
_store.RegisterEntity<LogEntryEntity>();
_context = context;
_logBuffer = context.Services.GetInstance<LogWriterBufferService>();
_logBuffer.OnEntryAdded += new EventHandler(_logBuffer_OnEntryAdded);
_context.Controller.WakeUp();
}
public AccountService()
{
var _storeManager = ServiceLocator.GetInstance<IEntityStoreManager>();
_store = _storeManager.CreateStore("accounts");
_store.RegisterEntity<UserModel>();
_store.RegisterEntity<RoleModel>();
_store.RegisterEntity<SchemaModel>();
_store.RegisterEntity<RoleSchemaRelation>();
_store.RegisterEntity<UserRoleRelation>();
}
private static void LoadNorthwindData(IEntityStore persistenceProvider)
{
persistenceProvider.StoreAll(NorthwindData.Categories);
persistenceProvider.StoreAll(NorthwindData.Customers);
persistenceProvider.StoreAll(NorthwindData.Employees);
persistenceProvider.StoreAll(NorthwindData.Shippers);
persistenceProvider.StoreAll(NorthwindData.Orders);
persistenceProvider.StoreAll(NorthwindData.Products);
persistenceProvider.StoreAll(NorthwindData.OrderDetails);
persistenceProvider.StoreAll(NorthwindData.CustomerCustomerDemos);
persistenceProvider.StoreAll(NorthwindData.Regions);
persistenceProvider.StoreAll(NorthwindData.Territories);
persistenceProvider.StoreAll(NorthwindData.EmployeeTerritories);
}
/// <summary>Loads an entity using SPARQL query and loads the resulting triples to the <paramref name="store"/>.</summary>
public void LoadEntity(IEntityStore store, EntityId entityId)
{
// todo: maybe this should return EntityTriples instead and they should be asserted in EntityContext?
var sparql = QueryBuilder.Select("s", "p", "o", "g")
.Graph("?g", graph => graph.Where(triple => triple.Subject("s").Predicate("p").Object("o")))
.Where(triple => triple.Subject("g").PredicateUri("foaf:primaryTopic").Object(entityId.Uri));
sparql.Prefixes.Import(_namespaces);
var triples = from result in ExecuteSelect(sparql.BuildQuery())
let subject = result["s"].WrapNode(entityId)
let predicate = result["p"].WrapNode(entityId)
let @object = result["o"].WrapNode(entityId)
let graph = result.HasBoundValue("g") ? result["g"].WrapNode(entityId) : null
select new EntityQuad(entityId, subject, predicate, @object, graph);
store.AssertEntity(entityId, triples);
}
public Repository(ICache<Artist> artistCache, IEntityStore<Artist> artistStore, ICache<Work> workCache, IEntityStore<Work> workStore)
{
if (artistCache == null)
throw new ArgumentNullException("artistCache");
if (artistStore == null)
throw new ArgumentNullException("artistStore");
if (workCache == null)
throw new ArgumentNullException("workCache");
if (workStore == null)
throw new ArgumentNullException("workStore");
this.artistCache = artistCache;
this.artistStore = artistStore;
this.workCache = workCache;
this.workStore = workStore;
}
public EntityRepository(ILogger logger, IEntityCache<IArtist> artistCache, IEntityStore<IArtist> artistStore, IEntityCache<IWork> workCache, IEntityStore<IWork> workStore)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (artistCache == null)
throw new ArgumentNullException("artistCache");
if (artistStore == null)
throw new ArgumentNullException("artistStore");
if (workCache == null)
throw new ArgumentNullException("workCache");
if (workStore == null)
throw new ArgumentNullException("workStore");
this.logger = logger;
this.artistCache = artistCache;
this.artistStore = artistStore;
this.workCache = workCache;
this.workStore = workStore;
}
static void Main(string[] args)
{
logger = Log4NetLogger.GetDefaultLogger(typeof(Program));
try
{
logger.Info("Ebla Started");
Console.WriteLine("Ebla version 3.0.0.0");
Console.WriteLine("Enter \"{0}\" for instructions", commandHelp);
artistCache = new EntityCache<IArtist>();
workCache = new EntityCache<IWork>();
artistStore = new SQLiteArtistDatabase();
workStore = new SQLiteWorkDatabase(artistCache, workCache);
repository = new EntityRepository(logger, artistCache, artistStore, workCache, workStore);
repository.Initialize();
tagger = new Tagger();
mediaFactory = new MediaFactory(logger);
mediaImporter = new MediaImporter(logger, mediaFactory, repository, tagger);
var exit = false;
while (!exit)
{
Console.Write(prompt);
exit = Execute(Console.ReadLine());
}
}
catch (Exception ex)
{
logger.Error("Program.Main", ex);
Console.WriteLine("ERROR");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Console.ReadLine();
}
}
public virtual void OnBeforeRun(IEntityStore provider) { }
public ScriptingServiceManager(ICore core)
{
Core = core ?? throw new ArgumentNullException(nameof(core));
_standardIndicatorsInstances = new List <IndicatorBase>
{
new SimpleMovingAverage(),
new SmoothedMovingAverage(),
new ExponentialMovingAverage(),
new LinearWeightedMovingAverage(),
new AcceleratorOscillator(),
new AccumulationDistribution(),
new AverageDirectionalMovement(),
new Alligator(),
new AwesomeOscillator(),
new AverageTrueRange(),
new BollingerBands(),
new BearsPower(),
new BullsPower(),
new MarketFacilitationIndex(),
new CommodityChannelIndex(),
new Envelopes(),
new ForceIndex(),
new Gator(),
new MACD(),
new MoneyFlowIndex(),
new Momentum(),
new OnBalanceVolume(),
new MovingAverageOfOscillator(),
new RelativeStrengthIndex(),
new RelativeVigorIndex(),
new StandardDeviation(),
new Volume(),
new WPercentRange(),
new ParabolicSAR(),
new StochasticOscillator(),
new PL(),
new ZigZag()
};
_signalStore = new SignalStore(Core.FileManager);
_userWorkingIndicators = new Dictionary <string, List <IndicatorService> >();
_userIndicators = new Dictionary <string, Dictionary <string, List <ScriptingParameterBase> > >();
_availableStandardIndicators = new Dictionary <string, List <ScriptingParameterBase> >();
_userSignals = new Dictionary <string, List <Signal> >();
_userWorkingSignals = new Dictionary <string, List <SignalService> >();
foreach (var indicator in _standardIndicatorsInstances)
{
_availableStandardIndicators.Add(indicator.Name, indicator.GetParameters().ToList());
}
try
{
const string folder = "CustomIndicators";
_indicatorsFolderPath = Directory.Exists(folder)
? new DirectoryInfo(folder).FullName
: Directory.CreateDirectory(folder).FullName;
}
catch (Exception ex)
{
Logger.Error("Failed to create folder for custom indicators", ex);
}
try
{
const string folder = "CustomSignals";
_signalsFolderPath = Directory.Exists(folder)
? new DirectoryInfo(folder).FullName
: Directory.CreateDirectory(folder).FullName;
}
catch (Exception ex)
{
Logger.Error("Failed to create folder for custom Signals", ex);
}
}
public RulesController(
IEntityStore<Campaigns.Model.Attribute> attributesDb,
IEntityStore<Campaigns.Model.AttributeContribution> contributionsDb)
{
_attributesDb = attributesDb;
_contributionsDb = contributionsDb;
}
public EntityTreeViewComponent(IEntityStore <Entity> entityStore)
{
_entityStore = entityStore;
}
public CalculationRules(
IEntityStore<Campaigns.Model.Attribute> attributesDb,
IEntityStore<AttributeContribution> contributionsDb)
: this(attributesDb, contributionsDb, new List<AttributeAllocation>())
{
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <Core.IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2));
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// ICloudConnectionProvider
builder.Register(c => new CloudConnectionProvider(c.Resolve <Core.IMessageConverterProvider>(), this.connectionPoolSize, c.Resolve <IClientProvider>(), this.upstreamProtocol))
.As <ICloudConnectionProvider>()
.SingleInstance();
if (this.isStoreAndForwardEnabled || this.cacheTokens)
{
// Detect system environment
builder.Register(c => new SystemEnvironment())
.As <ISystemEnvironment>()
.SingleInstance();
// DataBase options
builder.Register(c => new Storage.RocksDb.RocksDbOptionsProvider(c.Resolve <ISystemEnvironment>(), this.optimizeForPerformance))
.As <Storage.RocksDb.IRocksDbOptionsProvider>()
.SingleInstance();
// IDbStore
builder.Register(
c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger(typeof(RoutingModule));
if (this.usePersistentStorage)
{
// Create partitions for messages and twins
var partitionsList = new List <string> {
Core.Constants.MessageStorePartitionKey, Core.Constants.TwinStorePartitionKey, Core.Constants.CheckpointStorePartitionKey
};
try
{
IDbStoreProvider dbStoreprovider = Storage.RocksDb.DbStoreProvider.Create(c.Resolve <Storage.RocksDb.IRocksDbOptionsProvider>(),
this.storagePath, partitionsList);
logger.LogInformation($"Created persistent store at {this.storagePath}");
return(dbStoreprovider);
}
catch (Exception ex) when(!ExceptionEx.IsFatal(ex))
{
logger.LogError(ex, "Error creating RocksDB store. Falling back to in-memory store.");
return(new InMemoryDbStoreProvider());
}
}
else
{
logger.LogInformation($"Using in-memory store");
return(new InMemoryDbStoreProvider());
}
})
.As <IDbStoreProvider>()
.SingleInstance();
}
// Task<ICredentialsStore>
builder.Register(async c =>
{
if (this.cacheTokens)
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IEncryptionProvider encryptionProvider = await this.workloadUri.Map(
async uri => await EncryptionProvider.CreateAsync(
this.storagePath,
new Uri(uri),
Service.Constants.WorkloadApiVersion,
this.edgeModuleId,
this.edgeModuleGenerationId.Expect(() => new InvalidOperationException("Missing generation ID")),
Service.Constants.InitializationVectorFileName) as IEncryptionProvider)
.GetOrElse(() => Task.FromResult <IEncryptionProvider>(NullEncryptionProvider.Instance));
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, string> tokenCredentialsEntityStore = storeProvider.GetEntityStore <string, string>("tokenCredentials");
return(new TokenCredentialsStore(tokenCredentialsEntityStore, encryptionProvider));
}
else
{
return(new NullCredentialsStore() as ICredentialsStore);
}
})
.As <Task <ICredentialsStore> >()
.SingleInstance();
// IConnectionManager
builder.Register(c => new ConnectionManager(c.Resolve <ICloudConnectionProvider>(), this.maxConnectedClients))
.As <IConnectionManager>()
.SingleInstance();
// IEndpointFactory
builder.Register(c => new EndpointFactory(c.Resolve <IConnectionManager>(), c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), this.edgeDeviceId))
.As <IEndpointFactory>()
.SingleInstance();
// RouteFactory
builder.Register(c => new EdgeRouteFactory(c.Resolve <IEndpointFactory>()))
.As <RouteFactory>()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.None <IStoreProvider>()))
.As <ITwinManager>()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(c => CheckpointStore.Create(c.Resolve <IDbStoreProvider>()))
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.Some <IStoreProvider>(new StoreProvider(c.Resolve <IDbStoreProvider>()))))
.As <ITwinManager>()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<ICloudProxy> "EdgeHubCloudProxy"
builder.Register(
async c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var connectionManager = c.Resolve <IConnectionManager>();
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(edgeHubCredentials);
if (!cloudProxyTry.Success)
{
throw new EdgeHubConnectionException("Edge hub is unable to connect to IoT Hub", cloudProxyTry.Exception);
}
ICloudProxy cloudProxy = cloudProxyTry.Value;
return(cloudProxy);
})
.Named <Task <ICloudProxy> >("EdgeHubCloudProxy")
.SingleInstance();
// IInvokeMethodHandler
builder.Register(c => new InvokeMethodHandler(c.Resolve <IConnectionManager>()))
.As <IInvokeMethodHandler>()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
Router router = await c.Resolve <Task <Router> >();
IEdgeHub hub = new RoutingEdgeHub(router, c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), c.Resolve <IConnectionManager>(),
c.Resolve <ITwinManager>(), this.edgeDeviceId, c.Resolve <IInvokeMethodHandler>());
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
var routeFactory = c.Resolve <RouteFactory>();
if (this.useTwinConfig)
{
var connectionManager = c.Resolve <IConnectionManager>();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManager = c.Resolve <ITwinManager>();
ICloudProxy cloudProxy = await c.ResolveNamed <Task <ICloudProxy> >("EdgeHubCloudProxy");
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials,
edgeHub,
twinManager,
connectionManager,
cloudProxy,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo
);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConnectionProvider connectionProvider = new ConnectionProvider(c.Resolve <IConnectionManager>(), edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
public TimedEntityStore(IEntityStore <TK, TV> underlyingEntityStore, TimeSpan timeout)
: base(underlyingEntityStore, timeout)
{
this.underlyingEntityStore = Preconditions.CheckNotNull(underlyingEntityStore, nameof(underlyingEntityStore));
this.timeout = timeout;
}
public static long LongCount <T>(this IEntityStore <T> store, Expression <Func <T, bool> > conditions)
{
_ = store ?? throw new ArgumentNullException(nameof(store));
return(store.Query(conditions).LongCount());
}
public static void Update <T>(this IEntityStore <T> store, IEnumerable <T> entities, params string[] fields)
where T : class
{
_ = store ?? throw new ArgumentNullException(nameof(store));
entities.ForEach(p => store.Update(p, fields));
}
public static void Update <T>(this IEntityStore <T> store, IEnumerable <T> entities)
where T : class
{
_ = store ?? throw new ArgumentNullException(nameof(store));
entities.ForEach(p => Update(store, p));
}
public Tasks(IEntityStore <TaskRecord> taskRecords)
{
_taskRecords = taskRecords;
}
public FollowLikeHandler(IEntityStore entityStore, APEntity mainObject, APEntity actor, APEntity targetBox, ClaimsPrincipal user, CollectionTools collection, EntityData data) : base(entityStore, mainObject, actor, targetBox, user)
{
_collection = collection;
_data = data;
}
public FakeEntityStore(FakeEntityService fakeEntityService, IEntityStore next)
{
_fakeEntityService = fakeEntityService;
Bypass = next;
}
public AllProductsPaged(IEntityStore <Product> productStore)
{
_productStore = productStore;
}
public static TResult Max <T, TResult>(this IEntityStore <T> store, Expression <Func <T, bool> > conditions, Func <T, TResult> fieldSelector)
where T : class
{
_ = store ?? throw new ArgumentNullException(nameof(store));
return(store.Query(conditions).Max(fieldSelector));
}
public static decimal?Sum <T>(this IEntityStore <T> store, Expression <Func <T, bool> > conditions, Func <T, decimal?> fieldSelector)
where T : class
{
_ = store ?? throw new ArgumentNullException(nameof(store));
return(store.Query(conditions).Sum(fieldSelector));
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2), edgeHubCredentials.Identity);
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(
c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// Task<ICloudConnectionProvider>
builder.Register(
async c =>
{
var productInfoStore = c.Resolve <IProductInfoStore>();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var clientProvider = c.Resolve <IClientProvider>();
var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider");
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
var proxy = c.Resolve <Option <IWebProxy> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
this.connectionPoolSize,
clientProvider,
this.upstreamProtocol,
tokenProvider,
deviceScopeIdentitiesCache,
credentialsCache,
edgeHubCredentials.Identity,
this.cloudConnectionIdleTimeout,
this.closeCloudConnectionOnIdleTimeout,
this.operationTimeout,
proxy,
productInfoStore);
return(cloudConnectionProvider);
})
.As <Task <ICloudConnectionProvider> >()
.SingleInstance();
// IIdentityProvider
builder.Register(_ => new IdentityProvider(this.iotHubName))
.As <IIdentityProvider>()
.SingleInstance();
// Task<IConnectionManager>
builder.Register(
async c =>
{
var cloudConnectionProviderTask = c.Resolve <Task <ICloudConnectionProvider> >();
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var identityProvider = c.Resolve <IIdentityProvider>();
ICloudConnectionProvider cloudConnectionProvider = await cloudConnectionProviderTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
IConnectionManager connectionManager = new ConnectionManager(
cloudConnectionProvider,
credentialsCache,
identityProvider,
this.maxConnectedClients);
return(connectionManager);
})
.As <Task <IConnectionManager> >()
.SingleInstance();
// Task<IEndpointFactory>
builder.Register(
async c =>
{
var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId, this.maxUpstreamBatchSize, this.upstreamFanOutFactor) as IEndpointFactory);
})
.As <Task <IEndpointFactory> >()
.SingleInstance();
// Task<RouteFactory>
builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory)
.As <Task <RouteFactory> >()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (this.useV1TwinManager)
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
ITwinManager twinManager = new PassThroughTwinManager(connectionManager, messageConverterProvider);
return(twinManager);
}
else
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>()));
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(
c =>
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
return(CheckpointStore.Create(storeProvider));
})
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (this.useV1TwinManager)
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider))));
}
else
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
IEntityStore <string, TwinStoreEntity> entityStore = await this.GetTwinStore(c);
IConnectionManager connectionManager = await connectionManagerTask;
ITwinManager twinManager = StoringTwinManager.Create(
connectionManager,
messageConverterProvider,
entityStore,
deviceConnectivityManager,
new ReportedPropertiesValidator(),
this.minTwinSyncPeriod,
this.reportedPropertiesSyncFrequency);
return(twinManager);
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<IInvokeMethodHandler>
builder.Register(
async c =>
{
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler);
})
.As <Task <IInvokeMethodHandler> >()
.SingleInstance();
// Task<ISubscriptionProcessor>
builder.Register(
async c =>
{
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
if (this.disableCloudSubscriptions)
{
return(new LocalSubscriptionProcessor(await connectionManagerTask) as ISubscriptionProcessor);
}
else
{
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
return(new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager) as ISubscriptionProcessor);
}
})
.As <Task <ISubscriptionProcessor> >()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
var routerTask = c.Resolve <Task <Router> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var subscriptionProcessorTask = c.Resolve <Task <ISubscriptionProcessor> >();
Router router = await routerTask;
ITwinManager twinManager = await twinManagerTask;
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
ISubscriptionProcessor subscriptionProcessor = await subscriptionProcessorTask;
IEdgeHub hub = new RoutingEdgeHub(
router,
routingMessageConverter,
connectionManager,
twinManager,
this.edgeDeviceId,
invokeMethodHandler,
subscriptionProcessor);
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore, this.configUpdateFrequency);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >();
if (this.useTwinConfig)
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
ITwinManager twinManager = await twinManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo,
deviceScopeIdentitiesCache);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
IConnectionManager connectionManager = await connectionManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
public static decimal SumOrDefault <T>(this IEntityStore <T> store, Expression <Func <T, bool> > conditions, Func <T, decimal?> fieldSelector)
where T : class
{
var res = store.Sum(conditions, fieldSelector);
return(res.HasValue ? res.Value : default);
public async Task TestEdgeHubConnection()
{
const string EdgeDeviceId = "testHubEdgeDevice1";
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
IotHubConnectionStringBuilder iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(iotHubConnectionString);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
await registryManager.OpenAsync();
string iothubHostName = iotHubConnectionStringBuilder.HostName;
var identityProvider = new IdentityProvider(iothubHostName);
var identityFactory = new ClientCredentialsFactory(identityProvider);
(string edgeDeviceId, string deviceConnStr) = await RegistryManagerHelper.CreateDevice(EdgeDeviceId, iotHubConnectionString, registryManager, true, false);
string edgeHubConnectionString = $"{deviceConnStr};ModuleId={EdgeHubModuleId}";
IClientCredentials edgeHubCredentials = identityFactory.GetWithConnectionString(edgeHubConnectionString);
string sasKey = ConnectionStringHelper.GetSharedAccessKey(deviceConnStr);
var signatureProvider = new SharedAccessKeySignatureProvider(sasKey);
var credentialsCache = Mock.Of <ICredentialsCache>();
var productInfoStore = Mock.Of <IProductInfoStore>();
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
new ClientProvider(),
Option.None <UpstreamProtocol>(),
new ClientTokenProvider(signatureProvider, iothubHostName, edgeDeviceId, TimeSpan.FromMinutes(60)),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubCredentials.Identity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), identityProvider);
try
{
Mock.Get(credentialsCache)
.Setup(c => c.Get(edgeHubCredentials.Identity))
.ReturnsAsync(Option.Some(edgeHubCredentials));
Assert.NotNull(edgeHubCredentials);
Assert.NotNull(edgeHubCredentials.Identity);
// Set Edge hub desired properties
await this.SetDesiredProperties(registryManager, edgeDeviceId);
var endpointFactory = new EndpointFactory(connectionManager, new RoutingMessageConverter(), edgeDeviceId, 10, 10);
var routeFactory = new EdgeRouteFactory(endpointFactory);
var dbStoreProvider = new InMemoryDbStoreProvider();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, TwinInfo> twinStore = storeProvider.GetEntityStore <string, TwinInfo>("twins");
var twinManager = new TwinManager(connectionManager, twinCollectionMessageConverter, twinMessageConverter, Option.Some(twinStore));
var routerConfig = new RouterConfig(Enumerable.Empty <Route>());
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorFactory = new SyncEndpointExecutorFactory(new EndpointExecutorConfig(defaultTimeout, new FixedInterval(0, TimeSpan.FromSeconds(1)), defaultTimeout, true));
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), iothubHostName, routerConfig, endpointExecutorFactory);
IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
IEdgeHub edgeHub = new RoutingEdgeHub(router, new RoutingMessageConverter(), connectionManager, twinManager, edgeDeviceId, invokeMethodHandler, subscriptionProcessor);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var versionInfo = new VersionInfo("v1", "b1", "c1");
// Create Edge Hub connection
EdgeHubConnection edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
// Get and Validate EdgeHubConfig
Option <EdgeHubConfig> edgeHubConfigOption = await edgeHubConnection.GetConfig();
Assert.True(edgeHubConfigOption.HasValue);
EdgeHubConfig edgeHubConfig = edgeHubConfigOption.OrDefault();
Assert.Equal("1.0", edgeHubConfig.SchemaVersion);
Assert.NotNull(edgeHubConfig.Routes);
Assert.NotNull(edgeHubConfig.StoreAndForwardConfiguration);
Assert.Equal(20, edgeHubConfig.StoreAndForwardConfiguration.TimeToLiveSecs);
IReadOnlyDictionary <string, RouteConfig> routes = edgeHubConfig.Routes;
Assert.Equal(4, routes.Count);
RouteConfig route1 = routes["route1"];
Assert.True(route1.Route.Endpoints.First().GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
RouteConfig route2 = routes["route2"];
Endpoint endpoint = route2.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
RouteConfig route3 = routes["route3"];
endpoint = route3.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module3/input1", endpoint.Id);
Assert.Equal("route3", route3.Name);
Assert.Equal("from /modules/module2 INTO BrokeredEndpoint(\"/modules/module3/inputs/input1\")", route3.Value);
RouteConfig route4 = routes["route4"];
endpoint = route4.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module4/input1", endpoint.Id);
Assert.Equal("route4", route4.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module4/inputs/input1\")", route4.Value);
// Make sure reported properties were updated appropriately
EdgeHubConnection.ReportedProperties reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(0, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Simulate a module and a downstream device that connects to Edge Hub.
string moduleId = "module1";
string sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{edgeDeviceId}/modules/{moduleId}");
string moduleConnectionstring = $"HostName={iothubHostName};DeviceId={edgeDeviceId};ModuleId={moduleId};SharedAccessSignature={sasToken}";
IClientCredentials moduleClientCredentials = identityFactory.GetWithConnectionString(moduleConnectionstring);
var moduleProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
string downstreamDeviceId = "device1";
sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{downstreamDeviceId}");
string downstreamDeviceConnectionstring = $"HostName={iothubHostName};DeviceId={downstreamDeviceId};SharedAccessSignature={sasToken}";
IClientCredentials downstreamDeviceCredentials = identityFactory.GetWithConnectionString(downstreamDeviceConnectionstring);
var downstreamDeviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
// Connect the module and downstream device and make sure the reported properties are updated as expected.
await connectionManager.AddDeviceConnection(moduleClientCredentials.Identity, moduleProxy);
await connectionManager.AddDeviceConnection(downstreamDeviceCredentials.Identity, downstreamDeviceProxy);
string moduleIdKey = $"{edgeDeviceId}/{moduleId}";
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[downstreamDeviceId].Status);
Assert.NotNull(reportedProperties.Clients[downstreamDeviceId].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[downstreamDeviceId].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Update desired propertied and make sure callback is called with valid values
bool callbackCalled = false;
Task ConfigUpdatedCallback(EdgeHubConfig updatedConfig)
{
Assert.NotNull(updatedConfig);
Assert.NotNull(updatedConfig.StoreAndForwardConfiguration);
Assert.NotNull(updatedConfig.Routes);
routes = updatedConfig.Routes;
Assert.Equal(4, routes.Count);
route1 = routes["route1"];
Assert.True(route1.Route.Endpoints.First().GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
route2 = routes["route2"];
endpoint = route2.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
route3 = routes["route4"];
endpoint = route3.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module5/input1", endpoint.Id);
Assert.Equal("route4", route3.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module5/inputs/input1\")", route3.Value);
route4 = routes["route5"];
endpoint = route4.Route.Endpoints.First();
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module6/input1", endpoint.Id);
Assert.Equal("route5", route4.Name);
Assert.Equal("from /modules/module5 INTO BrokeredEndpoint(\"/modules/module6/inputs/input1\")", route4.Value);
callbackCalled = true;
return(Task.CompletedTask);
}
edgeHubConnection.SetConfigUpdatedCallback(ConfigUpdatedCallback);
await this.UpdateDesiredProperties(registryManager, edgeDeviceId);
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.True(callbackCalled);
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Disconnect the downstream device and make sure the reported properties are updated as expected.
await connectionManager.RemoveDeviceConnection(moduleIdKey);
await connectionManager.RemoveDeviceConnection(downstreamDeviceId);
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(1, reportedProperties.Clients.Count);
Assert.True(reportedProperties.Clients.ContainsKey(moduleIdKey));
Assert.False(reportedProperties.Clients.ContainsKey(downstreamDeviceId));
Assert.Equal(ConnectionStatus.Disconnected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// If the edge hub restarts, clear out the connected devices in the reported properties.
await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Null(reportedProperties.Clients);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
}
finally
{
try
{
await RegistryManagerHelper.RemoveDevice(edgeDeviceId, registryManager);
}
catch (Exception)
{
// ignored
}
}
}
public ActivityMissingFieldsHandler(IEntityStore entityStore, APEntity mainObject, APEntity actor, APEntity targetBox, ClaimsPrincipal user) : base(entityStore, mainObject, actor, targetBox, user)
{
}
public SpamFilter(IEntityStore entityStore, APEntity mainObject, APEntity actor, APEntity targetBox, ClaimsPrincipal user) : base(entityStore, mainObject, actor, targetBox, user)
{
}
public static async Task <DockerEnvironmentProvider> CreateAsync(IRuntimeInfoProvider runtimeInfoProvider, IEntityStore <string, ModuleState> store,
IRestartPolicyManager restartPolicyManager)
{
SystemInfo systemInfo = await Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider)).GetSystemInfo();
return(new DockerEnvironmentProvider(
runtimeInfoProvider, store, restartPolicyManager,
systemInfo.OperatingSystemType, systemInfo.Architecture,
systemInfo.Version));
}
public AS2Converter(IEntityStore entityStore, EntityFlattener flattener, AS2ConverterFactory factory)
{
_entityStore = entityStore;
_flattener = flattener;
_factory = factory;
}
public DeliverToWebSubTask(EventQueueItem item, IEntityStore entityStore, APContext context, AtomEntryGenerator entryGenerator) : base(item)
{
_entityStore = entityStore;
_context = context;
_entryGenerator = entryGenerator;
}
public ReportsObjectSpace(ITypesInfo typesInfo, IEntityStore entityStore, IObjectSpace innerObjectSpace)
: base(typesInfo, entityStore)
{
ObjectsGetting += ReportsObjectSpace_ObjectsGetting;
this.innerObjectSpace = innerObjectSpace;
}
public static string Serialize(this IEntityStore entityStore)
{
return(String.Join(Environment.NewLine, entityStore.Quads.Select(q => q.ToString(true))));
}
public async Task BatchWithKeyResetTest()
{
// Arrange
var encryptionProvider = new ResettableEncryptionProvider();
IEntityStore <string, string> entityStore = GetEntityStore <string, string>("smokeTest");
IKeyValueStore <string, TestDevice> encryptedStore = new EncryptedStore <string, TestDevice>(entityStore, encryptionProvider);
IDictionary <string, TestDevice> devices = new Dictionary <string, TestDevice>();
for (int i = 0; i < 10; i++)
{
devices[$"d{i}"] = new TestDevice(Guid.NewGuid().ToString(), new KeyAuth(Guid.NewGuid().ToString()));
}
// Act
foreach (KeyValuePair <string, TestDevice> device in devices)
{
await encryptedStore.Put(device.Key, device.Value);
}
IDictionary <string, TestDevice> obtainedDevices = new Dictionary <string, TestDevice>();
await encryptedStore.IterateBatch(
10,
(key, device) =>
{
obtainedDevices[key] = device;
return(Task.CompletedTask);
});
// Assert
Assert.Equal(devices.Count, obtainedDevices.Count);
foreach (KeyValuePair <string, TestDevice> device in devices)
{
Assert.Equal(device.Value.GenId, obtainedDevices[device.Key].GenId);
Assert.Equal(device.Value.Auth.Key, obtainedDevices[device.Key].Auth.Key);
}
// Act
Option <(string key, TestDevice value)> first = await encryptedStore.GetFirstEntry();
Option <(string key, TestDevice value)> last = await encryptedStore.GetLastEntry();
// Assert
Assert.True(first.HasValue);
Assert.True(last.HasValue);
Assert.Equal("d0", first.OrDefault().key);
Assert.Equal(devices["d0"].GenId, first.OrDefault().value.GenId);
Assert.Equal("d9", last.OrDefault().key);
Assert.Equal(devices["d9"].GenId, last.OrDefault().value.GenId);
// Act
encryptionProvider.Reset();
obtainedDevices = new Dictionary <string, TestDevice>();
await encryptedStore.IterateBatch(
10,
(key, device) =>
{
obtainedDevices[key] = device;
return(Task.CompletedTask);
});
// Assert
Assert.Equal(0, obtainedDevices.Count);
// Act
first = await encryptedStore.GetFirstEntry();
last = await encryptedStore.GetLastEntry();
// Assert
Assert.False(first.HasValue);
Assert.False(last.HasValue);
// Act
foreach (KeyValuePair <string, TestDevice> device in devices)
{
await encryptedStore.Put(device.Key, device.Value);
}
obtainedDevices = new Dictionary <string, TestDevice>();
await encryptedStore.IterateBatch(
10,
(key, device) =>
{
obtainedDevices[key] = device;
return(Task.CompletedTask);
});
// Assert
Assert.Equal(devices.Count, obtainedDevices.Count);
foreach (KeyValuePair <string, TestDevice> device in devices)
{
Assert.Equal(device.Value.GenId, obtainedDevices[device.Key].GenId);
Assert.Equal(device.Value.Auth.Key, obtainedDevices[device.Key].Auth.Key);
}
// Act
first = await encryptedStore.GetFirstEntry();
last = await encryptedStore.GetLastEntry();
// Assert
Assert.True(first.HasValue);
Assert.True(last.HasValue);
Assert.Equal("d0", first.OrDefault().key);
Assert.Equal(devices["d0"].GenId, first.OrDefault().value.GenId);
Assert.Equal("d9", last.OrDefault().key);
Assert.Equal(devices["d9"].GenId, last.OrDefault().value.GenId);
}
public Task RemoveStore <TK, TV>(IEntityStore <TK, TV> entityStore)
{
this.dbStoreProvider.RemoveDbStore(entityStore.EntityName);
return(Task.CompletedTask);
}
public RenderController(IEntityStore entityStore, TemplateService templateService, CollectionTools collectionTools)
{
_entityStore = new CollectionEntityStore(collectionTools, entityStore);
_templateService = templateService;
}
public SignatureVerifier(IEntityStore entityStore, DbConnection connection)
{
_entityStore = entityStore;
_connection = connection;
}
public SessionStateStoragePersistenceProvider(IEdgeHub edgeHub, IEntityStore <string, SessionState> sessionStore)
: base(edgeHub)
{
this.sessionStore = Preconditions.CheckNotNull(sessionStore, nameof(sessionStore));
}
public BookService(IEntityStore <Book> entityStore)
{
this.entityStore = entityStore;
}
public IssueViewComponent(IEntityStore <Issue> entityStore)
{
_entityStore = entityStore;
}
public CollectionEntityStore(CollectionTools collectionTools, IEntityStore next)
{
_collectionTools = collectionTools;
Bypass = next;
}
