public static ConDepExecutionResult ExecuteFromAssembly(ConDepSettings conDepSettings, CancellationToken token)
        {
            try
            {
                if (conDepSettings.Options.Assembly == null) throw new ArgumentException("assembly");

                var lbLookup = new LoadBalancerLookup(conDepSettings.Config.LoadBalancer);
                var runbookConfigurationHandler = new RunbookConfigurationHandler(new RunbookHandler(), new RunbookDependencyHandler(), lbLookup.GetLoadBalancer());
                //var sequenceManager = artifactConfigHandler.CreateExecutionSequence(conDepSettings);

                var clientValidator = new ClientValidator();

                var serverInfoHarvester = HarvesterFactory.GetHarvester(conDepSettings);
                var serverValidator = new RemoteServerValidator(conDepSettings.Config.Servers,
                                                                serverInfoHarvester, new PowerShellExecutor());

                //if (conDepSettings.Options.DryRun)
                //{
                //    Logger.Warn("Showing execution sequence from dry run:");
                //    sequenceManager.DryRun(conDepSettings);
                //    return new ConDepExecutionResult(true);
                //}

                return new ConDepConfigurationExecutor().Execute(conDepSettings, clientValidator, serverValidator, runbookConfigurationHandler.GetRunbooksToExecute(conDepSettings), new ServerHandler(), token);
            }
            catch (Exception ex)
            {
                Logger.Error("An error sneaked by.", ex);
                throw;
            }
        }
        public void DryRun(ConDepSettings settings)
        {
            Logger.WithLogSection("Local Operations", () =>
            {
                foreach (var item in _localSequences)
                {
                    Logger.WithLogSection(item.Name, () => { item.DryRun(); });
                }
            });

            var loadBalancer = GetDryRunLoadBalancer();
            Logger.WithLogSection("Remote Operations", () =>
            {
                foreach (var server in _servers)
                {
                    Logger.WithLogSection(server.Name, () =>
                    {
                        loadBalancer.BringOffline(server, new StatusReporter(), settings, new CancellationToken());
                        foreach (var item in _remoteSequences)
                        {
                            Logger.WithLogSection(item.Name, () => { item.DryRun(); });
                        }
                        loadBalancer.BringOnline(server, new StatusReporter(), settings, new CancellationToken());
                    });
                }
            });
        }
        public override void Execute(IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            var configFilePath = Path.Combine(_configDirPath, _configName);
            var transformFilePath = Path.Combine(_configDirPath, _transformName);
            var backupPath = "";

            if(ConDepConfigBackupExist(_configDirPath, _configName))
            {
                Logger.Info("Using [{0}] as configuration file to transform", _configDirPath + CONDEP_CONFIG_EXTENSION);
                backupPath = Path.Combine(_configDirPath, _configName + CONDEP_CONFIG_EXTENSION);
            }
            else
            {
                BackupConfigFile(_configDirPath, _configName);
            }

            Logger.Info("Transforming [{0}] using [{1}]", configFilePath, transformFilePath);
            var trans = new SlowCheetah.Tasks.TransformXml
            {
                BuildEngine = new TransformConfigBuildEngine(),
                Source = string.IsNullOrWhiteSpace(backupPath) ? configFilePath : backupPath,
                Transform = transformFilePath,
                Destination = configFilePath
            };

            var success = trans.Execute();
            if(!success)
                throw new CondepWebConfigTransformException(string.Format("Failed to transform [{0}] file.", _configName));
        }
        public override void BringOnline(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            if (server.LoadBalancerState.KeepOffline)
                return;

            BringOnline(server, status, settings, _loadBalancer, token);
        }
示例#5
0
        public static ISerializeConfig<ConDepEnvConfig> ResolveConfigParser(ConDepSettings settings, out string filePath)
        {
            var searchDir = Path.GetDirectoryName(settings.Options.Assembly.Location);
            var searchPattern = string.Format("{0}.env.*", settings.Options.Environment);

            var configFiles = Directory.GetFiles(
                searchDir,
                searchPattern,
                SearchOption.TopDirectoryOnly
            );

            if (configFiles.Length == 0)
                throw new FileNotFoundException(string.Format("No envrionment configuration files found in {0}", searchDir));

            if (configFiles.Length > 1)
                throw new FileNotFoundException(string.Format("More than one envrionment configuration file found in {0} matching the serarch pattern {1}", searchDir, searchPattern));

            var file = new FileInfo(configFiles[0]);
            if (!SupportedFileExtensions.Exists(x => x.Equals(file.Extension, StringComparison.InvariantCultureIgnoreCase)))
                throw new FileNotFoundException(string.Format("Envrionment configuration file with extension {0} is not currently supported. Currently supported config file extensions are {1}", file.Extension, string.Join(", ", SupportedFileExtensions)));

            filePath = file.FullName;

            return ResolveConfigParser(filePath, settings.Options.CryptoKey);
        }
 public IEnumerable<Runbook> GetRunbooksToExecute(ConDepSettings settings)
 {
     var runbook = _runbookHandler.GetRunbook(settings);
     var dependantRunbooks =_runbookDependencyHandler.GetDependeciesForRunbook(runbook, settings);
     dependantRunbooks.Add(runbook);
     return dependantRunbooks;
 }
