C# DeploymentContext.GetLoggerFor方法代码示例

        public override void AfterDeploy(DeploymentContext context)
        {
            var logger = context.GetLoggerFor(this);
            if (!EnvironmentIsValidForPackage(context))
            {
                return;
            }

            // if no such service then install it
            using (var service = ServiceController.GetServices().SingleOrDefault(s => s.ServiceName == context.Package.Id))
            {
                if (service == null)
                {
                    var pathToExecutable = Path.Combine(context.TargetInstallationFolder, context.Package.Id + ".exe");
                    logger.InfoFormat("Installing service {0} from {1}", context.Package.Title, pathToExecutable);

                    System.Configuration.Install.ManagedInstallerClass.InstallHelper(new[] {pathToExecutable});
                }
            }

            using (var service = ServiceController.GetServices().SingleOrDefault(s => s.ServiceName == context.Package.Id))
            {
                // todo: recursively shut down dependent services
                if (!service.Status.Equals(ServiceControllerStatus.Stopped) &&
                    !service.Status.Equals(ServiceControllerStatus.StopPending))
                {
                    return;
                }

                ChangeServiceStateTo(service, ServiceControllerStatus.Running, service.Start, logger);
            }
        }

        public override void BeforeDeploy(DeploymentContext context, Action<ProgressReport> reportProgress)
        {
            var logger = context.GetLoggerFor(this);

            // find an app_online.htm file in the package
            var appOnline = context.Package.GetFiles().SingleOrDefault(f => f.Path.EndsWith(APP_ONLINE_FILE));

            if (appOnline == null)
            {
                return;
            }

            var tempFilePath = Path.Combine(context.WorkingFolder, appOnline.Path);
            var destinationFilePath = Path.Combine(context.TargetInstallationFolder, APP_OFFLINE_FILE);

            if (!File.Exists(tempFilePath))
            {
                return;
            }

            logger.Info("Copying app_offline.htm to destination");
            reportProgress(new ProgressReport(context, GetType(), "Copying app_offline.htm to destination"));

            if (!_fileSystem.Directory.Exists(Path.GetDirectoryName(destinationFilePath)))
            {
                _fileSystem.Directory.CreateDirectory(Path.GetDirectoryName(destinationFilePath));
            }

            if (!_fileSystem.File.Exists(destinationFilePath))
            {
                _fileSystem.File.Copy(tempFilePath, destinationFilePath);
            }

            WaitForAppToUnload();
        }

 public override bool HookValidForPackage(DeploymentContext context)
 {
     Site site;
     LocateMsDeploy(context.GetLoggerFor(this));
     var iis7SiteInstance = FindIis7Website(context.Package.Title);
     return context.Package.Tags.ToLower().Split(' ', ',', ';').Contains("website")
            && !string.IsNullOrEmpty(MsWebDeployPath)
            && TryFindIis7Website(context.Package.Id, out site);
 }

        public override void BeforeDeploy(DeploymentContext context)
        {
            var logger = context.GetLoggerFor(this);
            if (!EnvironmentIsValidForPackage(context))
            {
                return;
            }

            ShutdownRequiredServices(context, logger);
        }

 public override void BeforeDeploy(DeploymentContext context)
 {
     var logger = context.GetLoggerFor(this);
     var appPools = GetApplicationPoolsForWebsite(context.Package.Title);
     foreach (var appPool in appPools)
     {
         logger.InfoFormat("Stopping application pool {0}", appPool.Name);
         appPool.Stop();
     }
 }

        public override void AfterDeploy(DeploymentContext context)
        {
            var logger = context.GetLoggerFor(this);
            logger.Info("Removing app_offline.htm to destination");

            var appOfflineFilePath = Path.Combine(context.TargetInstallationFolder, APP_OFFLINE_FILE);

            if (_fileSystem.File.Exists(appOfflineFilePath))
            {
                _fileSystem.File.Delete(appOfflineFilePath);
            }
        }

        public bool Deploy(string taskId, IPackage package, CancellationTokenSource cancellationToken, Action<ProgressReport> reportProgress)
        {
            var unpackFolder = Path.Combine(AgentSettings.AgentProgramDataPath, _agentSettingsManager.Settings.UnpackingLocation);
            var workingFolder = Path.Combine(unpackFolder, package.GetFullName());
            var targetInstallationFolder = Path.Combine(_agentSettingsManager.Settings.BaseInstallationPath, package.Id);
            using (var deploymentContext = new DeploymentContext(package, _agentSettingsManager, workingFolder, targetInstallationFolder, taskId))
            {

                var logger = deploymentContext.GetLoggerFor(this);
                var frameworks = package.GetSupportedFrameworks();
                foreach (var framework in frameworks)
                {
                    logger.DebugFormat("package supports {0}", framework.FullName);
                }

                try
                {
                    reportProgress(ProgressReport.Info(deploymentContext, this, package.Id,
                                                       package.Version.Version.ToString(), taskId,
                                                       "Extracting package to temp folder..."));
                    new NuGetPackageExtractor(Logger).Extract(package, workingFolder);
                }
                catch (Exception ex)
                {
                    logger.Fatal("Could not extract package", ex);
                }

                try
                {
                    BeforeDeploy(deploymentContext, reportProgress);
                    PerformDeploy(deploymentContext, reportProgress);
                    AfterDeploy(deploymentContext, reportProgress);

                    reportProgress(ProgressReport.Info(deploymentContext, this, package.Id,
                                                       package.Version.Version.ToString(), taskId,
                                                       "Deployment complete"));
                    return true;
                }
                catch (Exception ex)
                {
                    logger.Error("An error occurred", ex);
                    reportProgress(ProgressReport.Error(deploymentContext, this, package.Id,
                                                        package.Version.Version.ToString(), taskId,
                                                        "Deployment failed", ex));
                    return false;
                }
                finally
                {
                    deploymentContext.RemoveAppender();
                }
            }
        }

        public override void AfterDeploy(DeploymentContext context, Action<ProgressReport> reportProgress)
        {
            var logger = context.GetLoggerFor(this);
            logger.Info("Removing app_offline.htm from destination");
            reportProgress(new ProgressReport(context, GetType(), "Removing app_offline.htm from destination"));

            var appOfflineFilePath = Path.Combine(context.TargetInstallationFolder, APP_OFFLINE_FILE);

            if (_fileSystem.File.Exists(appOfflineFilePath))
            {
                _fileSystem.File.Delete(appOfflineFilePath);
            }
        }

 public override void AfterDeploy(DeploymentContext context, Action<ProgressReport> reportProgress)
 {
     var logger = context.GetLoggerFor(this);
     reportProgress(new ProgressReport(context, GetType(), "Starting application pool(s)"));
     var appPools = GetApplicationPoolsForWebsite(context.Package.Title);
     foreach(var appPool in appPools)
     {
         if (appPool.State == ObjectState.Stopped)
         {
             logger.InfoFormat("Starting application pool {0}", appPool.Name);
             appPool.Start();
         }
     }
 }

        public override void AfterDeploy(DeploymentContext context, Action<ProgressReport> reportProgress)
        {
            var logger = context.GetLoggerFor(this);
            if (!EnvironmentIsValidForPackage(context))
            {
                return;
            }

            reportProgress(new ProgressReport(context, GetType(), "Starting service"));

            var pathToExecutable = Path.Combine(Path.Combine(_serviceInstallationPath, context.Package.Id),
                                                context.Package.Id + ".exe");
            var serviceName = DetermineServiceName(context, pathToExecutable, logger);

            // if no such service then install it
            using (var service = GetServiceByNameOrDisplayName(serviceName))
            {
                if (service == null)
                {
                    logger.InfoFormat("Installing service {0} from {1}", serviceName, pathToExecutable);

                    ManagedInstallerClass.InstallHelper(new[] {pathToExecutable});
                    serviceName = DetermineServiceName(context, pathToExecutable, logger);
                }
            }

            // check that installation succeeded
            using (var service = GetServiceByNameOrDisplayName(serviceName))
            {
                // it didn't... installutil might be presenting a credentials dialog on the terminal
                if (service == null)
                {
                    throw new InstallException(
                        string.Format(
                            "The executable {0} was installed, so a service named '{1}' was expected but it could not be found",
                            Path.GetFileNameWithoutExtension(pathToExecutable), serviceName));
                }
            }

            using (var service = GetServiceByNameOrDisplayName(serviceName))
            {
                if (!service.Status.Equals(ServiceControllerStatus.Stopped) &&
                    !service.Status.Equals(ServiceControllerStatus.StopPending))
                {
                    return;
                }

                ChangeServiceStateTo(service, ServiceControllerStatus.Running, service.Start, logger);
            }
        }

        protected void CopyAllFilesToDestination(DeploymentContext context)
        {
            var installationLogger = context.GetLoggerFor(this);
            // this is where file copy will occur
            var sourceFolder = new DirectoryInfo(Path.Combine(context.WorkingFolder, "content"));

            if (!Directory.Exists(context.TargetInstallationFolder))
            {
                Directory.CreateDirectory(context.TargetInstallationFolder);
            }

            CleanDestinationFolder(context, installationLogger);

            try
            {
                RecursiveCopy(sourceFolder, context.TargetInstallationFolder, installationLogger);
            }
            catch (Exception exception)
            {
                installationLogger.Fatal("Copy failed", exception);
            }
        }

        private void FindAndTransformAppropriateConfiguration(DeploymentContext context, Action<ProgressReport> reportProgress)
        {
            var installationLogger = context.GetLoggerFor(this);

            reportProgress(new ProgressReport(context, GetType(), "Transforming configuration files"));

            //  find base config files
            string baseConfigurationFileName = "app.config";
            string expectedTransformFileName = string.Format("app.{0}{1}",
                                                             AgentSettingsManager.Settings.DeploymentEnvironment,
                                                             Path.GetExtension(baseConfigurationFileName));
            string outputFileName = string.Format("{0}.exe.config", context.Package.Title);

            if (context.Package.Tags.ToLower().Split(' ', ',', ';').Contains("website"))
            {
                baseConfigurationFileName = "web.config";
                expectedTransformFileName = string.Format("web.{0}.config", AgentSettingsManager.Settings.DeploymentEnvironment);
                outputFileName = "web.config";
            }
            var baseConfigurationPath = Path.Combine(context.WorkingFolder + "\\config", baseConfigurationFileName);
            var transformFilePath = Path.Combine(context.WorkingFolder + "\\config", expectedTransformFileName);

            if (!File.Exists(baseConfigurationPath))
            {
                installationLogger.DebugFormat("Config file not found, expected {0}", baseConfigurationPath);
            }

            // find a matching transform
            if (File.Exists(transformFilePath))
            {
                var outputPath = Path.Combine(context.TargetInstallationFolder, outputFileName);
                var transformArgs = string.Format(@"--source=""{0}"" --transform=""{1}"" --destination=""{2}""",
                                                    baseConfigurationPath,
                                                    transformFilePath,
                                                    outputPath);
                RunProcess(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"tools\TransformVsConfiguration.exe"),
                            transformArgs, installationLogger);
            }
        }

        public override void AfterDeploy(DeploymentContext context)
        {
            var installationLogger = context.GetLoggerFor(this);
            //  find base config files
            if (context.Package.Tags.ToLower().Split(' ', ',', ';').Contains("website"))
            {
            }

            var configFiles = context.Package.GetFiles().Where(f=>f.Path.ToLower().StartsWith("config\\", StringComparison.InvariantCultureIgnoreCase));

            foreach(var configFile in configFiles)
            {
                var expectedTransformFileName = string.Format("{0}.{1}{2}",
                    Path.GetFileNameWithoutExtension(configFile.Path),
                    AgentSettings.DeploymentEnvironment,
                    Path.GetExtension(configFile.Path));

                var baseConfigurationPath = Path.Combine(context.WorkingFolder, configFile.Path);
                var transformFilePath = Path.Combine(context.WorkingFolder, Path.Combine(Path.GetDirectoryName(configFile.Path), expectedTransformFileName));
                var outputPath = Path.Combine(context.TargetInstallationFolder, configFile.Path);

                installationLogger.DebugFormat("looking for {0}", transformFilePath);

                if (File.Exists(transformFilePath))
                {
                    // todo: perform transform here
                    installationLogger.InfoFormat(@"Transform ""{0}"" using ""{1}"" to ""{2}""", baseConfigurationPath, transformFilePath, outputPath);
                    var transformArgs = string.Format(@"--source=""{0}"" --transform=""{1}"" --destination=""{2}""",
                        baseConfigurationPath,
                        transformFilePath,
                        outputPath);
                    RunProcess(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"tools\TransformVsConfiguration.exe"), transformArgs, installationLogger);
                }
                else
                {
                    installationLogger.DebugFormat("No transform found for {0}", baseConfigurationPath);
                }
            }
        }

 public override void Deploy(DeploymentContext context, Action<ProgressReport> reportProgress)
 {
     ExecuteScriptIfFoundInPackage(context, "deploy.ps1", context.GetLoggerFor(this), reportProgress);
 }

 public override void Deploy(DeploymentContext context)
 {
     var installationLogger = context.GetLoggerFor(this);
     LocateMsDeploy(installationLogger);
     DeployWebsite(
         "localhost",
         Path.Combine(context.WorkingFolder, "Content\\" + context.Package.Id + ".zip"),
         context.Package.Title,
         installationLogger,
         Ignore.AppOffline().And().LogFiles().And().MaintenanceFile());
 }