private async Task MakeBootable(WindowsVolumes volumes, Phone phone, InstallOptions options) { Log.Information("Making Windows installation bootable..."); var bcdPath = Path.Combine(volumes.Boot.RootDir.Name, "EFI", "Microsoft", "Boot", "BCD"); var bcd = new BcdInvoker(bcdPath); var windowsPath = Path.Combine(volumes.Windows.RootDir.Name, "Windows"); var bootDriveLetter = volumes.Boot.Letter; await ProcessUtils.RunProcessAsync(BcdBootPath, $@"{windowsPath} /f UEFI /s {bootDriveLetter}:"); bcd.Invoke("/set {default} testsigning on"); bcd.Invoke("/set {default} nointegritychecks on"); await PatchBootIfNecessary(volumes.Boot, options); await volumes.Boot.Partition.SetGptType(PartitionType.Esp); var updatedBootVolume = await phone.GetBootVolume(); if (updatedBootVolume != null) { Log.Verbose("We shouldn't be able to get a reference to the Boot volume."); Log.Verbose("Updated Boot Volume: {@Volume}", new { updatedBootVolume.Label, updatedBootVolume.Partition, }); if (!Equals(updatedBootVolume.Partition.PartitionType, PartitionType.Esp)) { Log.Warning("The system partition should be {Esp}, but it's {ActualType}", PartitionType.Esp, updatedBootVolume.Partition.PartitionType); } } }
public static void Run(InstallOptions options) { Logo.Print(); ApplySettings(options); if (Packsly.Launcher.CanEmbed && !IsPackslyEmbeded(options.Workspace)) { logger.Info("Embedding packsly to launcher directory..."); EmbedPacksly(options.Workspace); } if (!options.IsSourceSpecified) { logger.Info("Using modpack source from configuration."); options.Source = Packsly.Configuration.DefaultModpackSource; } logger.Info($"Current modpack source: {options.Source}"); if (options.IsSourceLocalFile) { logger.Info("Beginning installation from local modpack definition file..."); Packsly.Launcher.CreateInstanceFromModpack(new FileInfo(options.Source)); } else if (options.IsSourceUrl) { logger.Info("Beginning installation from remote modpack definition source..."); Packsly.Launcher.CreateInstanceFromModpack(new Uri(options.Source)); } else { throw new ConfigurationErrorsException($"Specified modpack source '{options.Source}' is not valid file path or URL address."); } logger.Info("Thank you for using Packsly3!"); }
public static string GenerateString(this InstallOptions options) { string optionsString = string.Empty; if ((options & InstallOptions.WithForwardLock) != 0) { optionsString += " -l"; } if ((options & InstallOptions.ReinstallKeepingData) != 0) { optionsString += " -r"; } if ((options & InstallOptions.InstallToShared) != 0) { optionsString += " -s"; } if ((options & InstallOptions.InstallToInternal) != 0) { optionsString += " -f"; } if ((options & InstallOptions.AllowDowngrade) != 0) { optionsString += " -d"; } if ((options & InstallOptions.GrantAllPermissions) != 0) { optionsString += " -g"; } if ((options & InstallOptions.AllowTestAPKs) != 0) { optionsString += " -t"; } return(optionsString); }
/// <summary> /// Initializes a new instance of the <see cref="WebManager"/> class. /// </summary> /// <param name="options">The install options.</param> /// <param name="variables">A cache of install variables.</param> /// <param name="installLogger">Logs installation results.</param> public WebManager(InstallOptions options, InstallVariables variables, InstallLogger installLogger) { this.installOptions = options; this.installVariables = variables; this.installLogger = installLogger; this.siteName = this.installOptions.RootSite != null ? string.Format("{0}/{1}", this.installOptions.HostName, this.installOptions.WebsiteName) : this.installOptions.WebsiteName; }
/// <inheritdoc /> protected override InstallOptions GetInstallOptions(PackageVersionId version) { InstallOptions options = base.GetInstallOptions(version); options.AllowUpgradeToUnknownVersion = this.IncludeUnknown.ToBool(); return(options); }
private async Task ApplyWindowsImage(WindowsVolumes volumes, InstallOptions options, IObserver <double> progressObserver = null) { Log.Information("Applying Windows Image..."); await windowsImageService.ApplyImage(volumes.Windows, options.ImagePath, options.ImageIndex, progressObserver); progressObserver?.OnNext(double.NaN); }
/// <summary> /// Compile the installer. /// </summary> /// <param name="installOptions">The install options.</param> private void CompileInstaller(InstallOptions installOptions) { // Ask to close and restart to update files with installer var _references = new List <string> { "System.dll", "System.Windows.Forms.dll" }; ResourcesManager.CreateSettingsResource(installOptions.ResourceSettingsPath, installOptions); var _resources = new List <string> { installOptions.ResourceSettingsPath }; var _sources = new[] { Resources.MainEntryPoint, Resources.ConsoleManager, Resources.Installer, Resources.ResourceSettings }; string _updaterFileName = Application.StartupPath + @"\\Updater.exe"; CompilerResults _results = CodeDomCompiler.Build(_references, _sources, _updaterFileName, _resources); if (_results.Errors.Count > 0) { VisualCompileErrorDialog.Show(_results); } else { Process.Start(_updaterFileName); } File.Delete(installOptions.ResourceSettingsPath); }
/// <summary> /// Main method that runs the install program. /// </summary> /// <param name="args">Command line arguments.</param> private static void Main(string[] args) { InstallOptions installOptions = new InstallOptions(); Environment.CurrentDirectory = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName; if (args.Contains("--help")) { Console.Write(installOptions.GetUsage()); Environment.Exit(0); } installLogger = new InstallLogger(installOptions.Quiet); Parser parser = new Parser(settings => { settings.MutuallyExclusive = true; }); if (!parser.ParseArguments(args, installOptions)) { installLogger.LogErrorLine("Invalid command line parameters"); Environment.Exit(1); } JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Formatting = Formatting.None, ContractResolver = new DiscretionalContractResolver(), Converters = new JsonConverter[] { new JsonKnownTypeConverter() } }; new Program().Run(installOptions); }
public async Task DeployCoreAndWindows(InstallOptions options, RaspberryPi device, IObserver <double> progressObserver = null) { await EnsureValidCoreWindowsDeployment(); await CreateInitialPartitionLayout(device, progressObserver); await DeployUefi(device); await DeployWindows(options, device, progressObserver); }
public static void DoInstall(DirectoryInfo source, DirectoryInfo target, InstallOptions options) { CopyFiles(source.GetFiles().ToList(), target); foreach (DirectoryInfo di in source.GetDirectories()) { DoInstall(di, new DirectoryInfo(target.FullName + "\\" + di.Name), options); } }
public Installer(InstallOptions options) { _options = options; // Loads package info using var fr = new StreamReader(_options.PackagePath); _packageInfo = JsonConvert.DeserializeObject <PackageInfo>(fr.ReadToEnd()); }
/// <summary> /// Installs MSI package on remote server using the URI to the MSI package. /// ConDep will first download the MSI package to the server and then install the package. /// </summary> /// <param name="install"></param> /// <param name="packageName">A uniqe package name (DisplayName in Windows Registry) to make this /// operation idempotent. If this package name is not correct, ConDep will install this package /// on every execution. ConDep looks in these three registry keys for installed software packages: /// HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall</param> /// <param name="srcMsiUri">A URI to the MSI package</param> /// <param name="options">Additional options to pass in to msiexec.</param> /// <returns></returns> public static IOfferRemoteInstallation Msi(this IOfferRemoteInstallation install, string packageName, Uri srcMsiUri, Action <IOfferInstallOptions> options) { var msiOptions = new InstallOptions(); options(msiOptions); var msiOperation = new MsiOperation(packageName, srcMsiUri, msiOptions.Values); OperationExecutor.Execute((RemoteBuilder)install, msiOperation); return(install); }
/// <summary> /// Updates a package from the pipeline or from the local system. /// </summary> protected override void ProcessRecord() { base.ProcessRecord(); this.GetPackageAndExecute(CompositeSearchBehavior.LocalCatalogs, (package, version) => { InstallOptions options = this.GetInstallOptions(version); InstallResult result = this.UpgradePackage(package, options); this.WriteObject(result); }); }
private InstallResult UpgradePackage( CatalogPackage package, InstallOptions options) { var operation = PackageManager.Value.UpgradePackageAsync(package, options); return(this.RegisterCallbacksAndWait(operation, string.Format( Utilities.ResourceManager.GetString("ProgressRecordActivityUpdating"), package.Name))); }
public void StartDownloading() { InstallOptions InstallOptions = GameObject.Find("InstallOptions").GetComponent <InstallOptions>(); InstallOptions.gameObject.GetComponent <Canvas>().enabled = true; InstallOptions.GetComponent <InstallOptions>().RequiredSpace = RequiredSpace; GameNameText.text = GameName; SpecialScripts.ThisGame = gameObject.name; InstallOptions.OpenOptions(); }
/// <summary> /// Installs MSI package on remote server using the URI to the MSI package. /// ConDep will first download the MSI package to the server and then install the package. /// </summary> /// <param name="install"></param> /// <param name="packageName">A uniqe package name (DisplayName in Windows Registry) to make this /// operation idempotent. If this package name is not correct, ConDep will install this package /// on every execution. ConDep looks in these three registry keys for installed software packages: /// HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall</param> /// <param name="srcMsiUri">A URI to the MSI package</param> /// <param name="options">Additional options to pass in to msiexec.</param> /// <returns></returns> public static IOfferRemoteInstallation Msi(this IOfferRemoteInstallation install, string packageName, Uri srcMsiUri, Action <IOfferInstallOptions> options) { var msiOptions = new InstallOptions(); options(msiOptions); var msiOperation = new MsiOperation(packageName, srcMsiUri, msiOptions.Values); Configure.Operation(install, msiOperation); return(install); }
/// <summary>Initializes a new instance of the <see cref="UpdaterStateEventArgs" /> class.</summary> /// <param name="assembly">The assembly.</param> /// <param name="installOptions">The install Options.</param> /// <param name="packagePath">The package path.</param> /// <param name="state">The update state.</param> public UpdaterStateEventArgs(Assembly assembly, InstallOptions installOptions, Uri packagePath, UpdaterState state) { Assembly = assembly; AssemblyLocation = assembly.Location; InstallOptions = installOptions; PackagePath = packagePath; Package = new Package(packagePath); State = state; UpdateAvailable = ApplicationManager.CheckForUpdate(assembly, packagePath); Version = assembly.GetName().Version; }
public ChangeLogPanel(InstallOptions installOptions, Package package, Version currentVersion) { InitializeComponent(); StringBuilder _versionInfo = new StringBuilder(); _versionInfo.AppendLine(@"The version of " + package.Name + @" installed on this computer is: v" + currentVersion); _versionInfo.AppendLine(@"The latest version is: v" + package.Version); LVersion.Text = _versionInfo.ToString(); TbChangeLog.Text = package.ChangeLog; }
public async Task DeployWindows(InstallOptions options, Phone phone, IObserver <double> progressObserver = null) { await EnsureValidWindowsDeployment(); Log.Information("Deploying Windows 10 ARM64..."); await EnsureNoDualBootMenu(phone); await windowsDeployer.Deploy(options, phone, progressObserver); Log.Information("Deployment successful"); }
private static void InstallUpdate(InstallOptions options) { var installer = new Installer(options); installer .ExtractPackage() .CopyNewVersion(); if (options.RemoveAfterInstall) { installer.RemovePackages(); } }
private async Task PatchBootIfNecessary(Volume boot, InstallOptions partitionsBoot) { if (partitionsBoot.PatchBoot) { Log.Information("Patching boot..."); var source = new DirectoryInfo(deploymentPaths.BootPatchFolder); var dest = new DirectoryInfo(Path.Combine(boot.RootDir.FullName, "EFI", "Boot")); await FileUtils.CopyDirectory(source, dest); Log.Information("Boot patched"); } }
/// <summary> /// Use this for installing packages that are not an MSI (.msi extension). Typically an /// executable (.exe) followed by a set of parameters to make the installation /// non-interactive (silent). /// </summary> /// <param name="install"></param> /// <param name="packageName">A uniqe package name (DisplayName in Windows Registry) to make this /// operation idempotent. If this package name is not correct, ConDep will install this package /// on every execution. ConDep looks in these three registry keys for installed software packages: /// HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall</param> /// <param name="srcExecutableUri">A URI to the custom package</param> /// <param name="exeParams">Parameters needed by the package to install silently, logging etc.</param> /// <returns></returns> public static IOfferRemoteInstallation Custom(this IOfferRemoteInstallation install, string packageName, Uri srcExecutableUri, string exeParams, Action <IOfferInstallOptions> options = null) { var installOptions = new InstallOptions(); if (options != null) { options(installOptions); } var exeOperation = new InstallExecutableOperation(packageName, srcExecutableUri, exeParams, installOptions.Values); Configure.Operation(install, exeOperation); return(install); }
/// <summary> /// Use this for installing packages that are not an MSI (.msi extension). Typically an /// executable (.exe) followed by a set of parameters to make the installation /// non-interactive (silent). /// </summary> /// <param name="install"></param> /// <param name="packageName">A uniqe package name (DisplayName in Windows Registry) to make this /// operation idempotent. If this package name is not correct, ConDep will install this package /// on every execution. ConDep looks in these three registry keys for installed software packages: /// HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Uninstall /// HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall</param> /// <param name="srcExecutableFilePath">A local file path to the custom package (not a path on target server).</param> /// <param name="exeParams">Parameters needed by the package to install silently, logging etc.</param> /// <returns></returns> public static IOfferRemoteInstallation Custom(this IOfferRemoteInstallation install, string packageName, string srcExecutableFilePath, string exeParams, Action <IOfferInstallOptions> options = null) { var installOptions = new InstallOptions(); if (options != null) { options(installOptions); } var exeOperation = new InstallExecutableOperation(packageName, srcExecutableFilePath, exeParams, installOptions.Values); OperationExecutor.Execute((RemoteBuilder)install, exeOperation); return(install); }
/// <summary> /// Create the resource settings. /// </summary> /// <param name="filename">The filename.</param> /// <param name="installOptions">The install options.</param> public static void CreateSettingsResource(string filename, InstallOptions installOptions) { using (ResourceWriter _resourceWriter = new ResourceWriter(filename)) { _resourceWriter.AddResource("Logging", false); // TODO: On true it won't display the contents like ExtractFolder in the console. _resourceWriter.AddResource("ProductName", installOptions.ProductName); _resourceWriter.AddResource("ExecutablePath", installOptions.ExecutablePath); _resourceWriter.AddResource("InstallDirectory", installOptions.InstallDirectory); _resourceWriter.AddResource("RestartApplicationAfterInstall", installOptions.RestartApplicationAfterInstall); _resourceWriter.Generate(); _resourceWriter.Close(); } }
public static void InstallDone() // dont change this { Unzipper Unzipper = GameObject.Find("Unzipper").GetComponent <Unzipper>(); Unzipper.GetComponent <Unzipper>().InstallText.text = ("Afronden van installatie"); DownloadGame downloader = GameObject.Find("Downloader").GetComponent <DownloadGame>(); InstallOptions installoptions = GameObject.Find("InstallOptions").GetComponent <InstallOptions>(); installoptions.ResetShortcut(); downloader.GetComponent <DownloadGame>().CleanUp(); Unzipper.GetComponent <Unzipper>().InstallText.text = ("Installatie Voltooid !"); Gamebuttons.Enable(); ExitButtonStatic.SetActive(true); }
public WelcomePage(InstallOptions installOptions, Package package, Version currentVersion) { InitializeComponent(); LTitle.Text = $@"Welcome to the {package.Name} Update Wizard"; StringBuilder _headerText = new StringBuilder(); _headerText.AppendLine($@"This wizard will guide you through the update of {package.Name}."); _headerText.Append(Environment.NewLine); _headerText.AppendLine($@"It is recommended that you close all other applications before continuing."); _headerText.Append(Environment.NewLine); _headerText.AppendLine($@"Click Next to continue, or Cancel to exit the update."); LHeader.Text = _headerText.ToString(); }
public async Task Deploy(InstallOptions options, RaspberryPi phone, IObserver <double> progressObserver = null) { Log.Information("Deploying Windows 10 ARM64..."); await RemoveExistingWindowsPartitions(phone); await CreateWindowsPartition(phone); var windowsVolumes = new WindowsVolumes(await phone.GetBootVolume(), await phone.GetWindowsVolume()); await ApplyWindowsImage(windowsVolumes, options, progressObserver); await InjectDrivers(windowsVolumes.Windows); await MakeBootable(windowsVolumes, phone); Log.Information("Windows Image deployed"); }
public async Task Deploy(InstallOptions options, Phone phone, IObserver <double> progressObserver = null) { Log.Information("Deploying Windows 10 ARM64..."); await RemoveExistingWindowsPartitions(phone); await AllocateSpace(phone, options.SizeReservedForWindows); var partitions = await CreatePartitions(phone); await ApplyWindowsImage(partitions, options, progressObserver); await InjectDrivers(partitions.Windows); await MakeBootable(partitions, phone, options); Log.Information("Windows Image deployed"); }
public async Task Install(InstallOptions options, string expected) { // arrange var processManager = new TestProcessManager(); processManager.AddProcess(new[] { "Success" }); var adb = new Adb(processManager); // act var deviceAdb = adb.SingleDevice; await deviceAdb.Install("test.apk", options); // assert processManager.Stub.AssertWasCalled(_ => _.CreateProcess(Arg <string> .Is.Anything, Arg <string> .Matches(c => c.Contains(expected)))); }
public void should_create_dic_from_options() { var installCommand = new InstallOptions() { Interactive = true, Package = "vlc", }; var dic = installCommand.ToDictionary(); dic["cmd_package"].Should().Be(installCommand.Package); dic["cmd_interactivity"].Should().Be("interactive"); dic["cmd_force"].Should().Be("False"); dic["cmd_tag"].Should().Be(null); dic["cmd_commandname"].Should().Be("install"); }
/// <summary>Initializes a new instance of the <see cref="CometUpdater" /> class.</summary> public CometUpdater() { _updateServerPackagePath = new Uri("https://www.site.com/update.package"); _autoUpdate = false; _notifyUpdateAvailable = true; _notifyUpdateReadyToInstall = true; _state = UpdaterState.NotChecked; _installOptions = new InstallOptions(string.Empty, true, true); _opened = false; _backgroundUpdateChecker = new BackgroundWorker { WorkerSupportsCancellation = true }; _backgroundUpdateChecker.DoWork += BackgroundUpdateCheckerDoWork; _backgroundUpdateChecker.RunWorkerCompleted += BackgroundUpdateChecker_Completed; }
public CommandLineParserTests(ITestOutputHelper output) { _output = output; _parser = CommandLineParser.Create( new ServiceCollection(), startServer: (options, invocationContext) => { _startOptions = options; }, demo: (options, console, context, startOptions) => { _demoOptions = options; return(Task.CompletedTask); }, tryGithub: (options, c) => { _tryGitHubOptions = options; return(Task.CompletedTask); }, pack: (options, console) => { _packOptions = options; return(Task.CompletedTask); }, install: (options, console) => { _installOptions = options; _installPackageSource = options.AddSource; return(Task.CompletedTask); }, verify: (options, console, startupOptions) => { _verifyOptions = options; return(Task.FromResult(0)); }, telemetry: new FakeTelemetry(), publish: (options, console, startupOptions) => { _publishOptions = options; return(Task.FromResult(0)); }, firstTimeUseNoticeSentinel: new NopFirstTimeUseNoticeSentinel()); }
/// <summary> /// Checks all required parameters are supplied, and requests /// them from the user when they are missing. /// </summary> /// <param name="installOptionsToUse">The install options.</param> private void CheckParameters(InstallOptions installOptionsToUse) { if (installOptionsToUse.Quiet) { if (installOptionsToUse.Mode == InstallerMode.Unknown) { installOptionsToUse.Install = true; } return; } if (installOptionsToUse.Mode == InstallerMode.Unknown) { Menu menu = new Menu(); menu.AddMenuItem("I", "Install", (Action)delegate { installOptionsToUse.Install = true; }, new object[] { }); menu.AddMenuItem("R", "Repair / Upgrade Database", (Action)delegate { installOptionsToUse.Repair = true; }, new object[] { }); menu.AddMenuItem("U", "Uninstall", (Action)delegate { installOptionsToUse.Uninstall = true; }, new object[] { }); menu.AddMenuItem("Q", "Quit", (Action<int>)Environment.Exit, new object[] { 0 }); menu.DisplayMenu(); } if (installOptionsToUse.Mode == InstallerMode.Install || installOptionsToUse.Mode == InstallerMode.Uninstall) { Menu menu = new Menu(); menu.AddMenuItem("S", string.Format("Standard {0}", installOptionsToUse.Mode), (Action)delegate { installOptionsToUse.Api = false; }, new object[] { }); menu.AddMenuItem("A", string.Format("API {0}", installOptionsToUse.Mode), (Action)delegate { installOptionsToUse.Api = true; }, new object[] { }); menu.AddMenuItem("Q", "Quit", (Action<int>)Environment.Exit, new object[] { 0 }); menu.DisplayMenu(); menu = new Menu(); menu.AddMenuItem("R", string.Format("Root {0}", installOptionsToUse.Mode), (Action)delegate { installOptionsToUse.RootSite = null; }, new object[] { }); menu.AddMenuItem("S", string.Format("Subsite {0}", installOptionsToUse.Mode), new Action<InstallOptions>(this.DisplaySubsiteMenu), new object[] { installOptionsToUse }); menu.AddMenuItem("Q", "Quit", (Action<int>)Environment.Exit, new object[] { 0 }); menu.DisplayMenu(); string descriptionText = installOptionsToUse.Api ? Strings.APIDescription : Strings.StandardDescription; string exampleUrl = installOptionsToUse.Api ? Strings.APIExampleURL : Strings.StandardExampleURL; if (installOptionsToUse.RootSite != null && string.IsNullOrEmpty(installOptionsToUse.WebsiteName)) { var binding = installOptionsToUse.RootSite.Bindings.FirstOrDefault(b => !string.IsNullOrEmpty(b.Host)); var hostname = binding != null ? binding.Host : Strings.DefaultBinding; installOptionsToUse.HostName = hostname; if (binding == null) { // Show the user a warning if the default bindings Host value is blank. installLogger.LogWarningLine(Strings.DefaultBindingWarning); } installLogger.LogLine(null); installLogger.LogWarningLine(string.Format(Strings.SubsiteDescription, hostname)); installLogger.LogLine(null); installOptionsToUse.WebsiteName = this.ReadValidSiteName("Subsite Path (no slashes)"); } else if (string.IsNullOrEmpty(installOptionsToUse.WebsiteName)) { installLogger.LogLine(null); installLogger.LogWarningLine(descriptionText); installLogger.LogLine(null); installOptionsToUse.WebsiteName = this.ReadValidSiteName(string.Format("Website Name (eg. {0})", exampleUrl)); } if (installOptionsToUse.Mode == InstallerMode.Install && installOptionsToUse.Api && string.IsNullOrEmpty(installOptionsToUse.IapplyWebsiteName)) { installLogger.LogLine(null); installLogger.LogWarningLine(Strings.BaseWebsiteDescription); installLogger.LogLine(null); installOptionsToUse.IapplyWebsiteName = this.ReadValidSitePath(string.Format("iApply Website Name (eg. {0} - blank for {1})", Strings.StandardExampleURL, installOptionsToUse.WebsiteName)); } } if (installOptionsToUse.Mode != InstallerMode.Install && installOptionsToUse.Mode != InstallerMode.Repair) { return; } bool connectionStringSpecified = !string.IsNullOrEmpty(installOptionsToUse.MongoHost) && !string.IsNullOrEmpty(installOptionsToUse.MongoDatabase); if (string.IsNullOrEmpty(installOptionsToUse.MongoHost)) { installOptionsToUse.MongoHost = this.ReadInput("MongoDB Host", "LOCALHOST"); } if (!installOptionsToUse.MongoPort.HasValue) { installOptionsToUse.MongoPort = Convert.ToInt32(this.ReadInput("MongoDB Port ", "27017")); } if (string.IsNullOrEmpty(installOptionsToUse.MongoDatabase)) { installOptionsToUse.MongoDatabase = this.ReadInput("MongoDB Database Name"); } if (!connectionStringSpecified && string.IsNullOrEmpty(installOptionsToUse.MongoUsername)) { installOptionsToUse.MongoUsername = this.ReadInput("MongoDB Username (blank for none)"); } if (!string.IsNullOrEmpty(installOptionsToUse.MongoUsername) && string.IsNullOrEmpty(installOptionsToUse.MongoPassword)) { installOptionsToUse.MongoPassword = this.ReadPassword("MongoDB Password"); } }
/// <summary> /// Initializes a new instance of the <see cref="ScheduledTaskManager"/> class. /// </summary> /// <param name="options">The install options.</param> /// <param name="variables">A cache of install variables.</param> /// <param name="installLogger">Logs installation results.</param> public ScheduledTaskManager(InstallOptions options, InstallVariables variables, InstallLogger installLogger) { this.installOptions = options; this.installVariables = variables; this.installLogger = installLogger; }
/// <summary> /// Displays the subsite menu. /// </summary> /// <param name="installOptionsToUse">The install options to use.</param> private void DisplaySubsiteMenu(InstallOptions installOptionsToUse) { Menu rootSiteSelection = new Menu(); var iisManager = new ServerManager(); SiteCollection sites = iisManager.Sites; for (int i = 0; i < sites.Count; i++) { int iVal = i; var site = sites[iVal]; var firstBinding = site.Bindings.FirstOrDefault(); var hostname = firstBinding != null ? (!string.IsNullOrEmpty(firstBinding.Host) ? firstBinding.Host : Strings.DefaultBinding) : Strings.DefaultBinding; rootSiteSelection.AddMenuItem( Convert.ToString(iVal + 1), string.Format("{0} ({1})", site.Name, hostname), (Action)delegate { installOptionsToUse.RootSite = sites[iVal]; }, new object[] { }); } rootSiteSelection.DisplayMenu(true); }
/// <summary> /// Run the installation / uninstallation process. /// </summary> /// <param name="options">The install options.</param> private void Run(InstallOptions options) { int exitCode = 0; this.installOptions = options; try { if (string.IsNullOrEmpty(this.installOptions.LogFileRelative)) { this.installOptions.LogFileAbsolute = this.installOptions.Mode + ".log"; } installLogger.SetLogFile(options.LogFileAbsolute); if (!this.IsUserAdministrator()) { throw new UnauthorizedAccessException(Messages.MAIN_AdminRequired); } this.installVariables.BasePath = this.FindBasePath(); this.CheckParameters(options); this.webManager = new WebManager(this.installOptions, this.installVariables, installLogger); this.taskManager = new ScheduledTaskManager(this.installOptions, this.installVariables, installLogger); if (options.Mode != InstallerMode.Uninstall) { IMongoConfiguration mongoConfiguration = new MongoConfiguration { Host = this.installOptions.MongoHost, Port = this.installOptions.MongoPort.Value, Database = this.installOptions.MongoDatabase, Username = this.installOptions.MongoUsername, Password = this.installOptions.MongoPassword }; var websiteName = this.installOptions.WebsiteName; if (this.installOptions.RootSite != null) { websiteName = string.Format("{0}/{1}", this.installOptions.HostName, this.installOptions.WebsiteName); } DatabaseInitialiserOptions dbInitOptions = new DatabaseInitialiserOptions { WebsiteName = websiteName, OrgName = this.installOptions.OrgName, AdminEmail = this.installOptions.AdminEmail, AdminPassword = this.installOptions.AdminPassword }; this.dbManager = new DatabaseInitialiser(mongoConfiguration, dbInitOptions, this.installVariables, installLogger) { ReadInput = this.ReadInput, ReadPassword = this.ReadInput }; } if (options.Mode == InstallerMode.Install) { this.RunInstall(options.Type); } if (options.Mode == InstallerMode.Repair) { this.dbManager.Run(); } if (options.Mode != InstallerMode.Uninstall) { if (options.Api && !string.IsNullOrEmpty(this.installOptions.IapplyWebsiteName)) { this.installOptions.WebsiteName = this.installOptions.IapplyWebsiteName; } ConfigurationUpdater updater = new ConfigurationUpdater(this.installOptions, this.installVariables); updater.UpdateXmlConfig(options.Type); updater.UpdateJsConfig(options.Type); updater.WriteDbConfig(); if (options.Mode != InstallerMode.Repair) { updater.GenerateNewCryptoKeys(); } installLogger.LogLine(Messages.MAIN_InstallationComplete); } if (options.Mode == InstallerMode.Uninstall) { this.RunUninstall(options.Type); } } catch (Exception e) { installLogger.LogError(e); exitCode = 1; } if (!this.installOptions.Quiet) { Console.Write(Environment.NewLine + Strings.PressAnyKey); Console.ReadKey(); } Environment.Exit(exitCode); }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationUpdater"/> class. /// </summary> /// <param name="installOptions">The install options.</param> /// <param name="installVariables">A cache of install variables.</param> public ConfigurationUpdater(InstallOptions installOptions, InstallVariables installVariables) { this.installOptions = installOptions; this.installVariables = installVariables; }