示例#7
0
        public static ISerializerConDepConfig ResolveConfigParser(ConDepSettings settings, out string filePath)
        {
            var searchDir     = Path.GetDirectoryName(settings.Options.Assembly.Location);
            var searchPattern = string.Format("{0}.env.*", settings.Options.Environment);

            var configFiles = Directory.GetFiles(
                searchDir,
                searchPattern,
                SearchOption.TopDirectoryOnly
                );

            if (configFiles.Length == 0)
            {
                throw new FileNotFoundException(string.Format("No envrionment configuration files found in {0}", searchDir));
            }

            if (configFiles.Length > 1)
            {
                throw new FileNotFoundException(string.Format("More than one envrionment configuration file found in {0} matching the serarch pattern {1}", searchDir, searchPattern));
            }

            var file = new FileInfo(configFiles[0]);

            if (!SupportedFileExtensions.Exists(x => x.Equals(file.Extension, StringComparison.InvariantCultureIgnoreCase)))
            {
                throw new FileNotFoundException(string.Format("Envrionment configuration file with extension {0} is not currently supported. Currently supported config file extensions are {1}", file.Extension, string.Join(", ", SupportedFileExtensions)));
            }

            filePath = file.FullName;

            return(ResolveConfigParser(filePath, settings.Options.CryptoKey));
        }
 public ConDepNoRunbookTierDefinedException(Runbook application, ConDepSettings settings)
     : base(string.Format("No Tiers defined for application {0}. You need to specify a tier using the {1} attribute on the {0} class. Tiers available in your configuration are {2}.",
         application.GetType().Name, 
         typeof(TierAttribute).Name, 
         string.Join(", ", settings.Config.Tiers.Select(x => x.Name))))
 {
 }
        public void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            var assemblyLocalDir = Path.GetDirectoryName(GetType().Assembly.Location);
            var assemblyRemoteDir = Path.Combine(server.GetServerInfo().TempFolderDos, "Assemblies");

            _filePublisher.PublishDirectory(assemblyLocalDir, assemblyRemoteDir, server, settings);

            var remoteAssemblyFileName = Path.Combine(Path.Combine(server.GetServerInfo().TempFolderPowerShell, "Assemblies"), Path.GetFileName(GetType().Assembly.Location));
            var remoteJsonAssembly = Path.Combine(Path.Combine(server.GetServerInfo().TempFolderPowerShell, "Assemblies"), "Newtonsoft.Json.dll");
            var typeName = GetType().FullName;
            var loggerTypeName = typeof (RemotePowerShellLogger).FullName;

            var parameters = GetPowerShellParameters(ConstructorArguments, GetType()).ToList();
            var scriptParams = string.Join(",", parameters.Select(x => "$" + x.Name));
            var argumentList = string.Join(",", GetType().GetConstructor(ConstructorArguments.Select(x => x.GetType()).ToArray()).GetParameters().Select(x => "$" + x.Name));
            var deserializeScript = GetDeserializationScript(GetType().GetConstructor(ConstructorArguments.Select(x => x.GetType()).ToArray()));

            var script = string.Format(@"
            Param({3})
            add-type -path {0}
            add-type -path {5}
            {4}
            $operation = new-object -typename {1} -ArgumentList {6}
            $logger = new-object -typename {2} -ArgumentList (Get-Host).UI
            $operation.Execute($logger)
            ", remoteAssemblyFileName, typeName, loggerTypeName, scriptParams, deserializeScript, remoteJsonAssembly, argumentList);

            _psExecutor.Execute(server, script, mod => mod.LoadConDepModule = false, parameters);
        }
示例#10
0
        private static void ValidateApplicationTier(Runbook runbook, ConDepSettings settings)
        {
            var hasTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Any();
            if (!hasTier) throw new ConDepNoRunbookTierDefinedException(runbook, settings);

            var hasSingleTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).SingleOrDefault() != null;
            if (!hasSingleTier) throw new ConDepNoRunbookTierDefinedException(String.Format("Multiple tiers defined for {0}. Only one tier is allowed by Artifact.", runbook.GetType().Name));
        }
