public async Task <ActionResult> DeleteGet(string ns, string name) { if (string.IsNullOrEmpty(name)) { name = "(default)"; } if (!ModuleIdentifier.TryParse(ns, out var module)) { logger.LogDebug("invalid module"); return(BadRequest()); } logger.LogDebug($"Delete {ns}:{name}"); var found = await context.ModuleInstances.FirstOrDefaultAsync( m => m.Module == ns.ToLower() && m.Name == name.ToLower() ); if (found == null) { return(NotFound($"No such module: {ns}/{name}")); } context.Remove(found); await context.SaveChangesAsync(); return(Ok()); }
public static void get_report(Guid applicationId, ModuleIdentifier moduleIdentifier, string reportName, ref DataTable retReport, ref string retActions, ref Dictionary <string, string> columnsDic, List <ReportParameter> parameters) { DataProvider.GetReport(applicationId, moduleIdentifier, reportName, ref retReport, ref retActions, ref columnsDic, parameters); }
public static ValueTask <BlazorModuleManifest?> GetModuleManifestAsync( this IModuleManifestProvider moduleManifestProvider, ModuleIdentifier module, CancellationToken cancellation = default) { return(moduleManifestProvider.GetModuleManifestAsync(module, bypassCache: false, cancellation)); }
private async ValueTask <ModuleProperties?> InternalLookupAsync(ModuleIdentifier module, CancellationToken cancellation) { var maxTries = 10; var timeToWait = new TimeSpan(TimeSpan.TicksPerSecond * 2); for (var i = 0; i < maxTries; i++) { var query = new ModulePropertiesQuery(module); var queryResult = await _messageDispatcher.DispatchAsync(query, cancellation); if (queryResult.IsSuccessWithResult <ModuleProperties>(out var moduleProperties)) { Assert(moduleProperties != null); return(_cache.GetOrAdd(module, moduleProperties !)); } if (!queryResult.IsNotFound()) { _logger?.LogError($"Unable to lookup end-point for module '{module.Name}' for reason: {(queryResult.IsSuccess ? "Wrong type returned" : queryResult.ToString())}."); break; } await Task.Delay(timeToWait, cancellation).ConfigureAwait(false); } return(null); }
public IList <ModuleIdentifier> GetAvailableModules() { var dir = optionsMonitor.CurrentValue.Source; if (!Directory.Exists(dir)) { logger.LogError("Config catalog directory not found: " + dir); throw new ApplicationException("Config catalog directory not found"); } var list = new List <ModuleIdentifier>(); foreach (var file in Directory.GetFiles(dir)) { if (Path.GetExtension(file).ToLower() != ".json") { continue; } var name = Path.GetFileNameWithoutExtension(file); if (ModuleIdentifier.TryParse(name, out var identifier)) { list.Add(identifier); } } foreach (var file in Directory.GetDirectories(dir)) { var name = Path.GetFileName(file); if (ModuleIdentifier.TryParse(name, out var identifier)) { list.Add(identifier); } } return(list); }
// TODO: Refactor to own component private async ValueTask <Module> GetModuleAsync(ModuleIdentifier module, CancellationToken cancellation) { using (var scope = _serviceProvider.CreateScope()) { var storageEngine = scope.ServiceProvider.GetRequiredService <IEntityStorageEngine>(); return(await storageEngine.GetByIdAsync <Module>(module.ToString(), cancellation)); } }
/// <summary> /// Costruisce una nuova specifica /// </summary> /// <param name="moduleIdentifier">Module identifier.</param> public static Builder build(ModuleIdentifier moduleIdentifier) { if (moduleIdentifier == null) { throw new ArgumentException("ERROR: provide a valid module indentifier"); } return(new BuilderImpl(moduleIdentifier)); }
private static void _parse_logs(ref IDataReader reader, ref List <Log> lstLogs) { while (reader.Read()) { try { Log log = new Log(); if (!string.IsNullOrEmpty(reader["LogID"].ToString())) { log.LogID = (long)reader["LogID"]; } if (!string.IsNullOrEmpty(reader["UserID"].ToString())) { log.UserID = (Guid)reader["UserID"]; } if (!string.IsNullOrEmpty(reader["Date"].ToString())) { log.Date = (DateTime)reader["Date"]; } if (!string.IsNullOrEmpty(reader["HostName"].ToString())) { log.HostName = (string)reader["HostName"]; } if (!string.IsNullOrEmpty(reader["HostAddress"].ToString())) { log.HostAddress = (string)reader["HostAddress"]; } if (!string.IsNullOrEmpty(reader["Info"].ToString())) { log.Info = (string)reader["Info"]; } Action acn = Action.None; if (!Enum.TryParse <Action>(reader["Action"].ToString(), out acn)) { continue; } ModuleIdentifier mi = ModuleIdentifier.RV; if (!Enum.TryParse <ModuleIdentifier>(reader["ModuleIdentifier"].ToString(), out mi)) { continue; } log.Action = acn; log.ModuleIdentifier = mi; lstLogs.Add(log); } catch { } } if (!reader.IsClosed) { reader.Close(); } }
public bool ContainsModule(ModuleIdentifier module) { if (_resolved == null) { return(false); } return(_resolved.ContainsKey(module)); }
public UnresolvedInstallationSet SetVersionRange(ModuleIdentifier module, ModuleVersionRange versionRange) { if (_resolved != null && _resolved.ContainsKey(module)) { throw new InvalidOperationException(); } return(new UnresolvedInstallationSet(_resolved ?? ImmutableDictionary <ModuleIdentifier, ModuleVersion> .Empty, (_unresolved ?? ImmutableDictionary <ModuleIdentifier, ModuleVersionRange> .Empty).SetItem(module, versionRange))); }
public UnresolvedInstallationSet WithUnresolved(ModuleIdentifier module, ModuleVersionRange versionRange) { if (ContainsModule(module)) { throw new InvalidOperationException(); } return(new UnresolvedInstallationSet(_resolved ?? ImmutableDictionary <ModuleIdentifier, ModuleVersion> .Empty, (_unresolved ?? ImmutableDictionary <ModuleIdentifier, ModuleVersionRange> .Empty).Add(module, versionRange))); }
public async Task <IActionResult> Uninstall(ModuleIdentifier id) { var queryResult = await _messageDispatcher.QueryByIdAsync <ModuleIdentifier, ModuleUninstallModel>(id); if (queryResult.IsSuccessWithResult <ModuleUninstallModel>(out var model)) { return(View(model)); } return(GetActionResult(queryResult)); }
public bool HasCompatibleCatalog(ModuleIdentifier module) { if (catalogCache.ContainsKey(module)) { return(true); } return(catalogCache.Keys.Any( m => string.Compare(m.Name, module.Name, StringComparison.OrdinalIgnoreCase) == 0 && m.Version.Major == module.Version.Major)); }
private async Task <string> GetNormalizedPrefixAsync(ModuleIdentifier module, CancellationToken cancellation) { var prefix = await GetPrefixAsync(module, cancellation); if (!prefix.StartsWith("/", StringComparison.OrdinalIgnoreCase)) { prefix = "/" + prefix; } return(prefix); }
public static Guid?get_report_id(ModuleIdentifier moduleIdentifier, string reportName) { string name = (moduleIdentifier.ToString() + "_" + reportName).ToLower(); Guid? id = null; if (ReportIDs.Any(u => u.Key.ToLower() == name)) { id = ReportIDs.Where(u => u.Key.ToLower() == name).First().Value; } return(id); }
public ValueTask <BlazorModuleManifest?> GetModuleManifestAsync(ModuleIdentifier module, bool bypassCache, CancellationToken cancellation) { _logger?.LogDebug($"Requesting manifest for module {module}."); if (!bypassCache && _cache.TryGetValue(module, out var result)) { _logger?.LogTrace($"Successfully loaded manifest for module {module} from cache."); return(new ValueTask <BlazorModuleManifest?>(result)); } return(GetModuleManifestCoreAsync(module, cancellation)); }
private static DebugModuleProperties Decode(ReadOnlySpan <byte> memory) { var reader = new BinarySpanReader(memory, ByteOrder.LittleEndian); var endPoint = new EndPointAddress(reader.Read().ToArray()); // TODO: This copies var module = new ModuleIdentifier(reader.ReadString()); var major = reader.ReadInt32(); var minor = reader.ReadInt32(); var revision = reader.ReadInt32(); var isPreRelease = reader.ReadBool(); var version = new ModuleVersion(major, minor, revision, isPreRelease); return(new DebugModuleProperties(endPoint, module, version)); }
public Task ModuleUninstalledAsync(ModuleIdentifier module, IDependencyResolver dependencyResolver, // TODO: This should be injected via DI CancellationToken cancellation = default) { if (module == default) { throw new ArgumentDefaultException(nameof(module)); } InstalledModules = InstalledModules.WithoutUnresolved(module); return(ResolveDependenciesAsync(dependencyResolver, cancellation)); }
public async Task InstallAssemblyAsync(ModuleIdentifier module, string assemblyName, CancellationToken cancellation) { Console.WriteLine("Loading assembly: " + assemblyName); var assemblyUri = GetAssemblyUri(await GetNormalizedPrefixAsync(module, cancellation), assemblyName); using (var assemblyStream = await _httpClient.GetStreamAsync(assemblyUri)) using (var localAssemblyStream = await assemblyStream.ReadToMemoryAsync(cancellation)) { var assemblyBytes = localAssemblyStream.ToArray(); var assembly = Assembly.Load(assemblyBytes); } }
public ModuleVersion?GetResolvedVersion(ModuleIdentifier module) { if (_resolved == null) { return(null); } if (!_resolved.TryGetValue(module, out var result)) { return(null); } return(result); }
public ValueTask <ModuleProperties?> LookupAsync(ModuleIdentifier module, CancellationToken cancellation) { if (module == default) { throw new ArgumentDefaultException(nameof(module)); } if (_cache.TryGetValue(module, out var moduleProperties)) { return(new ValueTask <ModuleProperties?>(moduleProperties)); } return(InternalLookupAsync(module, cancellation)); }
public ValueTask <string> LookupPrefixAsync(ModuleIdentifier module, CancellationToken cancellation) { if (module == default) { throw new ArgumentDefaultException(nameof(module)); } if (_prefixCache.TryGetValue(module, out var modulePrefix)) { return(new ValueTask <string>(modulePrefix)); } return(new ValueTask <string>(InternalLookupPrefixAsync(module, cancellation))); }
public ValueTask <EndPointAddress> LookupEndPointAsync(ModuleIdentifier module, CancellationToken cancellation) { if (module == default) { throw new ArgumentDefaultException(nameof(module)); } if (_endPointCache.TryGetValue(module, out var endPoint)) { return(new ValueTask <EndPointAddress>(endPoint)); } return(new ValueTask <EndPointAddress>(InternalLookupEndPointAsync(module, cancellation))); }
public bool ContainsModule(ModuleIdentifier module) { if (_resolved != null && _resolved.ContainsKey(module)) { return(true); } if (_unresolved != null && _unresolved.ContainsKey(module)) { return(true); } return(false); }
public ConfigCatalog GetCompatibleCatalog(ModuleIdentifier module) { if (catalogCache.TryGetValue(module, out var catalog)) { return(catalog); } var found = catalogCache.Keys .Where(m => string.Compare(m.Name, module.Name, StringComparison.OrdinalIgnoreCase) == 0) .OrderByDescending(m => m.Version) .FirstOrDefault(m => m.Version.Major == module.Version.Major); return(catalogCache.TryGetValue(found, out catalog) ? catalog : null); }
public ConfigCatalog LoadCatalogForModule(ModuleIdentifier module) { var dir = optionsMonitor.CurrentValue.Source; var catalog = new ConfigCatalog() { ModuleInfo = new ModuleInfo() { Identifier = module } }; var basename = Path.Combine(dir, module.ToString()); if (File.Exists(basename + ".json")) { logger.LogTrace($"load catalog file [{basename}.json]"); string content = File.ReadAllText(basename + ".json"); catalog = JsonConvert.DeserializeObject <ConfigCatalog>(content); } if (Directory.Exists(basename)) { logger.LogTrace($"load catalog dir [{basename}]"); var sections = new List <ConfigCatalog.Section>(); foreach (var file in Directory.GetFiles(basename)) { logger.LogTrace($"-> loading {file}"); if (Path.GetExtension(file).ToLower() != ".json") { break; } string content = File.ReadAllText(file); if (Path.GetFileNameWithoutExtension(file) == "moduleinfo") { catalog.ModuleInfo = JsonConvert.DeserializeObject <ModuleInfo>(content); } else { var section = JsonConvert.DeserializeObject <ConfigCatalog.Section>(content); sections.Add(section); } } catalog.Sections = sections.ToArray(); } return(catalog); }
// TODO: This should be internal, but we have to split the interface to do this. public void Terminated(ModuleIdentifier module) { bool removed; lock (_mutex) { var modules = _modules; _modules = _modules.Remove(module); removed = modules != _modules; } if (removed) { ModuleTerminated?.InvokeAll(this, module); } }
public async Task <ActionResult <ConfigCatalog> > GetCompatibleCatalog(string ns) { if (!ModuleIdentifier.TryParse(ns, out var module)) { logger.LogDebug("invalid module"); return(BadRequest()); } await moduleCatalogManager.LoadModuleCatalogCache(); var catalog = moduleCatalogManager.GetCompatibleCatalog(module); if (catalog == null) { return(NotFound()); } return(catalog); }
/// <summary> /// crea un alias per il modulo, ossia all'interno del sistema posso riferire /// ad uno stesso modulo tramite il suo alias. /// </summary> /// <returns>The alias.</returns> /// <param name="moduleIdentifier">Module identifier.</param> /// <param name="aliasTarget">Alias target, ossia il nome dell'alias </param> public static AliasBuilder buildAlias(ModuleIdentifier moduleIdentifier, ModuleIdentifier aliasTarget) { if (moduleIdentifier == null) { throw new ArgumentException("[ERROR] - moduleIdentifier is null"); } if (aliasTarget == null) { throw new ArgumentException("[ERROR] - aliasTarget is null"); } AliasBuilder aliasBuilder = new AliasBuilderImpl(); aliasBuilder.create(moduleIdentifier, aliasTarget); return(aliasBuilder); }
public Task ReleaseRemovedAsync(ModuleIdentifier module, ModuleVersion version, IDependencyResolver dependencyResolver, // TODO: This should be injected via DI CancellationToken cancellation = default) { if (module == default) { throw new ArgumentDefaultException(nameof(module)); } // TODO: Is this ok? if (!ResolvedModules.ContainsModule(module)) { return(Task.CompletedTask); } return(ResolveDependenciesAsync(dependencyResolver, cancellation)); }