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);
}
private bool ConditionFulfilled(ServerConfig server)
{
if (string.IsNullOrEmpty(_conditionScript))
{
return _condition(server.GetServerInfo()) == _expectedConditionResult;
}
else
{
var psExecutor = new PowerShellExecutor();
var result = psExecutor.Execute(server, _conditionScript);
return result.First().ToString() == "True";
}
}
public override Result Execute(IOfferRemoteOperations remote, ServerConfig server, 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));
PublishConDepNode(server, settings);
var scriptPublisher = new PowerShellScriptPublisher(settings, server);
Logger.WithLogSection("Copying external scripts", () => scriptPublisher.PublishScripts());
Logger.WithLogSection("Copying remote helper assembly", () => scriptPublisher.PublishRemoteHelperAssembly());
InstallChocolatey(server, settings);
});
return Result.SuccessUnChanged();
}
public void Harvest(ServerConfig server)
{
var result = _executor.Execute(server, @"$regKeys = @(
""HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Client"",
""HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full"",
""HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.5"",
""HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.0"",
""HKLM:\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727"",
""HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v1.1.4322""
)
$result = @()
foreach($regKeyPath in $regKeys) {
if(test-path $regKeyPath) {
$regKey = Get-Item $regKeyPath
$installed = $regKey.GetValue(""Install"")
if($installed) {
$dotNetVersion = @{}
$dotNetVersion.Installed = $installed
$dotNetVersion.Version = $regKey.GetValue(""Version"")
$dotNetVersion.ServicePack = $regKey.GetValue(""SP"")
$dotNetVersion.Release = $regKey.GetValue(""Release"")
$dotNetVersion.TargetVersion = $regKey.GetValue(""TargetVersion"")
$dotNetVersion.Client = $regKey.Name.ToLower().EndsWith(""client"")
$dotNetVersion.Full = $regKey.Name.ToLower().EndsWith(""full"")
$result += ,@($dotNetVersion)
}
}
}
return $result", mod => mod.LoadConDepModule = false, logOutput: false);
foreach (var element in result)
{
server.GetServerInfo().DotNetFrameworks.Add(element);
}
}
public RemoteScriptFolders(ServerConfig server)
{
var serverInfo = server.GetServerInfo();
PSTempFolder = string.IsNullOrWhiteSpace(serverInfo.TempFolderPowerShell) ? string.Empty : serverInfo.TempFolderPowerShell;
NodeScriptFolder = serverInfo.ConDepNodeScriptsFolder;
ConDepScriptFolder = serverInfo.ConDepScriptsFolder;
}
private void PublishConDepNode(ServerConfig server, ConDepSettings settings)
{
Logger.WithLogSection("Validating ConDepNode", () =>
{
string path;
var executionPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "ConDepNode.exe");
if (!File.Exists(executionPath))
{
var currentPath = Path.Combine(Directory.GetCurrentDirectory(), "ConDepNode.exe");
if (!File.Exists(currentPath))
{
throw new FileNotFoundException("Could not find ConDepNode.exe. Paths tried: \n" +
executionPath + "\n" + currentPath);
}
path = currentPath;
}
else
{
path = executionPath;
}
var nodeUrl = new ConDepNodeUrl(server);
var nodePublisher = new ConDepNodePublisher(path, Path.Combine(server.GetServerInfo().OperatingSystem.ProgramFilesFolder, "ConDepNode", Path.GetFileName(path)), nodeUrl, new PowerShellExecutor());
nodePublisher.Execute(server);
if (!nodePublisher.ValidateNode(nodeUrl, server.DeploymentUser.UserName, server.DeploymentUser.Password, server))
{
throw new ConDepNodeValidationException("Unable to make contact with ConDep Node or return content from API.");
}
Logger.Info(string.Format("ConDep Node successfully validated on {0}", server.Name));
Logger.Info(string.Format("Node listening on {0}", nodeUrl.ListenUrl));
});
}
public void Harvest(ServerConfig server)
{
var networkInfo = @"$result = @()
$networkInterfaces = Get-WmiObject win32_networkadapterconfiguration | where { $_.IPEnabled }
foreach($interface in $networkInterfaces) {
$ifaceInfo = @{}
$ifaceInfo.IPAddresses = $interface.IPAddress
$ifaceInfo.IPSubnets = $interface.IPSubnet
$ifaceInfo.Description = $interface.Description
$ifaceInfo.DefaultGateways = $interface.DefaultIPGateway
$ifaceInfo.DHCPEnabled = $interface.DHCPEnabled
$ifaceInfo.DNSDomain = $interface.DNSDomain
$ifaceInfo.DNSHostName = $interface.DNSHostName
$ifaceInfo.Index = $interface.Index
$ifaceInfo.InterfaceIndex = $interface.InterfaceIndex
$result += ,@($ifaceInfo)
}
return $result";
var networkInfoResult = _executor.Execute(server, networkInfo, mod => mod.LoadConDepModule = false, logOutput: false);
if (networkInfoResult != null)
{
foreach (var network in networkInfoResult)
{
//object[] ipAddresses = network.IPAddresses;
//IEnumerable<string> ipAddresses2 = ipAddresses.Cast<string>();
//object[] gateways = network.DefaultGateways;
var info = new NetworkInfo
{
Description = network.Description,
DHCPEnabled = network.DHCPEnabled,
DNSDomain = network.DNSDomain,
DNSHostName = network.DNSHostName,
Index = Convert.ToInt32(network.Index),
InterfaceIndex = Convert.ToInt32(network.InterfaceIndex)
};
if (network.IPAddresses is String)
{
info.IPAddresses = new string[] { network.IPAddresses };
}
else
{
object[] addresses = network.IPAddresses;
info.IPAddresses = addresses.Cast<string>();
}
if (network.IPSubnets is String)
{
info.IPSubnets = new string[] { network.IPSubnets };
}
else
{
object[] subnets = network.IPSubnets;
info.IPSubnets = subnets.Cast<string>();
}
if (network.DefaultGateways != null)
{
if (network.DefaultGateways is String)
{
info.DefaultGateways = new string[] { network.DefaultGateways };
}
else
{
object[] gateways = network.DefaultGateways;
info.IPAddresses = gateways.Cast<string>();
}
}
server.GetServerInfo().Network.Add(info);
}
}
}
private bool NeedToDeployScript(ServerConfig server, string localFile)
{
const string script = @"Param($fileWithHash, $dir)
$dir = $ExecutionContext.InvokeCommand.ExpandString($dir)
$conDepReturnValues = New-Object PSObject -Property @{
ConDepResult = New-Object PSObject -Property @{
Files = $null
}
}
function Get-ConDepFileHash($path) {
if(Test-Path $path) {
$md5 = [System.Security.Cryptography.MD5]::Create()
$hash = [System.BitConverter]::ToString($md5.ComputeHash([System.IO.File]::ReadAllBytes($path)))
return $hash.Replace(""-"", """")
}
else {
return """"
}
}
$returnValues = @()
$hash = Get-ConDepFileHash (Join-Path -path $dir -childpath $($fileWithHash.Item1))
$returnValues += @{
FileName = $fileWithHash.Item1
IsEqual = ($hash -eq $fileWithHash.Item2)
}
$conDepReturnValues.ConDepResult.Files = $returnValues
return $conDepReturnValues
";
var scriptParameters = new List<CommandParameter>
{
new CommandParameter("fileWithHash", new Tuple<string, string>(Path.GetFileName(localFile), FileHashGenerator.GetFileHash(localFile))),
new CommandParameter("dir", server.GetServerInfo().ConDepNodeScriptsFolder)
};
var scriptResult = _psExecutor.Execute(server, script, opt => opt.LoadConDepModule = false, logOutput: false, parameters: scriptParameters);
foreach (var psObject in scriptResult)
{
if (psObject.ConDepResult == null || psObject.ConDepResult.Files == null) continue;
var remoteFilesArray = ((PSObject)psObject.ConDepResult.Files).BaseObject as ArrayList;
var remoteFiles = remoteFilesArray.Cast<dynamic>().Select(remoteFile => remoteFile);
return remoteFiles.Any(remoteFile => !remoteFile.IsEqual && remoteFile.FileName == Path.GetFileName(localFile));
}
return false;
}
private void DeployNodeModuleScript(ServerConfig server)
{
var resource = ConDepNodeResources.ConDepNodeModule;
var localModulePath = GetFilePathForConDepScriptModule(resource);
if (NeedToDeployScript(server, localModulePath))
{
Logger.Verbose("Found script {0} in assembly {1}", localModulePath, GetType().Assembly.FullName);
var dstPath = Path.Combine(server.GetServerInfo().ConDepNodeScriptsFolder, Path.GetFileName(localModulePath));
PublishFile(localModulePath, dstPath, server);
}
}
private void CopyFile(string srcPath, ServerConfig server, ConDepSettings settings)
{
var dstPath = Path.Combine(server.GetServerInfo().TempFolderDos, Path.GetFileName(srcPath));
CopyFile(srcPath, dstPath, server, settings);
}
private static bool HaveNet40(ServerConfig server)
{
Logger.Info(string.Format("Checking if .NET Framework 4.0 is installed on server [{0}]...", server.Name));
var success = server.GetServerInfo().DotNetFrameworks.HasVersion(DotNetVersion.v4_0_full);
if (success)
{
Logger.Info(string.Format("Microsoft .NET Framework version 4.0 is installed on server [{0}].",
server.Name));
}
else
{
Logger.Error(string.Format("Missing Microsoft .NET Framework version 4.0 on [{0}].", server.Name));
}
return success;
}
public void Harvest(ServerConfig server)
{
var osInfo = @"
$osInfo = @{}
try {
$perfData = Get-WmiObject win32_perfformatteddata_perfos_system -Property SystemUpTime
$osInfo.SystemUpTime = $perfData.SystemUpTime
}
catch {
write-warning 'Failed to retreive SystemUpTime through WMI. Probably because of a bug in Windows/WMI when the server has been running close to a year without reboot.'
}
$compSystem = Get-WmiObject win32_computersystem -Property Name,SystemType
$os = Get-WmiObject win32_operatingsystem -Property Caption,Version,BuildNumber
$osInfo.HostName = $compSystem.Name
$osInfo.SystemType = $compSystem.SystemType
$osInfo.Name = $os.Caption
$osInfo.Version = $os.Version
$osInfo.BuildNumber = $os.BuildNumber
$osInfo.ProgramFilesFolder = ${Env:ProgramFiles}
$osInfo.ProgramFilesX86Folder = ${Env:ProgramFiles(x86)}
$regKeys = @()
if(Test-Path HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall) {
$regKeys += 'HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall'
}
if(Test-Path HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall) {
$regKeys += 'HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall'
}
if(Test-Path HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall) {
$regKeys += 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall'
}
$packages = Get-ChildItem -Path $regKeys | Get-ItemProperty | where-object { $_.DisplayName -ne $null } | select-object -Property DisplayName,DisplayVersion | foreach{$_.DisplayName + "";"" + $_.DisplayVersion}
$osInfo.InstalledSoftwarePackages = $packages
return $osInfo
";
var osInfoResult = _executor.Execute(server, osInfo, mod => mod.LoadConDepModule = false, logOutput: false).FirstOrDefault();
if (osInfoResult != null)
{
server.GetServerInfo().OperatingSystem = new OperatingSystemInfo
{
BuildNumber = Convert.ToInt32(osInfoResult.BuildNumber),
Name = osInfoResult.Name,
HostName = osInfoResult.HostName,
SystemType = osInfoResult.SystemType,
SystemUpTime = TimeSpan.FromSeconds(Convert.ToDouble(osInfoResult.SystemUpTime)),
Version = osInfoResult.Version,
ProgramFilesFolder = osInfoResult.ProgramFilesFolder,
ProgramFilesX86Folder = osInfoResult.ProgramFilesX86Folder,
InstalledSoftwarePackages = ConvertPackagesStringArrayToObjectCollection(((ArrayList)((PSObject)osInfoResult.InstalledSoftwarePackages).BaseObject).Cast<string>().ToArray())
};
Logger.Verbose("Output from harvester:");
Logger.Verbose("BuildNumber : " + osInfoResult.BuildNumber);
Logger.Verbose("Name : " + osInfoResult.Name);
Logger.Verbose("HostName : " + osInfoResult.HostName);
Logger.Verbose("SystemType : " + osInfoResult.SystemType);
Logger.Verbose("SystemUpTime : " + osInfoResult.SystemUpTime);
Logger.Verbose("Version : " + osInfoResult.Version);
Logger.Verbose("ProgramFiles : " + osInfoResult.ProgramFilesFolder);
Logger.Verbose("ProgramFilesX86 : " + osInfoResult.ProgramFilesX86Folder);
Logger.Verbose("InstalledPackages:");
server.GetServerInfo().OperatingSystem.InstalledSoftwarePackages.ToList().ForEach(x => Logger.Verbose("\t" + x.DisplayName + ", version: " + x.DisplayVersion));
}
}
