private void LocalStorage_StorageBeforeLoad() { Log.WriteLine("BeforeLoad"); Serialization.Deserialize <List <VersionRecorder> >(PathHelper.VersionRecorders) .WhenNotDefault(_ => CompositeStorage.VersionRecorders = _); Serialization.Deserialize <Dictionary <string, int> >(PathHelper.CellTypeIDs) .WhenNotDefault(_ => CompositeStorage.CellTypeIDs = _); Serialization.Deserialize <List <int> >(PathHelper.IDIntervals) .WhenNotDefault(_ => CompositeStorage.IDIntervals = _); if (CompositeStorage.VersionRecorders != default(List <VersionRecorder>)) { var asm = CompositeStorage.VersionRecorders .Select(each => $"{each.Namespace}.dll" .By(PathHelper.DLL) .By(Assembly.LoadFrom)) .ToList(); CompositeStorage.StorageSchema = asm.Select(_ => AssemblyUtility.GetAllClassInstances <IStorageSchema>(assembly: _).First()).ToList(); CompositeStorage.GenericCellOperations = asm.Select(_ => AssemblyUtility.GetAllClassInstances <IGenericCellOperations>(assembly: _).First()).ToList(); } }
public void LoadsDynamically() { BlobStorageConfig.Instance.ConnectionString = "DefaultEndpointsProtocol=https;AccountName=redtest;AccountKey=cJF7OVo5NluWtotOAE5ZA362UlXKvHPEE7khssSzamQfs8b3KMvL8CTMskD4Fa491AuLbVA0NffuCwiJj6crDA==;EndpointSuffix=core.windows.net"; BlobStorageConfig.Instance.ContainerName = "TestContainer"; var azure_store = AssemblyUtility.GetAllClassInstances <IPersistentStorage>().First(); Assert.AreEqual(typeof(BlobStoragePersistentStorage), azure_store.GetType()); }
public void LoadsDynamically2() { BlobStorageConfig.Instance.ConnectionString = "not-a-connection-string"; BlobStorageConfig.Instance.ContainerName = "TestContainer"; var azure_store = AssemblyUtility.GetAllClassInstances <IPersistentStorage>().First(); Assert.AreEqual(typeof(BlobStoragePersistentStorage), azure_store.GetType()); }
internal static IEnumerable <ICommunicationSchema> ScanForTSLCommunicationSchema(RunningMode schemaRunningMode) { Debug.Assert(schemaRunningMode == RunningMode.Server || schemaRunningMode == RunningMode.Proxy); var schema_interface_type = typeof(ICommunicationSchema); var comm_instance_base_type = schemaRunningMode == RunningMode.Server ? typeof(TrinityServer) : typeof(TrinityProxy); var default_comm_schema = typeof(DefaultCommunicationSchema); return(AssemblyUtility.GetAllClassInstances <ICommunicationSchema, CommunicationSchemaAttribute>( _ => comm_instance_base_type.IsAssignableFrom(_) && _ != default_comm_schema, _ => _.CommunicationSchemaType .GetConstructor(new Type[] { }) .Invoke(new object[] { }) as ICommunicationSchema)); }
public void LoadsDynamically4() { BlobStorageConfig.Instance.ConnectionString = null; BlobStorageConfig.Instance.ContainerName = "TestContainer"; var azure_store = AssemblyUtility.GetAllClassInstances <IPersistentStorage>().First(); Assert.AreEqual(typeof(BlobStoragePersistentStorage), azure_store.GetType()); try { azure_store.CreateNewVersion().Wait(); } catch (AggregateException aex) { throw aex.InnerException; } }
private void _OnCommunicationInstanceStart() { m_module = Global.CommunicationInstance.GetCommunicationModule <TrinityFFIModule>(); Log.WriteLine("Scanning for foreign runtime providers."); m_providers = AssemblyUtility.GetAllClassInstances <ILanguageRuntimeProvider>(); foreach (var runtime_provider in m_providers) { try { ProgramRunner runner = new ProgramRunner(runtime_provider, m_module); Log.WriteLine("Discovered foreign runtime provider '{0}'.", runtime_provider.Name); foreach (var format in runtime_provider.SupportedSuffix) { m_runners[format] = runner; Log.WriteLine(LogLevel.Debug, "Use {0} to load *.{1}.", runtime_provider.Name, format); } } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "Failed to load foreign runtime provider '{0}':{1}", runtime_provider.Name, ex.ToString()); } } Log.WriteLine("Scanning for FFI Programs."); string dir; string[] files; dir = FFIConfig.Instance.ProgramDirectory; dir = FileUtility.CompletePath(dir, create_nonexistent: true); files = Directory.GetFiles(dir); foreach (var file in files) { try { var suffix = Path.GetExtension(file); if (m_runners.TryGetValue(suffix, out var runner)) { Log.WriteLine("Loading program {0} with {1}.", Path.GetFileName(file), runner.RuntimeName); runner.LoadProgram(file); } } catch { } } }
public override bool Open(ClusterConfig config, bool nonblocking) { this.m_cluster_config = config; m_cancelSrc = new CancellationTokenSource(); m_nameservice = AssemblyUtility.GetAllClassInstances <INameService>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using name service provided by '{m_nameservice.GetType().FullName}'"); m_chunktable = AssemblyUtility.GetAllClassInstances <IChunkTable>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using chunk table provided by '{m_chunktable.GetType().FullName}'"); m_taskqueue = AssemblyUtility.GetAllClassInstances <ITaskQueue>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using task queue provided by '{m_taskqueue.GetType().FullName}'"); m_healthmanager = AssemblyUtility.GetAllClassInstances <IHealthManager>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using health manager provided by '{m_healthmanager.GetType().FullName}'"); m_backupmgr = AssemblyUtility.GetAllClassInstances <IBackupManager>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using backup manager provided by '{m_backupmgr.GetType().FullName}'"); m_persistent_storage = AssemblyUtility.GetAllClassInstances <IPersistentStorage>().First(); Log.WriteLine(LogLevel.Info, $"{nameof(DynamicMemoryCloud)}: using persistent storage provided by '{m_persistent_storage.GetType().FullName}'"); m_nameservice.Start(m_cancelSrc.Token); m_taskqueue.Start(m_cancelSrc.Token); m_chunktable.Start(m_cancelSrc.Token); m_healthmanager.Start(m_cancelSrc.Token); m_backupmgr.Start(m_cancelSrc.Token); m_myid = GetInstanceId(InstanceGuid); m_storageTable = new DynamicStorageTable(PartitionCount); m_storageTable[m_myid] = Global.LocalStorage; NickName = GenerateNickName(InstanceGuid); int redundancy = DynamicClusterConfig.Instance.MinimumReplica; m_cloudidx = new CloudIndex(m_cancelSrc.Token, m_nameservice, m_chunktable, this, NickName, PartitionTable); m_healthmon = new HealthMonitor(m_cancelSrc.Token, m_nameservice, m_cloudidx, m_healthmanager, redundancy); m_partitioner = new Partitioner(m_cancelSrc.Token, m_cloudidx, m_nameservice, m_taskqueue, DynamicClusterConfig.Instance.ReplicationMode, redundancy); m_taskexec = new Executor(m_cancelSrc.Token, m_nameservice, m_taskqueue); m_backupctl = new BackupController(m_cancelSrc.Token, m_backupmgr, m_nameservice, m_persistent_storage, m_taskqueue); Log.WriteLine($"{nameof(DynamicMemoryCloud)}: Partition {MyPartitionId}: Instance '{NickName}' {InstanceGuid} opened."); Global.CommunicationInstance.Started += InitModule; return(true); }
/// <returns>E_SUCCESS if all the tasks are successfully executed. E_FAILURE otherwise.</returns> private static TrinityErrorCode _ScanForStartupTasks() { Log.WriteLine(LogLevel.Info, "Scanning for startup tasks."); bool all_good = true; var tasks = AssemblyUtility.GetAllClassInstances <IStartupTask>(); foreach (var task in tasks) { try { task.Run(); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "An error occured while executing a startup task: {0}", ex.ToString()); all_good = false; } } return(all_good ? TrinityErrorCode.E_SUCCESS : TrinityErrorCode.E_FAILURE); }
public static IEnumerable <ServiceReplicaListener> CreateServiceReplicaListeners(StatefulServiceContext context) => AssemblyUtility.GetAllClassInstances <GraphEngineListenerBase>() .Select(l => l._Setup(context)) .Select(l => new ServiceReplicaListener(ctx => l, l.ListenerName, l.ListenOnSecondaries));
/// <summary> /// Gets all the configuration instances /// </summary> /// <returns></returns> internal static List <ConfigurationInstance> GetConfigurationInstances() { return(Enumerable.OfType <ConfigurationInstance>(AssemblyUtility.GetAllClassInstances <object>(CreateConfigurationInstance)).ToList()); }
private static IStorageSchema Load(StorageExtensionRecord ext, bool primary) { // capture states var ctoffset = ext.CellTypeOffset; var ctmap = new Dictionary <string, int>(s_CellTypeIDs); var gcops = new List <IGenericCellOperations>(s_GenericCellOperations); var schemas = new List <IStorageSchema>(s_StorageSchemas); var iditv = new List <int>(s_IDIntervals); var pshadow = ShadowCopy(Path.Combine(PathHelper.StorageSlot(primary), ext.AssemblyName)); var apath = Path.Combine(pshadow, ext.AssemblyName + ".dll"); var asm = Assembly.LoadFrom(apath); Log.WriteLine(LogLevel.Debug, $"{nameof(CompositeStorage)}: assembly from {apath} is loaded."); new[] { "Current Storage Info:", $"#Loaded extensions: {s_Extensions.Count}", $"#IDIntervals: : {iditv.Count}", $"#CellTypeIDs:{ctmap.Count}", $"#StorageSchema:{schemas.Count}", $"#GenericCellOperations:{gcops.Count}" } .Each(_ => Log.WriteLine(LogLevel.Debug, $"{nameof(CompositeStorage)}: {{0}}", _)); var schema = AssemblyUtility.GetAllClassInstances <IStorageSchema>(assembly: asm).FirstOrDefault(); var cellOps = AssemblyUtility.GetAllClassInstances <IGenericCellOperations>(assembly: asm).FirstOrDefault(); if (schema == null || cellOps == null) { throw new AsmLoadException("Not a TSL extension."); } var cellDescs = schema.CellDescriptors.ToList(); schemas.Add(schema); gcops.Add(cellOps); int maxoffset = ctoffset; foreach (var cellDesc in cellDescs) { if (ctmap.TryGetValue(cellDesc.TypeName, out var existing_tid)) { Log.WriteLine(LogLevel.Info, $"{nameof(CompositeStorage)}: overriding type {cellDesc.TypeName}: TypeId {existing_tid}->{cellDesc.CellType}"); } ctmap[cellDesc.TypeName] = cellDesc.CellType; if (cellDesc.CellType < ctoffset) { throw new AsmLoadException("New cell type id conflicts existing type space"); } maxoffset = Math.Max(maxoffset, cellDesc.CellType); } ctoffset += cellDescs.Count + 1; // extra typeid for undefined/reserved cell type if (ctoffset != maxoffset + 1) { throw new AsmLoadException("The whole type id space is not compact"); } iditv.Add(ctoffset); if (!iditv.OrderBy(_ => _).SequenceEqual(iditv)) { throw new AsmLoadException("intervals do not grow monotonically"); } // commit states lock (s_lock) { s_currentCellTypeOffset = ctoffset; s_CellTypeIDs = ctmap; s_GenericCellOperations = gcops; s_StorageSchemas = schemas; s_IDIntervals = iditv; s_Extensions.Add(ext); Log.WriteLine(LogLevel.Info, $"{nameof(CompositeStorage)}: storage extension '{ext.RootNamespace}' loaded"); return(schema); } }