示例#11
0
        public void Setup()
        {
            var tokenSource = new CancellationTokenSource();
            _token = tokenSource.Token;

            Logger.Initialize(CreateMemoryLogger());
            _settingsStopAfterMarkedServer = new ConDepSettings
            {
                Config =
                {
                    EnvironmentName = "bogus",
                    LoadBalancer = new LoadBalancerConfig
                    {
                        Name = "bogus"
                    }
                },
                Options =
                    {
                        StopAfterMarkedServer = true,
                        SuspendMode = LoadBalancerSuspendMethod.Graceful
                    }
            };

            _settingsContinueAfterMarkedServer = new ConDepSettings
            {
                Config =
                {
                    EnvironmentName = "bogus",
                    LoadBalancer = new LoadBalancerConfig
                    {
                        Name = "bogus"
                    }
                },
                Options =
                {
                    ContinueAfterMarkedServer = true,
                    SuspendMode = LoadBalancerSuspendMethod.Graceful
                }
            };

            _settingsDefault = new ConDepSettings
            {
                Config =
                {
                    EnvironmentName = "bogus",
                    LoadBalancer = new LoadBalancerConfig
                    {
                        Name = "bogus"
                    }
                },
                Options =
                {
                    SuspendMode = LoadBalancerSuspendMethod.Graceful
                }
            };
        }
        protected void BringOnline(ServerConfig server, IReportStatus status, ConDepSettings settings, ILoadBalance loadBalancer, CancellationToken token)
        {
            if (settings.Config.LoadBalancer == null) return;
            if (server.LoadBalancerState.CurrentState == LoadBalanceState.Online) return;

            Logger.WithLogSection(string.Format("Taking server [{0}] online in load balancer.", server.Name), () =>
            {
                loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm, status);
                server.LoadBalancerState.CurrentState = LoadBalanceState.Online;
            });
        }
        public override void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            var createFolderScript = string.Format(@"
            if(!(Test-Path ""{0}""))
            {{
            New-Item -ItemType directory -Path ""{0}""
            }}
            ", _path);

            var psExecutor = new PowerShellExecutor();
            psExecutor.Execute(server, createFolderScript);
        }
示例#14
0
        public virtual void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            foreach (var element in _sequence)
            {
                token.ThrowIfCancellationRequested();

                IExecuteRemotely elementToExecute = element;
                if (element is CompositeSequence)
                    elementToExecute.Execute(server, status, settings, token);
                else
                    Logger.WithLogSection(element.Name, () => elementToExecute.Execute(server, status, settings, token));
            }
        }
示例#15
0
        public Runbook GetRunbook(ConDepSettings settings)
        {
            if (!settings.Options.HasApplicationDefined()) throw new ConDepNoRunbookDefinedException();

            var assembly = settings.Options.Assembly;

            var type = assembly.GetTypes().SingleOrDefault(t => typeof(Runbook).IsAssignableFrom(t) && t.Name == settings.Options.Runbook);
            if (type == null)
            {
                throw new ConDepConfigurationTypeNotFoundException(string.Format("A class inheriting from [{0}] must be present in assembly [{1}] for ConDep to work. No calss with name [{2}] found in assembly. ", typeof(Runbook).FullName, assembly.FullName, settings.Options.Runbook));
            }
            return CreateRunbook(type);
        }
示例#16
0
        public static ConDepEnvConfig GetEnvConfig(ConDepSettings settings)
        {
            string envFilePath;
            var jsonConfigParser = new EnvConfigParser(ResolveConfigParser(settings, out envFilePath));

            var envConfig = jsonConfigParser.GetTypedEnvConfig(envFilePath);
            envConfig.EnvironmentName = settings.Options.Environment;

            if (settings.Options.BypassLB)
            {
                envConfig.LoadBalancer = null;
            }
            return envConfig;
        }
        public override void Configure(IOfferLocalOperations local, ConDepSettings settings)
        {
            local.HttpGet("http://www.con-dep.net");
            local.ToEachServer(server =>
                {
                    server
                        .Configure.IIS();

                    server
                        .Execute.PowerShell("ipconfig");
                }
            );
            local.HttpGet("http://blog.torresdal.net");
        }
 public override void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
 {
     switch (_commandType)
     {
         case CommandType.CmdLine:
             ExecuteCommand(_cmd, server);
             break;
         case CommandType.ScriptFile:
             ExecuteScriptFile(_scriptFile, server);
             break;
         default:
             throw new ConDepInvalidEnumValueException(_commandType);
     }
 }
