public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions conDepOptions)
{
WebDeployOptions options = null;
try
{
Logger.LogSectionStart(_provider.GetType().Name);
_webDeploy.Sync(_provider, server, _provider.ContinueOnError, status, OnWebDeployTraceMessage);
}
catch (Exception ex)
{
HandleSyncException(status, ex);
}
finally
{
Logger.LogSectionEnd(_provider.GetType().Name);
if (options != null && options.DestBaseOptions != null)
{
options.DestBaseOptions.Trace -= OnWebDeployTraceMessage;
}
if (options != null && options.SourceBaseOptions != null)
{
options.SourceBaseOptions.Trace -= OnWebDeployTraceMessage;
}
}
return(status);
}
private void HandleSyncException(IReportStatus status, Exception ex)
{
status.AddUntrappedException(ex);
var message = GetCompleteExceptionMessage(ex);
Logger.Error(message);
}
private void StartrxnProcessors(IReportStatus logger, IContainer container, Type[] events, IScheduler eventDelivery)
{
var startedProcessors = new List <dynamic>();
foreach (var @event in events)
{
try
{
//now we create an rxnProcessor of each IRxn discovered, then ask the container
//for any interfaces which implement them.
var processorForEvent = typeof(IRxnProcessor <>).MakeGenericType(@event);
var allProcessorsForEventType = typeof(IEnumerable <>).MakeGenericType(processorForEvent);
var allProcessors = ((IEnumerable <dynamic>)container.Resolve(allProcessorsForEventType)).ToArray();
Func <string, Rxns.Interfaces.IReactor <IRxn> > getReactorByName = reactorName => container.Resolve <IManageReactors>().StartReactor(reactorName).Reactor;
//now register any processors found with the subscription to the events they are interested in
var distinctProcessors = allProcessors.Distinct().ToArray();
foreach (var p in distinctProcessors.Except(startedProcessors))
{
var reactor = RxnCreator.GetReactorFor((object)p, getReactorByName);
//this method will hookup ALL process methods of a processor in one call
reactor.Connect((object)p, eventDelivery);
}
startedProcessors.AddRange(distinctProcessors); //so we need to keep a list processors we see so we dont attach them twice
}
catch (Exception e)
{
logger.OnError(e);
}
}
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart(_compositeName);
foreach (var element in _sequence)
{
if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
}
if (status.HasErrors)
return status;
}
}
finally
{
Logger.LogSectionEnd(_compositeName);
}
return status;
}
public override void BringOnline(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
if (server.LoadBalancerState.KeepOffline)
return;
BringOnline(server, status, settings, _loadBalancer, token);
}
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");
var publisher = new FilePublisher();
publisher.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 psExecutor = new PowerShellExecutor(server);
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(script, parameters);
}
private void HandleSyncException(IReportStatus status, Exception ex)
{
status.AddUntrappedException(ex);
var message = GetCompleteExceptionMessage(ex);
Logger.Error(message);
}
public override IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
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));
return status;
}
public IReportStatus Execute(IReportStatus status, ConDepOptions options)
{
foreach (var server in _servers)
{
try
{
Logger.LogSectionStart(server.Name);
if (!options.WebDeployExist)
{
using (new WebDeployDeployer(server))
{
ExecuteOnServer(server, status, options);
}
}
else
{
ExecuteOnServer(server, status, options);
}
}
finally
{
Logger.LogSectionEnd(server.Name);
}
}
return status;
}
public void BringOffline(string serverName, string farm, LoadBalancerSuspendMethod suspendMethod, IReportStatus status)
{
SessionToken token = null;
try
{
token = LogIn();
var deviceId = GetDeviceId(token);
var server = GetServer(serverName, farm, token, deviceId);
var suspend = new suspendServerfarmRserver
{
deviceID = deviceId,
reason = "ConDep deployment",
sessionToken = token,
suspendState = GetSuspendState(suspendMethod),
rserver = server
};
_proxy.suspendServerfarmRserver(new suspendServerfarmRserverRequest { suspendServerfarmRserver = suspend});
}
finally
{
if (_loggedIn)
{
LogOut(token);
}
}
}
public void BringOnline(string serverName, string farm, IReportStatus status)
{
SessionToken token = null;
try
{
token = LogIn();
var deviceId = GetDeviceId(token);
var server = GetServer(serverName, farm, token, deviceId);
var activate = new activateServerfarmRserver
{
deviceID = deviceId,
reason = "ConDep deployment",
sessionToken = token,
rserver = server
};
_proxy.activateServerfarmRserver(new activateServerfarmRserverRequest { activateServerfarmRserver = activate});
}
finally
{
if (_loggedIn)
{
_proxy.logout(new logoutRequest { logout = new logout { sessionToken = token } });
}
}
}
private IReportStatus ExecuteWithSticky(ConDepOptions options, IReportStatus status)
{
var servers = _servers.ToList();
ServerConfig manuelTestServer;
if (options.StopAfterMarkedServer)
{
manuelTestServer = servers.SingleOrDefault(x => x.StopServer) ?? servers.First();
return(ExecuteOnServer(manuelTestServer, status, options, _loadBalancer, true, false));
}
if (options.ContinueAfterMarkedServer)
{
manuelTestServer = servers.SingleOrDefault(x => x.StopServer) ?? servers.First();
_loadBalancer.BringOnline(manuelTestServer.Name, manuelTestServer.LoadBalancerFarm, status);
servers.Remove(manuelTestServer);
}
foreach (var server in servers)
{
ExecuteOnServer(server, status, options, _loadBalancer, true, true);
if (status.HasErrors)
{
return(status);
}
}
return(status);
}
private void StartReactions(IReportStatus logger, IContainer container, Type[] events, IScheduler eventDelivery)
{
foreach (var @event in events)
{
try
{
var processorForEvent = typeof(IReactTo <>).MakeGenericType(@event);
var allProcessorsForEventType = typeof(IEnumerable <>).MakeGenericType(processorForEvent);
var allProcessors = (IEnumerable <dynamic>)container.Resolve(allProcessorsForEventType);
Func <string, Rxns.Interfaces.IReactor <IRxn> > getReactorByName = reactorName => container.Resolve <IManageReactors>().StartReactor(reactorName).Reactor;
//now attach any processors found with the subscription to the events they are interested in
foreach (object reaction in allProcessors.Distinct())
{
var reactor = RxnCreator.GetReactorFor(reaction, getReactorByName);
reactor.Connect((IReactTo <IRxn>)reaction, eventDelivery);
}
}
catch (Exception e)
{
logger.OnError(e);
}
}
}
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);
}
public IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
try
{
Logger.LogSectionStart(_name);
foreach (var element in _sequence)
{
if (element is LocalOperation)
{
Logger.LogSectionStart(element.GetType().Name);
((LocalOperation)element).Execute(status, config, options);
Logger.LogSectionEnd(element.GetType().Name);
}
else if (element is RemoteSequence)
{
((RemoteSequence)element).Execute(status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
{
return(status);
}
}
return(status);
}
finally
{
Logger.LogSectionEnd(_name);
}
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart(_compositeName);
foreach (var element in _sequence)
{
if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
}
if (status.HasErrors)
{
return(status);
}
}
}
finally
{
Logger.LogSectionEnd(_compositeName);
}
return(status);
}
public void BringOnline(string serverName, string farm, IReportStatus status)
{
SessionToken token = null;
try
{
token = LogIn();
var deviceIds = GetDeviceIds(token);
DeviceID deviceId;
var server = GetServer(serverName, farm, token, deviceIds, out deviceId);
var activate = new activateServerfarmRserver
{
deviceID = deviceId,
reason = "ConDep deployment",
sessionToken = token,
rserver = server
};
_proxy.activateServerfarmRserver(new activateServerfarmRserverRequest {
activateServerfarmRserver = activate
});
}
finally
{
if (_loggedIn)
{
_proxy.logout(new logoutRequest {
logout = new logout {
sessionToken = token
}
});
}
}
}
public void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
token.ThrowIfCancellationRequested();
Logger.WithLogSection("Pre-Operations", () =>
{
server.GetServerInfo().TempFolderDos = string.Format(TMP_FOLDER, "%windir%");
Logger.Info(string.Format("Dos temp folder is {0}", server.GetServerInfo().TempFolderDos));
server.GetServerInfo().TempFolderPowerShell = string.Format(TMP_FOLDER, "$env:windir");
Logger.Info(string.Format("PowerShell temp folder is {0}", server.GetServerInfo().TempFolderPowerShell));
//var scriptPublisher = new PowerShellScriptPublisher(settings);
//Logger.WithLogSection("Copying internal ConDep scripts", () => scriptPublisher.PublishDslScripts(server));
PublishConDepNode(server, settings);
var scriptPublisher = new PowerShellScriptPublisher(settings);
Logger.WithLogSection("Copying external scripts", () => scriptPublisher.PublishScripts(server));
Logger.WithLogSection("Copying remote helper assembly", () => scriptPublisher.PublishRemoteHelperAssembly(server));
InstallChocolatey(server, settings);
//Logger.WithLogSection("Copying external scripts", () => scriptPublisher.PublishExternalScripts(server));
});
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart("Infrastructure");
foreach (var element in _sequence)
{
if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
if (status.HasErrors)
return status;
}
else if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
return status;
}
}
finally
{
Logger.LogSectionEnd("Infrastructure");
}
return status;
}
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 Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
_executor.Execute(server, "Stop-ConDepNode", mod =>
{
mod.LoadConDepNodeModule = true;
mod.LoadConDepModule = false;
}, logOutput: false);
}
public static IEnumerable <T> DisposedBy <T>(this IEnumerable <T> objs, IReportStatus reporter) where T : IDisposable
{
foreach (var o in objs)
{
reporter.OnDispose(o);
}
return(objs);
}
public static IDisposable ReportsOn(this ReportsStatus context, IReportStatus another)
{
var resources = new CompositeDisposable();
another.Errors.Subscribe(context.ReportExceptions).DisposedBy(resources);
another.Information.Subscribe(context.ReportInformation).DisposedBy(resources);
return(resources);
}
public void Execute(IReportStatus status, ConDepSettings settings, CancellationToken token)
{
foreach (var element in _sequence)
{
token.ThrowIfCancellationRequested();
IExecuteLocally internalElement = element;
Logger.WithLogSection(internalElement.Name, () => element.Execute(status, settings, token));
}
}
public static T[] DisposedBy <T>(this T[] objs, IReportStatus reporter) where T : IDisposable
{
foreach (var obj in objs)
{
reporter.OnDispose(obj);
}
return(objs);
}
public override void BringOnline(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
if (server.LoadBalancerState.KeepOffline)
{
return;
}
BringOnline(server, status, settings, _loadBalancer, token);
}
public IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
foreach (var localSequence in _sequence)
{
localSequence.Execute(status, config, options);
if (status.HasErrors)
return status;
}
return status;
}
private void Execute(LoadBalanceState state, string serverName, IReportStatus status)
{
//var provider = new ApplicationRequestRoutingProvider(state, serverName);
//var sequence = new ExecutionSequenceManager();
//var webDeploy = new WebDeployOperator();
//var server = new RemoteCompositeBuilder(new RemoteSequenceManager(new[] { _server }, null), new[] { _server }, webDeploy);
//provider.Configure(server);
//sequence.Execute(status);
}
private void Execute(LoadBalanceState state, string serverName, IReportStatus status)
{
//var provider = new ApplicationRequestRoutingProvider(state, serverName);
//var sequence = new ExecutionSequenceManager();
//var webDeploy = new WebDeployOperator();
//var server = new RemoteCompositeBuilder(new RemoteSequenceManager(new[] { _server }, null), new[] { _server }, webDeploy);
//provider.Configure(server);
//sequence.Execute(status);
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
bool sectionAdded = false;
try
{
if (ConDepGlobals.ServersWithPreOps.ContainsKey(server.Name))
{
return(status);
}
ConDepGlobals.ServersWithPreOps.Add(server.Name, server);
Logger.LogSectionStart("Pre-Operations");
sectionAdded = true;
var remotePreOps = new PreRemoteOps(server, this, options, _webDeploy);
remotePreOps.Configure();
remotePreOps.Execute(status);
foreach (var element in _sequence)
{
if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
if (status.HasErrors)
{
return(status);
}
}
else if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
{
return(status);
}
}
return(status);
}
finally
{
if (sectionAdded)
{
Logger.LogSectionEnd("Pre-Operations");
}
}
}
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;
});
}
/// <summary>
/// Reports any exceptions that occour through your reporter
/// </summary>
/// <param name="reporter">The person who will catch the exception</param>
/// <param name="work">The work todo</param>
public static void TryCatch(this IReportStatus reporter, Action work)
{
try
{
work.Invoke();
}
catch (Exception e)
{
reporter.OnError(e);
}
}
public void Run(IReportStatus logger, IContainer container)
{
//here we look for all the IRxns registered, along with the interfaces they implement that also
//can be considered IRxns.
var events = container.ComponentRegistry.Registrations.Where(r => typeof(IRxn).IsAssignableFrom(r.Activator.LimitType) && !r.Activator.LimitType.IsAbstract() && !r.Activator.LimitType.GetTypeInfo().IsGenericTypeDefinition).Select(r => r.Activator.LimitType).ToArray();
events = events.Concat(events.SelectMany(e => e.GetInterfaces().Where(ee => TypeExtensions.IsAssignableTo <IRxn>(ee)))).Distinct().ToArray();
StartEventPublishers(logger, container, events);
StartrxnProcessors(logger, container, events, RxnSchedulers.TaskPool);
StartReactions(logger, container, new[] { typeof(IRxn) }, RxnSchedulers.TaskPool); //only supports IRxn atm
}
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);
}
/// <summary>
/// Same are trycatch
/// Reports any exceptions that occour through your reporter
/// </summary>
/// <param name="reporter">The person who will catch the exception</param>
/// <param name="work">The work todo</param>
public static T ReportExceptions <T>(this IReportStatus reporter, Func <T> work)
{
try
{
return(work.Invoke());
}
catch (Exception e)
{
reporter.OnError(e);
return(default(T));
}
}
/// <summary>
/// Same are trycatch
/// Reports any exceptions that occour through your reporter
/// </summary>
/// <param name="reporter">The person who will catch the exception</param>
/// <param name="work">The work todo</param>
public static dynamic ReportExceptions(this IReportStatus reporter, Func <dynamic> work)
{
try
{
return(work.Invoke());
}
catch (Exception e)
{
reporter.OnError(e);
return(null);
}
}
public IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
foreach (var localSequence in _sequence)
{
localSequence.Execute(status, config, options);
if (status.HasErrors)
{
return(status);
}
}
return(status);
}
public IReportStatus Execute(IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart("Post-Operations");
var postRemoteOp = new PostRemoteOps();
postRemoteOp.Configure(this);
foreach (var server in ConDepGlobals.ServersWithPreOps.Values)
{
foreach (var element in _sequence)
{
if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
if (status.HasErrors)
{
return(status);
}
}
else if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
{
return(status);
}
}
}
}
finally
{
try
{
WebDeployDeployer.DisposeAll();
}
catch (Exception ex)
{
Logger.Warn("Unable to remove Web Deploy from server(s).", ex);
}
Logger.LogSectionEnd("Post-Operations");
}
return(status);
}
private void ExecuteLocalOperations(IReportStatus status, ConDepSettings settings, CancellationToken token)
{
Logger.WithLogSection("Local Operations", () =>
{
foreach (var localSequence in _localSequences)
{
token.ThrowIfCancellationRequested();
LocalSequence sequence = localSequence;
Logger.WithLogSection(localSequence.Name, () => sequence.Execute(status, settings, token));
}
});
}
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));
}
}
public void BringOffline(string serverName, string farm, LoadBalancerSuspendMethod suspendMethod, IReportStatus status)
{
var result = ChangeServerState(serverName, farm, ServerState.Offline);
if (!result.IsSuccessStatusCode)
throw new ConDepLoadBalancerException(string.Format("Failed to take server {0} offline in loadbalancer. Returned status code was {1} with reason: {2}", serverName, result.StatusCode, result.ReasonPhrase));
Logger.Verbose(string.Format("Waiting {0} seconds to give load balancer a chance to set server i maintenance mode.", _waitTimeInSecondsAfterSettingServerStateToOffline));
Thread.Sleep(_waitTimeInSecondsAfterSettingServerStateToOffline * 1000);
Logger.Verbose("Waiting for server connections to drain.");
WaitForCurrentConnectionsToDrain(farm, serverName, _snmpEndpoint, _snmpPort, _snmpCommunity, DateTime.Now.AddSeconds(_config.TimeoutInSeconds));
}
private static void ExecutePostOps(ConDepSettings conDepSettings, IReportStatus status, CancellationToken token)
{
foreach (var server in conDepSettings.Config.Servers)
{
//Todo: This will not work with ConDep server. After first run, this key will always exist.
if (ConDepGlobals.ServersWithPreOps.ContainsKey(server.Name))
{
var remotePostOps = new PostRemoteOps();
remotePostOps.Execute(server, status, conDepSettings, token);
ConDepGlobals.ServersWithPreOps.Remove(server.Name);
}
}
}
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(server);
psExecutor.Execute(createFolderScript);
}
public void Execute(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
token.ThrowIfCancellationRequested();
Logger.WithLogSection(string.Format("Stopping ConDepNode on server {0}", server.Name), () =>
{
var executor = new PowerShellExecutor(server)
{
LoadConDepModule = false, LoadConDepNodeModule = true
};
executor.Execute("Stop-ConDepNode", logOutput: false);
});
}
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);
}
}
public IReportStatus Execute(IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart("Post-Operations");
var postRemoteOp = new PostRemoteOps();
postRemoteOp.Configure(this);
foreach (var server in ConDepGlobals.ServersWithPreOps.Values)
{
foreach (var element in _sequence)
{
if (element is IOperateRemote)
{
((IOperateRemote) element).Execute(server, status, options);
if (status.HasErrors)
return status;
}
else if (element is CompositeSequence)
{
((CompositeSequence) element).Execute(server, status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
return status;
}
}
}
finally
{
try
{
WebDeployDeployer.DisposeAll();
}
catch(Exception ex)
{
Logger.Warn("Unable to remove Web Deploy from server(s).", ex);
}
Logger.LogSectionEnd("Post-Operations");
}
return status;
}
private void TempInstallWebDeploy(IReportStatus status)
{
if (!_options.WebDeployExist)
{
Logger.LogSectionStart("Deploying Web Deploy");
try
{
WebDeployDeployer.DeployTo(_server);
}
finally
{
Logger.LogSectionEnd("Deploying Web Deploy");
}
}
}
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 override IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
try
{
if(Directory.Exists(_preCompileOutputpath))
Directory.Delete(_preCompileOutputpath, true);
_buildManager.PrecompileApplication(new PreCompileCallback());
}
catch (Exception ex)
{
Logger.Error(ex.Message);
throw;
}
return status;
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
bool sectionAdded = false;
try
{
if (ConDepGlobals.ServersWithPreOps.ContainsKey(server.Name))
return status;
ConDepGlobals.ServersWithPreOps.Add(server.Name, server);
Logger.LogSectionStart("Pre-Operations");
sectionAdded = true;
var remotePreOps = new PreRemoteOps(server, this, options, _webDeploy);
remotePreOps.Configure();
remotePreOps.Execute(status);
foreach (var element in _sequence)
{
if (element is IOperateRemote)
{
((IOperateRemote)element).Execute(server, status, options);
if (status.HasErrors)
return status;
}
else if (element is CompositeSequence)
{
((CompositeSequence)element).Execute(server, status, options);
}
else
{
throw new NotSupportedException();
}
if (status.HasErrors)
return status;
}
return status;
}
finally
{
if(sectionAdded)
{
Logger.LogSectionEnd("Pre-Operations");
}
}
}
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)
{
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 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.");
}
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart("Infrastructure");
foreach (var element in _sequence)
{
element.Execute(server, status, options);
if (status.HasErrors)
return status;
}
}
finally
{
Logger.LogSectionEnd("Infrastructure");
}
return status;
}
public override void Execute(IReportStatus status, ConDepSettings settings, CancellationToken token)
{
Thread.Sleep(1000);
var webRequest = System.Net.WebRequest.Create(_url);
webRequest.Method = "GET";
webRequest.ContentLength = 0;
webRequest.ContentType = "application/x-www-form-urlencoded";
ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
HttpStatusCode statusCode = ((HttpWebResponse)webRequest.GetResponse()).StatusCode;
if (statusCode == HttpStatusCode.OK)
{
Logger.Info("HTTP {0} Succeeded: {1}", "GET", _url);
}
else
{
throw new WebException(string.Format("GET request did not return with 200 (OK), but {0} ({1})", (int)statusCode, statusCode));
}
}
public IReportStatus Execute(ServerConfig server, IReportStatus status, ConDepOptions conDepOptions)
{
WebDeployOptions options = null;
try
{
Logger.LogSectionStart(_provider.GetType().Name);
_webDeploy.Sync(_provider, server, _provider.ContinueOnError, status, OnWebDeployTraceMessage);
}
catch (Exception ex)
{
HandleSyncException(status, ex);
}
finally
{
Logger.LogSectionEnd(_provider.GetType().Name);
if (options != null && options.DestBaseOptions != null) options.DestBaseOptions.Trace -= OnWebDeployTraceMessage;
if (options != null && options.SourceBaseOptions != null) options.SourceBaseOptions.Trace -= OnWebDeployTraceMessage;
}
return status;
}
public override 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();
if (servers.Count == 1)
{
BringOnline(markedServer, status, settings, token);
return new List<ServerConfig>();
}
markedServer.LoadBalancerState.PreventDeployment = true;
}
return servers;
}
public override IReportStatus Execute(IReportStatus status, ConDepConfig config, ConDepOptions options)
{
var webRequest = System.Net.WebRequest.Create(_url);
webRequest.Method = _method;
webRequest.ContentLength = 0;
webRequest.ContentType = "application/x-www-form-urlencoded";
ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
HttpStatusCode statusCode = ((HttpWebResponse)webRequest.GetResponse()).StatusCode;
if (statusCode == HttpStatusCode.OK)
{
Logger.Info("HTTP {0} Succeeded: {1}", _method.ToUpper(), _url);
}
else
{
Logger.Error("HTTP {0} Failed with Status {1}: {2}", _method.ToUpper(), statusCode, _url);
}
return status;
}
public IReportStatus Execute(IReportStatus status, ConDepOptions options)
{
try
{
Logger.LogSectionStart("Remote Operations");
switch (_loadBalancer.Mode)
{
case LbMode.Sticky:
return ExecuteWithSticky(options, status);
case LbMode.RoundRobin:
return ExecuteWithRoundRobin(options, status);
default:
throw new ConDepLoadBalancerException(string.Format("Load Balancer mode [{0}] not supported.",
_loadBalancer.Mode));
}
}
finally
{
Logger.LogSectionEnd("Remote Operations");
}
}
public override void BringOffline(ServerConfig server, IReportStatus status, ConDepSettings settings, CancellationToken token)
{
var servers = _servers.ToList();
var roundRobinMaxOfflineServers = (int)Math.Ceiling(((double)servers.Count) / 2);
var activeServerIndex = _servers.ToList().IndexOf(server);
if (settings.Options.StopAfterMarkedServer)
{
var manuelTestServer = servers.SingleOrDefault(x => x.StopServer) ?? servers.First();
BringOffline(manuelTestServer, status, settings, _loadBalancer, token);
return;
}
if (activeServerIndex == roundRobinMaxOfflineServers)
{
TurnRoundRobinServersAround(servers, settings, token, roundRobinMaxOfflineServers, status);
}
if (server.LoadBalancerState.PreventDeployment) return;
if (server.LoadBalancerState.CurrentState == LoadBalanceState.Offline)
return;
if (settings.Options.ContinueAfterMarkedServer)
{
BringOffline(server, status, settings, _loadBalancer, token);
server.LoadBalancerState.KeepOffline = true;
return;
}
if (_servers.Count() == 1)
{
BringOffline(server, status, settings, _loadBalancer, token);
return;
}
BringOffline(server, status, settings, _loadBalancer, token);
server.LoadBalancerState.KeepOffline = true;
}
