public bool NeedsUpgrade(string applicationName)
{
IVersionProvider provider = versionProviderFactory.Get(applicationName);
if (provider == null)
{
log.LogInformation("IVersionProvider not found for " + applicationName);
return(true);
}
Version codeVersion = provider.GetCodeVersion();
Guid appId = db.GetOrGenerateSchemaApplicationId(applicationName);
Version schemaVersion = db.GetSchemaVersion(appId);
bool result = false;
if (codeVersion > schemaVersion)
{
//log.LogInformation(applicationName + " needs upgrade");
result = true;
}
return(result);
}
private async Task <IHost> CreateHost(Action <BlitzOptions> configureBlitz,
ICronjobApiClient apiClient,
IVersionProvider versionProvider = null,
Assembly assembly = null)
{
var host = new HostBuilder()
.ConfigureWebHost(builder =>
{
builder.UseTestServer()
.ConfigureServices(services
=>
{
services
.AddCronjobs(options =>
{
options.RoutePattern = "cronjobs";
options.WebhookBaseUrl = "https://example.com";
},
assembly ?? Assembly.GetExecutingAssembly()
)
.UseBlitz(configureBlitz);
services.AddSingleton <ICronjobApiClient>(apiClient);
services.AddTransient <ICronjobProvider, FakeCronjobProvider>();
services.AddTransient <IVersionProvider>(provider => versionProvider ?? new StubVersionProvider());
services.AddTransient <SimpleCronjob>();
services.AddRouting();
})
.Configure(app
=> app.UseRouting().UseEndpoints(routeBuilder => { routeBuilder.MapCronjobWebhook(); }));
}).Build();
await host.StartAsync();
return(host);
}
public ErrorViewModel(IGreenshotLanguage greenshotLanguage,
[Import(AllowDefault = true)]
IVersionProvider versionProvider)
{
GreenshotLanguage = greenshotLanguage;
VersionProvider = versionProvider;
}
private PakFile(string fileName, long size, Stream sourceStream, IVersionProvider?versionProvider = null, AesPakCryptoProvider?aesProvider = null)
{
FileName = fileName;
SourceStream = sourceStream;
_aesProvider = aesProvider;
_versionProvider = versionProvider ?? AutomaticVersionProvider.Instance;
}
public HealthCheckService(IHealthNetConfiguration healthNetConfiguration, IVersionProvider versionProvider,
IEnumerable <ISystemChecker> systemStateCheckers)
{
this.healthNetConfiguration = healthNetConfiguration;
this.versionProvider = versionProvider;
this.systemStateCheckers = systemStateCheckers;
}
public DbUpdater(ILogger <DbUpdater> logger, SqliteConnectionFactory cnxFactory, IVersionProvider versionProvider)
{
_logger = logger;
_dbConnectionFactory = cnxFactory;
_versionProvider = versionProvider;
_resourcesAssembly = typeof(DbUpdater).Assembly;
}
public DependencyResolver(IHealthNetConfiguration configuration,
IVersionProvider versionProvider, IEnumerable <ISystemChecker> checkers)
{
this.configuration = configuration;
this.versionProvider = versionProvider;
this.checkers = checkers;
}
public MainViewModel(IEventBus eventBus, IVersionProvider versionProvider, IProjectService projectService,
INewProjectDialogViewModelFactory newProjectDialogViewModelFactory, IEnumerable <Tool> tools, ICompositeDocumentFactory compositeDocumentFactory)
{
_versionProvider = versionProvider;
_projectService = projectService;
_newProjectDialogViewModelFactory = newProjectDialogViewModelFactory;
_compositeDocumentFactory = compositeDocumentFactory;
foreach (var tool in tools)
{
ToolsViewModels.Add(tool.CreateViewModel());
}
_currentProjectName = CreateProperty <string>(nameof(CurrentProjectName));
_applicationTitle = CreateComputedProperty(nameof(ApplicationTitle), _currentProjectName, currentProjectName =>
{
var prefix = string.IsNullOrEmpty(currentProjectName) ? string.Empty : $"{CurrentProjectName} - ";
return($"{prefix}Geisha Editor {ApplicationVersion}");
});
NewProjectCommand = RelayCommand.Create(NewProject);
OpenProjectCommand = RelayCommand.Create(OpenProject);
_closeProjectCommand = RelayCommand.Create(CloseProject, CanCloseProject);
SaveCommand = RelayCommand.Create(Save);
ExitCommand = RelayCommand.Create(Exit);
_projectService.CurrentProjectChanged += ProjectServiceOnCurrentProjectChanged;
eventBus.RegisterEventHandler <OpenFileEditorRequestedEvent>(OpenFileEditorRequestedEventHandler);
}
public NotifyIconViewModel(
[NotNull] ILogger logger,
[NotNull] ISettingsManager manager,
[NotNull] Func <IDeskProvider> providerFactory,
[NotNull] IScheduler scheduler,
[NotNull] IErrorManager errorManager,
[NotNull] IVersionProvider versionProvider,
[NotNull] Func <Application, ITaskbarIconProvider> factory)
{
Guard.ArgumentNotNull(logger,
nameof(logger));
Guard.ArgumentNotNull(manager,
nameof(manager));
Guard.ArgumentNotNull(providerFactory,
nameof(providerFactory));
Guard.ArgumentNotNull(scheduler,
nameof(scheduler));
Guard.ArgumentNotNull(errorManager,
nameof(errorManager));
Guard.ArgumentNotNull(versionProvider,
nameof(versionProvider));
Guard.ArgumentNotNull(factory,
nameof(factory));
_scheduler = scheduler;
_manager = manager;
_providerFactory = providerFactory;
_scheduler = scheduler;
_errorManager = errorManager;
_versionProvider = versionProvider;
_iconProvider = factory(null);
}
public Program(string programDescription, string commandLineExample, string programAuthors, string programName,
IVersionProvider versionProvider = null) : base(programDescription, commandLineExample, programAuthors,
programName, versionProvider = null)
{
_options = new GeminiApplicationOptions();
_appOptionParser = new GeminiApplicationOptionsParser();
}
public Guid GetOrGenerateSchemaApplicationId(string applicationName)
{
IVersionProvider versionProvider = versionProviders.Get(applicationName);
if (versionProvider != null)
{
return(versionProvider.ApplicationId);
}
Guid appID = Guid.NewGuid();
try
{
using (DbDataReader reader = GetSchemaId(applicationName))
{
if (reader.Read())
{
appID = new Guid(reader["ApplicationID"].ToString());
}
}
}
catch (Exception ex)
{
log.LogError("error", ex);
}
return(appID);
}
internal AmdConfiguration(
IAmdConfigurationSection configSection,
IVersionProvider defaultVersionProvider)
{
if (configSection == null)
{
this.Shims = new Dictionary<string, IShim>();
this.Bundles = new Dictionary<string, IEnumerable<string>>();
}
else
{
this.LoaderUrl = configSection.LoaderUrl;
this.ModuleRootUrl = configSection.RootModuleUrl;
this.ScriptLoadingMode = configSection.ScriptLoadingMode;
this.Shims = configSection.Shims.ToDictionary(s => s.Id);
this.Bundles = configSection.Bundles.ToDictionary(b => b.Id, b => b.Modules);
if (configSection.Minifier != null)
{
this.Minifier = Activator.CreateInstance(configSection.Minifier) as IScriptMinifier;
}
}
this.VersionProvider = configSection.IfExists(c => c.VersionProvider) == null
? defaultVersionProvider
: Activator.CreateInstance(configSection.VersionProvider) as IVersionProvider;
}
public GameUpdater(IRestClient restClient, string basePath, IVersionProvider versionProvider)
{
this._restClient = restClient;
this._basePath = basePath;
_versionProvider = versionProvider;
this.SetupCurrentCulture();
}
public static void Setup(ILoggerFactory loggerFactory)
{
if (Current == null)
{
Current = new DefaultVersionProvider(loggerFactory);
}
}
public CreateBusinessUnitCommandHandler(IBusinessUnitWriteRepository businessUnitWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_businessUnitWriteRepository = businessUnitWriteRepository ?? throw Error.ArgumentNull(nameof(businessUnitWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
/// <summary>
/// Instantiates a new instance of the <see cref="SimpleMigrator"/> class
/// </summary>
/// <param name="migrationAssembly">Assembly to search for migrations</param>
/// <param name="connection">Connection to use to communicate with the database</param>
/// <param name="versionProvider"><see cref="IVersionProvider{TDatabase}"/> implementation to use</param>
/// <param name="logger">Logger to use to log progress</param>
public SimpleMigrator(
Assembly migrationAssembly,
IDbConnection connection,
IVersionProvider <IDbConnection> versionProvider,
ILogger logger = null)
: base(migrationAssembly, new ConnectionProvider(connection), versionProvider, logger)
{
}
public CreateRemarkCommandHandler(IRemarkWriteRepository remarkWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_remarkWriteRepository = remarkWriteRepository ?? throw Error.ArgumentNull(nameof(remarkWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public Cache(CacheContainer container, CacheConfiguration cacheConfiguration)
{
_versionProvider = container.Resolve <IVersionProvider>();
_logger = container.Resolve <ILogger>();
_storage = new InMemoryStorageProxy(container.Resolve <IStorage>(), cacheConfiguration.InMemoryOnly);
_cacheData = new CacheData(_storage, container.Resolve <ISerializer>(), cacheConfiguration, _logger);
_timer = new Timer(SaveMappingsAndCheckLimits, null, cacheConfiguration.PeriodicOperationsDueTime, cacheConfiguration.PeriodicOperationsPeriodTime);
}
public CreateFlowCommandHandler(IFlowWriteRepository flowWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_flowWriteRepository = flowWriteRepository ?? throw Error.ArgumentNull(nameof(flowWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateLayoutCommandHandler(ILayoutWriteRepository layoutWriteRepository,
ILayoutReadRepository layoutReadRepository,
IVersionProvider versionProvider)
{
_layoutWriteRepository = layoutWriteRepository ?? throw Error.ArgumentNull(nameof(layoutWriteRepository));
_layoutReadRepository = layoutReadRepository ?? throw Error.ArgumentNull(nameof(layoutReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
/// <summary>
/// Initializes a new instance of the <see cref="UpdatesMonitor"/> class.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="bootstrapperParameters">The bootstrapper parameters.</param>
/// <param name="versionProvider">The version provider.</param>
public UpdatesMonitor(ILog log, BootstrapperParameters bootstrapperParameters, IVersionProvider versionProvider)
{
path = Path.GetDirectoryName(bootstrapperParameters.BootstrapperFile);
this.log = log;
this.versionProvider = versionProvider;
timer = new Timer(SomeFileWasChangedAfterWait);
}
/// <summary>
/// Initializes a new instance of the <see cref="AgentUpdater"/> class.
/// </summary>
/// <param name="connectionProvider">The connection provider.</param>
/// <param name="versionProvider">The version provider.</param>
/// <param name="updateSource">The update source.</param>
/// <param name="agents">The agents.</param>
/// <param name="log">The log.</param>
public AgentUpdater(IConnectionProvider connectionProvider, IVersionProvider versionProvider, IUpdateSource updateSource, AgentsCollection agents, ILog log)
{
this.connectionProvider = connectionProvider;
this.versionProvider = versionProvider;
this.updateSource = updateSource;
this.agents = agents;
this.log = log;
}
public CreateIconCommandHandler(IIconWriteRepository iconWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_iconWriteRepository = iconWriteRepository ?? throw Error.ArgumentNull(nameof(iconWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateBusinessUnitCommandHandler(IBusinessUnitWriteRepository businessUnitWriteRepository,
IBusinessUnitReadRepository businessUnitReadRepository,
IVersionProvider versionProvider)
{
_businessUnitWriteRepository = businessUnitWriteRepository ?? throw Error.ArgumentNull(nameof(businessUnitWriteRepository));
_businessUnitReadRepository = businessUnitReadRepository ?? throw Error.ArgumentNull(nameof(businessUnitReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateOperationCommandHandler(IOperationWriteRepository operationWriteRepository,
IOperationReadRepository operationReadRepository,
IVersionProvider versionProvider)
{
_operationWriteRepository = operationWriteRepository ?? throw Error.ArgumentNull(nameof(operationWriteRepository));
_operationReadRepository = operationReadRepository ?? throw Error.ArgumentNull(nameof(operationReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateRemarkCommandHandler(IRemarkWriteRepository remarkWriteRepository,
IRemarkReadRepository remarkReadRepository,
IVersionProvider versionProvider)
{
_remarkWriteRepository = remarkWriteRepository ?? throw Error.ArgumentNull(nameof(remarkWriteRepository));
_remarkReadRepository = remarkReadRepository ?? throw Error.ArgumentNull(nameof(remarkReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public CreateLayoutCommandHandler(ILayoutWriteRepository layoutWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_layoutWriteRepository = layoutWriteRepository ?? throw Error.ArgumentNull(nameof(layoutWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateSourceCommandHandler(ISourceWriteRepository sourceWriteRepository,
ISourceReadRepository sourceReadRepository,
IVersionProvider versionProvider)
{
_sourceWriteRepository = sourceWriteRepository ?? throw Error.ArgumentNull(nameof(sourceWriteRepository));
_sourceReadRepository = sourceReadRepository ?? throw Error.ArgumentNull(nameof(sourceReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public ActionResult <VersionInformationDto> GetVersion([FromServices] IVersionProvider versionProvider)
{
return(Ok(new VersionInformationDto()
{
Version = versionProvider.EmpoweredPixelsVersion,
EngineVersion = versionProvider.SharpFightingEngineVersion,
}));
}
public CreateSourceCommandHandler(ISourceWriteRepository sourceWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_sourceWriteRepository = sourceWriteRepository ?? throw Error.ArgumentNull(nameof(sourceWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public CreateTeamCommandHandler(ITeamWriteRepository teamWriteRepository,
IIdentifierProvider identifierProvider,
IVersionProvider versionProvider)
{
_teamWriteRepository = teamWriteRepository ?? throw Error.ArgumentNull(nameof(teamWriteRepository));
_identifierProvider = identifierProvider ?? throw Error.ArgumentNull(nameof(identifierProvider));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateTeamCommandHandler(ITeamWriteRepository teamWriteRepository,
ITeamReadRepository teamReadRepository,
IVersionProvider versionProvider)
{
_teamWriteRepository = teamWriteRepository ?? throw Error.ArgumentNull(nameof(teamWriteRepository));
_teamReadRepository = teamReadRepository ?? throw Error.ArgumentNull(nameof(teamReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateInstructionCommandHandler(IInstructionWriteRepository instructionWriteRepository,
IInstructionReadRepository instructionReadRepository,
IVersionProvider versionProvider)
{
_instructionWriteRepository = instructionWriteRepository ?? throw Error.ArgumentNull(nameof(instructionWriteRepository));
_instructionReadRepository = instructionReadRepository ?? throw Error.ArgumentNull(nameof(instructionReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
public UpdateValidationCommandHandler(IValidationWriteRepository validationWriteRepository,
IValidationReadRepository validationReadRepository,
IVersionProvider versionProvider)
{
_validationWriteRepository = validationWriteRepository ?? throw Error.ArgumentNull(nameof(validationWriteRepository));
_validationReadRepository = validationReadRepository ?? throw Error.ArgumentNull(nameof(validationReadRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountsController" /> class
public AccountsController(IMapper mapper,
INotificationService notificationService,
IVersionProvider currentVersionProvider)
{
this.mapper = mapper;
this.notificationService = notificationService;
this.currentVersionProvider = currentVersionProvider;
}
private Factory()
{
_configuration = null;
_dispachers = new Dictionary<string, IDbDispatcher<DataSharding>>();
_versionProvider = null;
_retries = 0;
_connectionConstructor = null;
}
public void Setup()
{
TestHelpers.CleanupTestFolder();
Mock<RestClient> restclientMock = new Mock<RestClient>();
restclientMock.Setup(x => x.Execute(It.IsAny<IRestRequest>())).Returns(new RestResponse
{
Content = "{ 'version' : 1 }"
});
var restclient = restclientMock.Object;
_versionProvider = new VersionProvider(restclient, TestHelpers.GetTestDataFolder("TestData/Version.json"));
}
public void Setup()
{
TestHelpers.CleanupTestFolder();
TestHelpers.SetupCultureInfo();
this._restClient = new RestClient("https://s3-eu-west-1.amazonaws.com/helbreath-files/updates/");
var restclientMock = new Mock<RestClient>();
restclientMock.Setup(x => x.Execute(It.IsAny<IRestRequest>())).Returns(new RestResponse
{
Content = "{ 'version' : 0.4 }"
});
this._versionProvider = new VersionProvider(restclientMock.Object, TestHelpers.GetTestDataFolder("TestData/Version.json"));
this._gameUpdater = new GameUpdater(_restClient, TestHelpers.GetTestDataFolder("TestData"), this._versionProvider);
}
public SiteTemplateActionDecorator(IAction decoratedAction, IVelocityViewGenerator velocityViewGenerator,
ObjectSource objectSource, IVersionProvider versionProvider,
IFingerprintFactory fingerprintFactory, IUrlBuilder urlBuilder,
IPluginConfiguration configuration, ICruiseRequest cruiseRequest)
{
this.decoratedAction = decoratedAction;
this.velocityViewGenerator = velocityViewGenerator;
this.objectSource = objectSource;
this.versionProvider = versionProvider;
this.fingerprintFactory = fingerprintFactory;
this.urlBuilder = urlBuilder;
this.configuration = configuration;
this.cruiseRequest = cruiseRequest;
}
/// <summary>
/// Initializes a new instance of the <see cref="Server"/> class.
/// </summary>
/// <param name="updateSource">The update source.</param>
/// <param name="versionProvider">The version provider.</param>
/// <param name="runner">The manager.</param>
/// <param name="requests">The storage.</param>
/// <param name="resultsStorage">The results.</param>
/// <param name="log">The log.</param>
/// <param name="projects">The projects.</param>
public Server(
IUpdateSource updateSource,
IVersionProvider versionProvider,
ServerTestRunner runner,
IRequestsStorage requests,
IResultsStorage resultsStorage,
ILog log,
IProjectsStorage projects)
{
this.updateSource = updateSource;
this.versionProvider = versionProvider;
this.runner = runner;
this.requests = requests;
this.resultsStorage = resultsStorage;
this.log = log;
this.projects = projects;
}
public MainWindow()
{
InitializeComponent();
WebBrowser.Navigate(new Uri("http://helbreathpoland.com"));
this._storageRestClient = new RestClient("https://s3-eu-west-1.amazonaws.com/helbreath-files/updates/");
this._versionRestClient = new RestClient("http://version.helbreathpoland.com/");
this._basePath = Path.Combine(Directory.GetCurrentDirectory(), "Version.json");
this._versionProvider = new VersionProvider(this._versionRestClient, this._basePath);
this._gameUpdater = new GameUpdater(this._storageRestClient, Directory.GetCurrentDirectory(),
this._versionProvider);
var currentCulture = (System.Globalization.CultureInfo)CultureInfo.CurrentCulture.Clone();
currentCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = currentCulture;
this.Main();
}
/// <summary>
/// Initializes a new instance of the <see cref="Client"/> class.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="updateReceiver">The update receiver.</param>
/// <param name="connectionProvider">The connection provider.</param>
/// <param name="versionProvider">The version provider.</param>
/// <param name="parametersReader">The file reader.</param>
/// <param name="packager">The packager.</param>
/// <param name="resultsProcessor">The results processor.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="log">The log.</param>
public Client(ClientParameters options,
IUpdateReceiver updateReceiver,
IConnectionProvider connectionProvider,
IVersionProvider versionProvider,
ITestRunParametersFileReader parametersReader,
IProjectPackager packager,
TestResultsProcessor resultsProcessor,
ITestResultsSerializer serializer,
ILog log)
{
this.options = options;
this.updateReceiver = updateReceiver;
this.connectionProvider = connectionProvider;
this.versionProvider = versionProvider;
this.parametersReader = parametersReader;
this.packager = packager;
this.resultsProcessor = resultsProcessor;
this.serializer = serializer;
this.log = log;
}
public void GetVersionFromInternet_Then_Deserialize_Version_Return_GameVersion()
{
//arrange
Mock<RestClient> restclientMock = new Mock<RestClient>();
var expectedGameVersion = new GameVersion
{
Version = 0.5
};
var jsonToReturn = JsonConvert.SerializeObject(expectedGameVersion);
restclientMock.Setup(x => x.Execute(It.IsAny<IRestRequest>())).Returns(new RestResponse
{
Content = jsonToReturn
});
var restclient = restclientMock.Object;
_versionProvider = new VersionProvider(restclient, TestHelpers.GetTestDataFolder("TestData/Version.json"));
//act
var result = _versionProvider.GetVersionFromInternet();
//assert
Assert.AreEqual(expectedGameVersion.Version, result.Version);
}
string GetVersionString() {
var versionProviders = new IVersionProvider[] {
jitMethodsDecrypter,
memoryMethodsDecrypter,
proxyCallFixer,
antiDebugger,
antiDumping,
resourceDecrypter,
constantsDecrypterV18,
constantsDecrypterV17,
constantsDecrypterV15,
stringDecrypter,
unpacker,
};
var vd = new VersionDetector();
foreach (var versionProvider in versionProviders) {
if (versionProvider == null)
continue;
int minRev, maxRev;
if (versionProvider.GetRevisionRange(out minRev, out maxRev)) {
if (maxRev == int.MaxValue)
Logger.v("r{0}-latest : {1}", minRev, versionProvider.GetType().Name);
else
Logger.v("r{0}-r{1} : {2}", minRev, maxRev, versionProvider.GetType().Name);
vd.AddRevs(minRev, maxRev);
}
}
if (useAttributeVersion)
vd.SetVersion(approxVersion);
return vd.GetVersionString();
}
public VersionController(IVersionProvider versionProvider, IResemblerUsageService usageService)
{
_versionProvider = versionProvider;
_usageService = usageService;
}
public ActiveUpdater(IVersionProvider currentVersionProvider, IVersionProvider serverVersionProvider, IUpdateResolver updateResolver)
{
_currentVersionProvider = currentVersionProvider;
_serverVersionProvider = serverVersionProvider;
_updateResolver = updateResolver;
}
public FingerprintFactory(IVersionProvider versionProvider, IPhysicalApplicationPathProvider pathProvider)
{
this.versionProvider = versionProvider;
this.pathProvider = pathProvider;
}
public VersionModule(IVersionProvider versionProvider)
{
Get["/version"] = _ => versionProvider.GetVersion();
}
public HealthCheckService(IHealthNetConfiguration healthNetConfiguration, IVersionProvider versionProvider, IEnumerable<ISystemChecker> systemStateCheckers)
{
this.healthNetConfiguration = healthNetConfiguration;
this.versionProvider = versionProvider;
this.systemStateCheckers = systemStateCheckers;
}
public VersionAwareModule(IVersionProvider sVersionProvider)
{
Items.Add(new InterfaceMapModule<IVersionAware,VersionAwareInterfaceMap>());
Items.Add(new EventHandlerModule(new VersionAwareEventListener(sVersionProvider)));
}
public static void AddVersion(IVersionProvider provider)
{
VersionProviders.Add(provider.DisplayName, provider);
}