示例#19
0
        public static ConDepEnvConfig GetEnvConfig(ConDepSettings settings)
        {
            string envFilePath;
            var    jsonConfigParser = new EnvConfigParser(ResolveConfigParser(settings, out envFilePath));

            var envConfig = jsonConfigParser.GetTypedEnvConfig(envFilePath, settings.Options.CryptoKey);

            envConfig.EnvironmentName = settings.Options.Environment;

            if (settings.Options.BypassLB)
            {
                envConfig.LoadBalancer = null;
            }
            return(envConfig);
        }
        public override void Execute(IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            try
            {
                if(Directory.Exists(_preCompileOutputpath))
                    Directory.Delete(_preCompileOutputpath, true);

                _buildManager.PrecompileApplication(new PreCompileCallback());
            }
            catch (Exception ex)
            {
                Logger.Error(ex.Message);
                throw;
            }
        }
 public void Setup()
 {
     var tokenSource = new CancellationTokenSource();
     _token = tokenSource.Token;
     _buildManager = new Mock<IWrapClientBuildManager>();
     _buildManager.Setup(x => x.PrecompileApplication(It.IsAny<PreCompileCallback>()));
     _validWebAppPath = Path.GetTempPath();
     _validOutputPath = Environment.CurrentDirectory;
     _settingsDefault = new ConDepSettings
     {
         Options =
         {
             SuspendMode = LoadBalancerSuspendMethod.Graceful
         }
     };
 }
        private IEnumerable<IHarvestServerInfo> GetHarvesters(ConDepSettings settings)
        {
            if (settings.Options.SkipHarvesting)
            {
                return GetMandatoryHarvesters(GetType().Assembly.GetTypes());
            }

            var internalHarvesters = GetHarvesters(GetType().Assembly.GetTypes());
            if (settings.Options.Assembly == null)
            {
                return internalHarvesters;
            }

            var externalHarvesters = GetHarvesters(settings.Options.Assembly.GetTypes());
            return internalHarvesters.Concat(externalHarvesters);
        }
示例#23
0
        public override Result Execute(IOfferRemoteOperations remote, ServerConfig server, ConDepSettings settings, CancellationToken token)
        {
            token.ThrowIfCancellationRequested();

            Logger.WithLogSection(string.Format("Stopping ConDepNode on server {0}", server.Name), () =>
            {
                var executor = new PowerShellExecutor();
                executor.Execute(server, "Stop-ConDepNode", mod =>
                {
                    mod.LoadConDepModule = false;
                    mod.LoadConDepNodeModule = true;
                }, logOutput: false);
            });

            return Result.SuccessUnChanged();
        }
        public void Setup()
        {
            var tokenSource = new CancellationTokenSource();
            _token = tokenSource.Token;

            Logger.Initialize(CreateMemoryLogger());
            //new Logger().AutoResolveLogger();
            FilesToDeleteAfterTest = new List<string>();
            _settingsDefault = new ConDepSettings
            {
                Options =
                {
                    SuspendMode = LoadBalancerSuspendMethod.Graceful
                }
            };
        }
        public override void Configure(IOfferLocalOperations onLocalMachine, ConDepSettings settings)
        {
            onLocalMachine.ToEachServer(server => {

                server
                    .Configure
                        .OnlyIf(x => x.OperatingSystem.Name.StartsWith("Windows"))
                            .IIS();

                server
                    .OnlyIf(x => x.OperatingSystem.Name.StartsWith("Windows"))
                    .Execute.PowerShell("write-host ''");

            }
            );
        }
示例#26
0
        public static ConDepEnvConfig GetEnvConfig(ConDepSettings settings)
        {
            var envFileName = string.Format("{0}.Env.json", settings.Options.Environment);
            var envFilePath = Path.Combine(Path.GetDirectoryName(settings.Options.Assembly.Location), envFileName);

            var jsonConfigParser = new EnvConfigParser();
            var envConfig        = jsonConfigParser.GetTypedEnvConfig(envFilePath, settings.Options.CryptoKey);

            envConfig.EnvironmentName = settings.Options.Environment;

            if (settings.Options.BypassLB)
            {
                envConfig.LoadBalancer = null;
            }
            return(envConfig);
        }
