public void Setup()
{
logger = MockRepository.GenerateMock<ILogger>();
exec = MockRepository.GenerateMock<IExecutableProcessQueue>();
installer = new Installer(exec, logger);
}
public WorkloadRepairCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string tempDirPath = null,
string version = null,
string userProfileDir = null)
: base(parseResult, reporter: reporter, nugetPackageDownloader: nugetPackageDownloader)
{
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
userProfileDir ??= CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadRepairCommandParser.VersionOption), version, _dotnetPath, userProfileDir);
var configOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.ConfigOption);
var sourceOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), userProfileDir);
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = workloadInstaller ??
WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand,
_workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetDir, TempDirectoryPath,
_packageSourceLocation, _parseResult.ToRestoreActionConfig());
}
private static bool InstallOrUninstallWithElevationContext(IEnumerable <ComponentHandle <IInstaller, InstallerTraits> > installerHandles,
IElevationContext elevationContext, IProgressMonitor progressMonitor,
InstallerOperation operation)
{
foreach (var installerHandle in installerHandles)
{
if (progressMonitor.IsCanceled)
{
return(false);
}
IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1);
if (elevationContext != null && installerHandle.GetTraits().RequiresElevation)
{
elevationContext.Execute(InstallerElevatedCommand.ElevatedCommandId,
new InstallerElevatedCommand.Arguments(installerHandle.Id, operation),
subProgressMonitor);
}
else
{
IInstaller installer = installerHandle.GetComponent();
if (operation == InstallerOperation.Install)
{
installer.Install(progressMonitor.CreateSubProgressMonitor(1));
}
else
{
installer.Uninstall(progressMonitor.CreateSubProgressMonitor(1));
}
}
}
return(true);
}
public BuildFOMODsStep(IInstaller installer, ILog log, IPrompts prompts)
{
Log = log;
_installer = installer;
_prompts = prompts;
_fomod = DependencyRegistry.Container.GetInstance <FOMOD>();
}
private NuGetManagedTemplatePackage(
IEngineEnvironmentSettings settings,
IInstaller installer,
IManagedTemplatePackageProvider provider,
string mountPointUri,
IReadOnlyDictionary <string, string> details)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
MountPointUri = mountPointUri;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
Details = details?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value) ?? throw new ArgumentNullException(nameof(details));
if (Details.TryGetValue(PackageIdKey, out string packageId))
{
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentException($"{nameof(details)} should contain key {PackageIdKey} with non-empty value", nameof(details));
}
}
else
{
throw new ArgumentException($"{nameof(details)} should contain key {PackageIdKey}", nameof(details));
}
_logger = settings.Host.LoggerFactory.CreateLogger <NuGetInstaller>();
}
public WorkloadUninstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string version = null)
: base(parseResult)
{
_reporter = reporter ?? Reporter.Output;
_workloadIds = parseResult.ValueForArgument <IEnumerable <string> >(WorkloadUninstallCommandParser.WorkloadIdArgument)
.Select(workloadId => new WorkloadId(workloadId)).ToList().AsReadOnly();
_sdkVersion = string.IsNullOrEmpty(parseResult.ValueForOption <string>(WorkloadUninstallCommandParser.VersionOption)) ?
new ReleaseVersion(version ?? Product.Version) :
new ReleaseVersion(parseResult.ValueForOption <string>(WorkloadUninstallCommandParser.VersionOption));
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
var verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadUninstallCommandParser.VerbosityOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString());
workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString());
nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(new DirectoryPath(Path.GetTempPath()), filePermissionSetter: null, new NullLogger());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand, workloadResolver, verbosity, nugetPackageDownloader, dotnetPath);
}
private void test_installertype(IInstaller installer, bool hasQuietUninstallString)
{
reset();
registryKeys.Add(
new RegistryApplicationKey
{
InstallLocation = @"C:\Program Files (x86)\WinDirStat",
UninstallString = "{0} {1}".format_with(originalUninstallString, registryUninstallArgs),
HasQuietUninstall = hasQuietUninstallString,
KeyPath = @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinDirStat",
InstallerType = installer.InstallerType,
});
packageInformation.RegistrySnapshot = new Registry("123", registryKeys);
fileSystem.Setup(x => x.combine_paths(config.CacheLocation, "chocolatey", It.IsAny <string>(), It.IsAny <string>())).Returns(logLocation);
because();
var installerTypeArgs = installer.build_uninstall_command_arguments().trim_safe().Replace(InstallTokens.PACKAGE_LOCATION, logLocation);
var uninstallArgs = !hasQuietUninstallString?registryUninstallArgs.trim_safe() + " " + installerTypeArgs : registryUninstallArgs.trim_safe();
commandExecutor.Verify(
c =>
c.execute(
expectedUninstallString,
uninstallArgs.trim_safe(),
It.IsAny <int>(),
It.IsAny <Action <object, DataReceivedEventArgs> >(),
It.IsAny <Action <object, DataReceivedEventArgs> >(),
It.IsAny <bool>()),
Times.Once);
}
public Launcher()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
var container = new Container();
container.Register <Logger>(Lifestyle.Singleton);
container.Register <FileService>(Lifestyle.Singleton);
container.Register <AccessProvider>(Lifestyle.Singleton);
container.Register <SettingsProvider>(Lifestyle.Singleton);
container.Register <DownloadProvider>(Lifestyle.Singleton);
container.Register <InstallProvider>(Lifestyle.Singleton);
container.Register <Installer>();
container.Register <Downloader>();
_logger = container.GetInstance <Logger>();
_installProvider = container.GetInstance <InstallProvider>();
_settingsProvider = container.GetInstance <SettingsProvider>();
_installer = container.GetInstance <Installer>();
_downloader = container.GetInstance <Downloader>();
}
public WorkloadUpdateCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userHome = null,
string version = null)
: base(parseResult)
{
_printDownloadLinkOnly =
parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.FromCacheOption);
_reporter = reporter ?? Reporter.Output;
_includePreviews = parseResult.ValueForOption <bool>(WorkloadUpdateCommandParser.IncludePreviewsOption);
_verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadUpdateCommandParser.VerbosityOption);
_sdkVersion = new ReleaseVersion(version ??
(string.IsNullOrWhiteSpace(parseResult.ValueForOption <string>(WorkloadUpdateCommandParser.SdkVersionOption)) ?
Product.Version : parseResult.ValueForOption <string>(WorkloadUpdateCommandParser.SdkVersionOption)));
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString());
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(_workloadManifestProvider, dotnetPath, _sdkVersion.ToString());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = workloadInstaller ?? WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand, _workloadResolver, _verbosity, nugetPackageDownloader, dotnetDir);
userHome = userHome ?? CliFolderPathCalculator.DotnetHomePath;
var tempPackagesDir = new DirectoryPath(Path.Combine(userHome, ".dotnet", "sdk-advertising-temp"));
_nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(tempPackagesDir, filePermissionSetter: null, new NullLogger());
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadManifestProvider, _nugetPackageDownloader, userHome);
}
public WorkloadUninstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string version = null,
string userProfileDir = null)
: base(parseResult, reporter: reporter, nugetPackageDownloader: nugetPackageDownloader)
{
_workloadIds = parseResult.GetValueForArgument(WorkloadUninstallCommandParser.WorkloadIdArgument)
.Select(workloadId => new WorkloadId(workloadId)).ToList().AsReadOnly();
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadUninstallCommandParser.VersionOption), version, dotnetPath, userProfileDir);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString(), userProfileDir);
workloadResolver ??= WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString(), userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand, workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetPath);
}
public void Setup()
{
logger = MockRepository.GenerateMock <ILogger>();
exec = MockRepository.GenerateMock <IExecutableProcessQueue>();
installer = new Installer(exec, logger);
}
public Form1(
IModState modState,
IModListInit modListInit,
ICheckBoxes checkBoxes,
IActionToTake actionToTake,
IInstaller installer,
IUninstall uninstall,
IProgressBarSteps progressBarSteps,
IVersion version,
ICheckExe checkExe,
IConverter converter,
IDataStorage dataStorage,
IDownloader downloader)
{
InitializeComponent();
_modState = modState;
_modListInit = modListInit;
_checkBoxes = checkBoxes;
_actionToTake = actionToTake;
_installer = installer;
_uninstall = uninstall;
_progressBarSteps = progressBarSteps;
_version = version;
_checkExe = checkExe;
_converter = converter;
_dataStorage = dataStorage;
_downloader = downloader;
OnInit();
}
public BuildFOMODsStep(IInstaller installer, ILog log, IPrompts prompts)
{
Log = log;
_installer = installer;
_prompts = prompts;
_fomod = DependencyRegistry.Container.GetInstance<FOMOD>();
}
public SolutionService(
IMessage message,
IInstaller installer)
{
this.message = message;
this.installer = installer;
}
// This method is used for cases where you need to create the SceneCompositionRoot entirely in code
// Necessary because the Awake() method is called immediately after AddComponent<SceneCompositionRoot>
// so there's no other way to add installers to it
public static SceneCompositionRoot AddComponent(
GameObject gameObject, IInstaller rootInstaller)
{
return(AddComponent(gameObject, new List <IInstaller>()
{
rootInstaller
}));
}
private static void FirstRun(IEngineEnvironmentSettings environmentSettings, IInstaller installer)
{
var packages = new List <string> {
"VitalElement.AvalonStudio.Templates"
};
installer.InstallPackages(packages);
}
public void ThrowArgumentNullException_WhenPassedInstallerIsNull()
{
// Arrange
IInstaller <IPackage> invalidInstaller = null;
var packageMock = new Mock <IPackage>();
// Act and Assert
Assert.Throws <ArgumentNullException>(() => new FakeInstallCommand(invalidInstaller, packageMock.Object));
}
/// <summary>
/// Runs an installer, adding the installer's handlers to the disclose.
/// </summary>
/// <param name="installer"></param>
public void Install(IInstaller installer)
{
if (installer == null)
{
throw new ArgumentNullException(nameof(installer));
}
installer.Install(this);
}
public WorkloadInstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userHome = null,
string tempDirPath = null,
string version = null,
IReadOnlyCollection <string> workloadIds = null)
: base(parseResult)
{
_reporter = reporter ?? Reporter.Output;
_skipManifestUpdate = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.SkipManifestUpdateOption);
_includePreviews = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.IncludePreviewOption);
_printDownloadLinkOnly = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.FromCacheOption);
_downloadToCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.DownloadToCacheOption);
_workloadIds = workloadIds ?? parseResult.ValueForArgument <IEnumerable <string> >(WorkloadInstallCommandParser.WorkloadIdArgument).ToList().AsReadOnly();
_verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadInstallCommandParser.VerbosityOption);
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.ValueForOption <string>(WorkloadInstallCommandParser.VersionOption), version, _dotnetPath);
_sdkFeatureBand = new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
_tempDirPath = tempDirPath ?? (string.IsNullOrWhiteSpace(parseResult.ValueForOption <string>(WorkloadInstallCommandParser.TempDirOption)) ?
Path.GetTempPath() :
parseResult.ValueForOption <string>(WorkloadInstallCommandParser.TempDirOption));
var configOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.ConfigOption);
var sourceOption = parseResult.ValueForOption <string[]>(WorkloadInstallCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString());
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(sdkWorkloadManifestProvider, _dotnetPath, _sdkVersion.ToString());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
var tempPackagesDir = new DirectoryPath(Path.Combine(_tempDirPath, "dotnet-sdk-advertising-temp"));
var restoreActionConfig = _parseResult.ToRestoreActionConfig();
_nugetPackageDownloader = nugetPackageDownloader ??
new NuGetPackageDownloader(tempPackagesDir,
filePermissionSetter: null,
new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, _verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger()),
_verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger(), restoreActionConfig: restoreActionConfig);
_workloadInstaller = workloadInstaller ??
WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand,
_workloadResolver, _verbosity, _nugetPackageDownloader, _dotnetPath, _tempDirPath,
_packageSourceLocation, restoreActionConfig, elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
_userHome = userHome ?? CliFolderPathCalculator.DotnetHomePath;
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadResolver, _nugetPackageDownloader, _userHome, _tempDirPath,
_workloadInstaller.GetWorkloadInstallationRecordRepository(), _packageSourceLocation);
ValidateWorkloadIdsInput();
}
/// <summary>
/// Creates a new instance and performs some initialization tasks.
/// </summary>
public UninstallViewModel()
{
this.Title = _loc.GetLocalizationValue("TitleUninstall");
this.UninstallButtonText = _loc.GetLocalizationValue("BtnUninstall");
// Create a platform-specific installer instance
_installer = Activator.CreateInstance(
Implementation.ForType <IInstaller>()) as IInstaller;
}
public async Task <IReadOnlyList <InstallResult> > InstallAsync(IEnumerable <InstallRequest> installRequests, CancellationToken cancellationToken)
{
_ = installRequests ?? throw new ArgumentNullException(nameof(installRequests));
if (!installRequests.Any())
{
return(new List <InstallResult>());
}
//validate that install requests are different - install requests should have unique identifier for given installer
HashSet <InstallRequest> uniqueInstallRequests = new HashSet <InstallRequest>(new InstallRequestEqualityComparer());
foreach (InstallRequest installRequest in installRequests)
{
if (uniqueInstallRequests.Add(installRequest))
{
continue;
}
throw new ArgumentException($"{nameof(installRequests)} has duplicate install requests", nameof(installRequest));
}
using var disposable = await _globalSettings.LockAsync(cancellationToken).ConfigureAwait(false);
var packages = new List <TemplatePackageData>(await _globalSettings.GetInstalledTemplatePackagesAsync(cancellationToken).ConfigureAwait(false));
var results = await Task.WhenAll(installRequests.Select(async installRequest =>
{
var installersThatCanInstall = new List <IInstaller>();
foreach (var install in _installersByName.Values)
{
if (await install.CanInstallAsync(installRequest, cancellationToken).ConfigureAwait(false))
{
installersThatCanInstall.Add(install);
}
}
if (installersThatCanInstall.Count == 0)
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.UnsupportedRequest,
string.Format(LocalizableStrings.GlobalSettingsTemplatePackageProvider_InstallResult_Error_PackageCannotBeInstalled, installRequest.PackageIdentifier)));
}
if (installersThatCanInstall.Count > 1)
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.UnsupportedRequest,
string.Format(LocalizableStrings.GlobalSettingsTemplatePackageProvider_InstallResult_Error_MultipleInstallersCanBeUsed, installRequest.PackageIdentifier)));
}
IInstaller installer = installersThatCanInstall[0];
return(await InstallAsync(packages, installRequest, installer, cancellationToken).ConfigureAwait(false));
})).ConfigureAwait(false);
await _globalSettings.SetInstalledTemplatePackagesAsync(packages, cancellationToken).ConfigureAwait(false);
return(results);
}
public static IInstaller GetInstaller(string file)
{
IInstaller r = null;
if (file.EndsWith("msi"))
{
r = new MSIInstaller(file);
}
return(r);
}
public void Install(IInstaller installer)
{
if (_installedInstallers.Where(x => x.GetType() == installer.GetType()).IsEmpty())
// Do not install the same installer twice
{
_installedInstallers.Add(installer);
this.Inject(installer);
installer.InstallBindings();
}
}
public void ApplyUpdates(IInstaller installer, IReadOnlyList <IUpdateUnitDescriptor> updatesToApply)
{
// TODO: revisit whether this should happen, or something else.
if (updatesToApply.Any(x => x.InstallUnitDescriptor.FactoryId != DescriptorFactoryId))
{
throw new Exception("Incorrect descriptor type");
}
installer.InstallPackages(updatesToApply.Select(x => x.InstallString));
}
private static void FirstRun(ITemplateEngineHost host, IInstaller installer)
{
var templatesDir = Path.Combine(Paths.Global.BaseDir, "Templates");
if (templatesDir.Exists())
{
var layoutIncludedPackages = host.FileSystem.EnumerateFiles(templatesDir, "*.nupkg", SearchOption.TopDirectoryOnly);
installer.InstallPackages(layoutIncludedPackages);
}
}
private static void FirstRun(IEngineEnvironmentSettings environmentSettings, IInstaller installer)
{
var templateFolders = GetTemplateFolders(environmentSettings);
foreach (var templateFolder in templateFolders)
{
var layoutIncludedPackages = environmentSettings.Host.FileSystem.EnumerateFiles(templateFolder, "*.nupkg", SearchOption.TopDirectoryOnly);
installer.InstallPackages(layoutIncludedPackages);
}
}
public WorkloadUpdateCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userProfileDir = null,
string tempDirPath = null,
string version = null)
: base(parseResult)
{
_printDownloadLinkOnly =
parseResult.GetValueForOption(WorkloadUpdateCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromCacheOption);
_reporter = reporter ?? Reporter.Output;
_includePreviews = parseResult.GetValueForOption(WorkloadUpdateCommandParser.IncludePreviewsOption);
_fromPreviousSdk = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromPreviousSdkOption);
_adManifestOnlyOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.AdManifestOnlyOption);
_downloadToCacheOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.DownloadToCacheOption);
_verbosity = parseResult.GetValueForOption(WorkloadUpdateCommandParser.VerbosityOption);
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadUpdateCommandParser.VersionOption), version, _dotnetPath, _userProfileDir);
_tempDirPath = tempDirPath ?? (string.IsNullOrWhiteSpace(parseResult.GetValueForOption(WorkloadUpdateCommandParser.TempDirOption)) ?
Path.GetTempPath() :
parseResult.GetValueForOption(WorkloadUpdateCommandParser.TempDirOption));
_printRollbackDefinitionOnly = parseResult.GetValueForOption(WorkloadUpdateCommandParser.PrintRollbackOption);
_fromRollbackDefinition = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromRollbackFileOption);
var configOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.ConfigOption);
var sourceOption = parseResult.GetValueForOption <string[]>(WorkloadUpdateCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), _userProfileDir);
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), _userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
var restoreActionConfig = _parseResult.ToRestoreActionConfig();
_workloadInstaller = workloadInstaller ?? WorkloadInstallerFactory.GetWorkloadInstaller(_reporter,
sdkFeatureBand, _workloadResolver, _verbosity, _userProfileDir, nugetPackageDownloader,
dotnetDir, _tempDirPath, packageSourceLocation: _packageSourceLocation, restoreActionConfig,
elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
var tempPackagesDir = new DirectoryPath(Path.Combine(_tempDirPath, "dotnet-sdk-advertising-temp"));
_nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(tempPackagesDir,
filePermissionSetter: null, new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, _verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger()),
_verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger(), restoreActionConfig: restoreActionConfig);
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadResolver, _nugetPackageDownloader, _userProfileDir, _tempDirPath,
_workloadInstaller.GetWorkloadInstallationRecordRepository(), _packageSourceLocation);
}
// ----- Constructor
public Application(
IInstaller installer,
IModuleManager moduleManager,
IRemoteServerConnector remoteServerConnector,
IEnvironment environment)
{
_installer = installer;
_moduleManager = moduleManager;
_remoteServerConnector = remoteServerConnector;
_environment = environment;
}
// ----- Constructor
public Application(
IInstaller installer,
IModuleManager moduleManager,
IRemoteServerConnector remoteServerConnector,
IEnvironment environment)
{
_installer = installer;
_moduleManager = moduleManager;
_remoteServerConnector = remoteServerConnector;
_environment = environment;
}
public FolderManagedTemplatePackage(IEngineEnvironmentSettings settings, IInstaller installer, IManagedTemplatePackageProvider provider, string mountPointUri)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
MountPointUri = mountPointUri;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
private static void FirstRun(IEngineEnvironmentSettings environmentSettings, IInstaller installer)
{
Paths paths = new Paths(environmentSettings);
var templatesDir = Path.Combine(paths.Global.BaseDir, "Templates");
if (paths.Exists(templatesDir))
{
var layoutIncludedPackages = environmentSettings.Host.FileSystem.EnumerateFiles(templatesDir, "*.nupkg", SearchOption.TopDirectoryOnly);
installer.InstallPackages(layoutIncludedPackages);
}
}
public static void EnqueueExtra(IInstaller installer, string key = "")
{
ExtraInstallers.AddOrUpdate(key,
new ExtraInstaller {
installer
},
(_, binding) =>
{
binding.Add(installer);
return(binding);
});
}
public WorkloadInstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userProfileDir = null,
string tempDirPath = null,
string version = null,
IReadOnlyCollection <string> workloadIds = null)
: base(parseResult, reporter: reporter, tempDirPath: tempDirPath, nugetPackageDownloader: nugetPackageDownloader)
{
_skipManifestUpdate = parseResult.GetValueForOption(WorkloadInstallCommandParser.SkipManifestUpdateOption);
_includePreviews = parseResult.GetValueForOption(WorkloadInstallCommandParser.IncludePreviewOption);
_printDownloadLinkOnly = parseResult.GetValueForOption(WorkloadInstallCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.GetValueForOption(WorkloadInstallCommandParser.FromCacheOption);
_downloadToCacheOption = parseResult.GetValueForOption(WorkloadInstallCommandParser.DownloadToCacheOption);
_workloadIds = workloadIds ?? parseResult.GetValueForArgument(WorkloadInstallCommandParser.WorkloadIdArgument).ToList().AsReadOnly();
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadInstallCommandParser.VersionOption), version, _dotnetPath, _userProfileDir);
_sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_fromRollbackDefinition = parseResult.GetValueForOption(WorkloadInstallCommandParser.FromRollbackFileOption);
var configOption = parseResult.GetValueForOption(WorkloadInstallCommandParser.ConfigOption);
var sourceOption = parseResult.GetValueForOption(WorkloadInstallCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), userProfileDir);
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(sdkWorkloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), _userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
var tempPackagesDir = new DirectoryPath(Path.Combine(TempDirectoryPath, "dotnet-sdk-advertising-temp"));
_workloadInstaller = workloadInstaller ??
WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand,
_workloadResolver, Verbosity, _userProfileDir, VerifySignatures, PackageDownloader, _dotnetPath, TempDirectoryPath,
_packageSourceLocation, RestoreActionConfiguration, elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
bool displayManifestUpdates = false;
if (Verbosity.VerbosityIsDetailedOrDiagnostic())
{
displayManifestUpdates = true;
}
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(Reporter, _workloadResolver, PackageDownloader, _userProfileDir, TempDirectoryPath,
_workloadInstaller.GetWorkloadInstallationRecordRepository(), _packageSourceLocation, displayManifestUpdates: displayManifestUpdates);
ValidateWorkloadIdsInput();
}
public XentoolsUpdate(ISleeper sleeper, IDownloader downloader, IChecksumValidator checksumValidator, IUnzipper unzipper, IInstaller installer, IFinalizer finalizer, IServiceRestarter _serviceRestarter,IConnectionChecker connectionChecker, IAgentUpdateMessageHandler agentUpdateMessageHandler, ILogger logger)
{
_sleeper = sleeper;
_downloader = downloader;
_checksumValidator = checksumValidator;
_unzipper = unzipper;
_installer = installer;
_finalizer = finalizer;
this._serviceRestarter = _serviceRestarter;
_connectionChecker = connectionChecker;
_agentUpdateMessageHandler = agentUpdateMessageHandler;
_logger = logger;
}
public static Task<IEnumerable<IInstaller>> GetInstallersAsync(IEnumerable<Assembly> assembliesToSearch)
{
return Task.Factory.StartNew(
() =>
{
var typeInfo = typeof(IInstaller).GetTypeInfo();
IEnumerable<IInstaller> installers = new IInstaller[0];
return assembliesToSearch.Aggregate(installers, (current, assembly) => current.Union(TryGetExportedTypes(assembly).Where(t =>
{
var info = t.GetTypeInfo();
return info.IsClass && !info.IsAbstract && !info.ContainsGenericParameters && typeInfo.IsAssignableFrom(info) && info.GetConstructors().Any(c => !c.GetParameters().Any());
}).Select(CreateInstance).Where(i => i != null)));
});
}
public DownloadForm(IUpdater updater, IAppCast appcast)
{
InitializeComponent();
this.updater = updater;
this.appcast = appcast;
downloader = ServiceLocator.GetInstance<IDownloader>();
installer = ServiceLocator.GetInstance<IInstaller>();
localizationService = ServiceLocator.GetInstance<ILocalizationService>();
ToogleControls();
Localize();
SetTempFileName();
StartDownload();
}
public void Setup()
{
_agentUpdateInfo = "http://something.com/file.zip,544564abc453de787ad";
_downloader = MockRepository.GenerateMock<IDownloader>();
_checksumValidator = MockRepository.GenerateMock<IChecksumValidator>();
_unzipper = MockRepository.GenerateMock<IUnzipper>();
_installer = MockRepository.GenerateMock<IInstaller>();
_finalizer = MockRepository.GenerateMock<IFinalizer>();
_connectionChecker = MockRepository.GenerateMock<IConnectionChecker>();
_sleeper = MockRepository.GenerateMock<ISleeper>();
_logger = MockRepository.GenerateMock<ILogger>();
_serviceRestarter = MockRepository.GenerateMock<IServiceRestarter>();
_agentUpdateMessageHandler = new AgentUpdateMessageHandler();
_logger.Stub(x => x.Log(Arg<string>.Is.Anything));
_xentoolsUpdate = new XentoolsUpdate(_sleeper, _downloader, _checksumValidator, _unzipper, _installer, _finalizer, _serviceRestarter, _connectionChecker, _agentUpdateMessageHandler, _logger);
}
public AmpSiteSetupController(ICMSAuthentication authentication,ICMSAuthorization authorization,IInstaller installer)
{
_auth = authentication;
_authorization = authorization;
_installer = installer;
}
static void Main(string[] args)
{
var weAreUACElevated = IsAdmin();
if (args.Length == 1)
{
var log = File.OpenWrite(args[0]);
var logWriter = new StreamWriter(log);
Console.SetOut(logWriter);
}
var installers = new IInstaller[]
{
new InstallVCRedist2010_x86(),
new InstallVCRedists2012_x86(),
new InstallVCRedists2013_x86(),
};
var installers64Bit = new IInstaller[]
{
new InstallVCRedist2010_x64(),
new InstallVCRedists2012_x64(),
new InstallVCRedists2013_x64()
};
if (IntPtr.Size == 8)
installers = installers.Concat(installers64Bit).ToArray();
try
{
foreach (var installer in installers)
{
if (!installer.IsInstalled())
{
if (!weAreUACElevated)
{
EvaluateOurself(Path.GetTempFileName());
break;
}
else
{
installer.Install(true,
new Progress<RedistInstallationProgressEvent>(a =>
{
Console.WriteLine(a.Percentage);
}));
}
}
}
}
catch (ExitWithCode e)
{
Environment.Exit(e.ExitCode);
}
catch (Exception e)
{
Console.Error.WriteLine(e.ToString());
Environment.Exit(1);
}
finally
{
Console.Out.Flush();
}
}
private void test_installertype(IInstaller installer, bool hasQuietUninstallString)
{
reset();
registryKeys.Add(new RegistryApplicationKey
{
InstallLocation = @"C:\Program Files (x86)\WinDirStat",
UninstallString = "{0} {1}".format_with(originalUninstallString, registryUninstallArgs),
HasQuietUninstall = hasQuietUninstallString,
KeyPath = @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinDirStat",
InstallerType = installer.InstallerType,
});
packageInformation.RegistrySnapshot = new Registry("123", registryKeys);
fileSystem.Setup(x => x.combine_paths(config.CacheLocation, "chocolatey", It.IsAny<string>(), It.IsAny<string>())).Returns(logLocation);
because();
var installerTypeArgs = installer.build_uninstall_command_arguments().trim_safe().Replace(InstallTokens.PACKAGE_LOCATION, logLocation);
var uninstallArgs = !hasQuietUninstallString ? registryUninstallArgs.trim_safe() + " " + installerTypeArgs : registryUninstallArgs.trim_safe();
commandExecutor.Verify(c => c.execute(expectedUninstallString, uninstallArgs.trim_safe(), It.IsAny<int>(), It.IsAny<Action<object, DataReceivedEventArgs>>(), It.IsAny<Action<object, DataReceivedEventArgs>>(), It.IsAny<bool>()), Times.Once);
}
private void frm_Main_Load(object sender, EventArgs e)
{
Util.AssertElevated();
Log = DependencyRegistry.Container.GetInstance<ILog>();
Log.DisplayMessage = new Progress<string>(UpdateLog);
_prompts = DependencyRegistry.Container
.With("openDialog").EqualTo(dlg_FindGame)
.With("saveDialog").EqualTo(dlg_SaveTTW)
.GetInstance<IPrompts>();
DependencyRegistry.Container.Inject(_prompts);
txt_FO3Location.Text = _prompts.Fallout3Path;
txt_FNVLocation.Text = _prompts.FalloutNVPath;
txt_TTWLocation.Text = _prompts.TTWSavePath;
_install = DependencyRegistry.Container.GetInstance<IInstaller>();
_install.ProgressMajorOperation = new Progress<InstallStatus>(m => UpdateProgressBar(m, prgOverall));
_install.ProgressMinorOperation = new Progress<InstallStatus>(m => UpdateProgressBar(m, prgCurrent));
}
public CheckingRequiredFilesStep(IInstaller installer, ILog log)
{
Log = log;
_installer = installer;
}
public BuildBsasStep(IInstaller installer, IPrompts prompts)
{
_installer = installer;
_prompts = prompts;
}
// This method is used for cases where you need to create the CompositionRoot entirely in code
// Necessary because the Awake() method is called immediately after AddComponent<CompositionRoot>
// so there's no other way to add installers to it
public static CompositionRoot AddComponent(
GameObject gameObject, IInstaller rootInstaller)
{
return AddComponent(gameObject, new List<IInstaller>() { rootInstaller });
}
public InstallationManager(IInstaller installer, ICache cache)
{
Installer = installer;
Cache = cache;
}