示例#27
0
        public void Setup()
        {
            _tierSettings = new ConDepSettings
            {
                Config =
                {
                    Tiers = new[]
                    {
                        new TiersConfig
                        {
                            Name = Tier.Web.ToString(),
                            Servers = new[]
                            {
                                new ServerConfig
                                {
                                    Name = "TierServer1"
                                },
                                new ServerConfig
                                {
                                    Name = "TierServer2"
                                }
                            }
                        }
                    }
                },
                Options = { Assembly = typeof(MyArtifactWithTierTag).Assembly, Runbook = "MyArtifactWithTierTag" }
            };

            _serverSettings = new ConDepSettings
            {
                Config =
                {
                    Servers = new[]
                    {
                        new ServerConfig
                        {
                            Name = "Server1"
                        },
                        new ServerConfig
                        {
                            Name = "Server2"
                        }
                    }
                },
                Options = { Assembly = typeof(MyArtifactWithTierTag).Assembly, Runbook = "MyArtifactWithTierTag" }
            };
        }
        public void Setup()
        {
            var app = new OnlyIfTestApp();

            var config = new ConDepEnvConfig { EnvironmentName = "bogusEnv" };
            var server = new ServerConfig { Name = "bogusHost" };
            config.Servers = new[] { server };

            _sequenceManager = new ExecutionSequenceManager(config.Servers, new DefaultLoadBalancer());

            var settings = new ConDepSettings { Config = config };

            var local = new LocalOperationsBuilder(_sequenceManager.NewLocalSequence("Test"));
            app.Configure(local, settings);

            _serverInfo = new ServerInfo {OperatingSystem = new OperatingSystemInfo {Name = "Windows Server 2012"}};
        }
示例#29
0
        public IEnumerable<ServerConfig> GetServers(Runbook runbook, ConDepSettings settings)
        {
            if (settings.Config.UsingTiers)
            {
                ValidateApplicationTier(runbook, settings);

                var tier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Single() as TierAttribute;
                if (!settings.Config.Tiers.Exists(tier.TierName))
                {
                    throw new ConDepTierDoesNotExistInConfigException(string.Format("Tier {0} does not exist in {1}.env.config", tier.TierName, settings.Options.Environment));
                }
                return
                    settings.Config.Tiers.Single(x => x.Name.Equals(tier.TierName, StringComparison.OrdinalIgnoreCase))
                        .Servers;
            }
            return settings.Config.Servers;
        }
 public override void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
 {
     Logger.WithLogSection(Name, () =>
     {
         if (ConditionFulfilled(server))
         {
             foreach (var element in _sequence)
             {
                 IExecuteRemotely elementToExecute = element;
                 Logger.WithLogSection("Condition True, executing " + element.Name, () => elementToExecute.Execute(server, status, settings, token));
             }
         }
         else
         {
             Logger.Info("Condition evaluated to false. Will not execute.");
         }
     });
 }
        public void TestThatExecutionSequenceIsValid()
        {
            var config = new ConDepEnvConfig {EnvironmentName = "bogusEnv"};
            var server = new ServerConfig { Name = "jat-web03" };
            config.Servers = new[] { server };

            var sequenceManager = new ExecutionSequenceManager(config.Servers, new DefaultLoadBalancer());

            var settings = new ConDepSettings();
            settings.Config = config;

            var local = new LocalOperationsBuilder(sequenceManager.NewLocalSequence("Test"));
            //Configure.LocalOperations = local;
            _app.Configure(local, settings);

            var notification = new Notification();
            Assert.That(sequenceManager.IsValid(notification));
        }
        public virtual IEnumerable<ServerConfig> GetServerExecutionOrder(IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            var servers = settings.Config.Servers;
            if (settings.Options.StopAfterMarkedServer)
            {
                return new[] { servers.SingleOrDefault(x => x.StopServer) ?? servers.First() };
            }

            if (settings.Options.ContinueAfterMarkedServer)
            {
                var markedServer = servers.SingleOrDefault(x => x.StopServer) ?? servers.First();
                BringOnline(markedServer, status, settings, token);

                return servers.Count == 1 ? new List<ServerConfig>() : servers.Except(new[] { markedServer });
            }

            return servers;
        }
        public override void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
        {
            _api = new Api(new ConDepNodeUrl(server, settings), server.DeploymentUser.UserName, server.DeploymentUser.Password, server.Node.TimeoutInSeconds.Value * 1000);
            var result = _api.SyncDir(_srcDir, _dstDir);

            if (result == null) return;

            if(result.Log.Count > 0)
            {
                foreach (var entry in result.Log)
                {
                    Logger.Info(entry);
                }
            }
            else
            {
                Logger.Info("Nothing to deploy. Everything is in sync.");
            }
        }