private void GetSettingsFromIISFiles(ImportArgs args)
{
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext("ImportSolution.Initialization"))
{
string appPoolFilePath = FileSystem.FileSystem.Local.Zip.ZipUnpackFile(args.PathToExportedInstance, args.temporaryPathToUnpack, ImportArgs.appPoolSettingsFileName);
string websiteSettingsFilePath = FileSystem.FileSystem.Local.Zip.ZipUnpackFile(args.PathToExportedInstance, args.temporaryPathToUnpack, ImportArgs.websiteSettingsFileName);
XmlDocumentEx appPool = new XmlDocumentEx();
appPool.Load(appPoolFilePath);
XmlDocumentEx websiteSettings = new XmlDocumentEx();
websiteSettings.Load(websiteSettingsFilePath);
args.oldSiteName = websiteSettings.GetElementAttributeValue("/appcmd/SITE/site", "name");
if (args.siteName == string.Empty)
{
args.siteName = websiteSettings.GetElementAttributeValue("/appcmd/SITE/site", "name");
}
args.virtualDirectoryPath = websiteSettings.GetElementAttributeValue("/appcmd/SITE/site/application/virtualDirectory", "path");
if (args.virtualDirectoryPhysicalPath == string.Empty)
{
args.virtualDirectoryPhysicalPath = websiteSettings.GetElementAttributeValue("/appcmd/SITE/site/application/virtualDirectory", "physicalPath");
}
args.appPoolName = appPool.GetElementAttributeValue("/appcmd/APPPOOL", "APPPOOL.NAME"); // need to set appPoolName in both files
if (args.appPoolName != args.siteName)
{
args.appPoolName = args.siteName;
}
args.appPoolName = SetupWebsiteHelper.ChooseAppPoolName(args.appPoolName, context.ApplicationPools);
args.siteID = long.Parse(websiteSettings.GetElementAttributeValue("/appcmd/SITE", "SITE.ID"));
}
}
private static IEnumerable <Site> GetOperableSites([NotNull] WebServerManager.WebServerContext context, [CanBeNull] string defaultRootFolder = null, bool?detectEverywhere = null)
{
Assert.IsNotNull(context, "Context cannot be null");
using (new ProfileSection("Getting operable sites", typeof(InstanceManager)))
{
ProfileSection.Argument("context", context);
ProfileSection.Argument("defaultRootFolder", defaultRootFolder);
ProfileSection.Argument("detectEverywhere", detectEverywhere);
if (defaultRootFolder != null)
{
instancesFolder = defaultRootFolder.ToLower();
}
IEnumerable <Site> sites = context.Sites;
var detectEverywhereResult = detectEverywhere ?? Settings.CoreInstancesDetectEverywhere.Value;
if (!detectEverywhereResult)
{
if (string.IsNullOrEmpty(instancesFolder))
{
Log.Warn("Since the 'Detect.Instances.Everywhere' setting is disabled and the instances root isn't set in the Settings dialog, the 'C:\\inetpub\\wwwroot' will be used instead", typeof(InstanceManager));
instancesFolder = @"C:\inetpub\wwwroot";
}
instancesFolder = instancesFolder.ToLower();
sites = sites.Where(s => WebServerManager.GetWebRootPath(s).ToLower().Contains(instancesFolder));
}
return(ProfileSection.Result(sites));
}
}
public void InitializeWithSoftListRefresh([CanBeNull] string defaultRootFolder = null)
{
using (new ProfileSection("Initialize with soft list refresh"))
{
// Add check that this isn't an initial initialization
if (Instances == null)
{
Initialize(defaultRootFolder);
}
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext())
{
IEnumerable <Site> sites = GetOperableSites(context, defaultRootFolder);
// The trick is in reused PartiallyCachedInstances. We use site ID as identificator that cached instance may be reused. If we can't fetch instance from cache, we create new.
PartiallyCachedInstances = sites
.Select(site => PartiallyCachedInstances.FirstOrDefault(cachedInst => cachedInst.ID == site.Id) ?? GetPartiallyCachedInstance(site))
.Where(IsSitecore)
.Where(IsNotHidden)
.ToArray();
Instances = PartiallyCachedInstances.Select(x => GetInstance(x.ID)).ToArray();
}
}
}
public string CreateNewAppPoolName(string oldName)
{
List <string> poolsNames = new List <string>();
foreach (var appPool in WebServerManager.CreateContext(string.Empty).ApplicationPools)
{
poolsNames.Add(appPool.Name);
}
bool flag = false;
while (!flag)
{
if ((from t in poolsNames
where t == oldName
select t).FirstOrDefault() == null)
{
return(oldName);
}
else
{
oldName += "_imported";
}
}
return(null);
}
bool IWizardStep.SaveChanges(WizardArgs wizardArgs)
{
var args = (ImportWizardArgs)wizardArgs;
if (WebServerManager.WebsiteExists(this.websiteName.Text))
{
this.websiteNameWarn.Visibility = System.Windows.Visibility.Visible;
return(false);
}
this.websiteNameWarn.Visibility = System.Windows.Visibility.Hidden;
if (FileSystem.FileSystem.Local.Directory.Exists(this.rootFolderPath.Text) && FileSystem.FileSystem.Local.Directory.GetFiles(this.rootFolderPath.Text).Length > 0)
{
this.rootPathWarn.Visibility = System.Windows.Visibility.Visible;
return(false);
}
args.siteName = this.websiteName.Text;
args.rootPath = this.rootFolderPath.Text;
args.updateLicense = this.updateLicense.IsChecked == true ? true : false;
args.pathToLicenseFile = ProfileManager.Profile.License;
return(true);
}
public static IServiceCollection AddSyncServer(this IServiceCollection serviceCollection, WebServerOrchestrator webServerOrchestrator)
{
var serviceProvider = serviceCollection.BuildServiceProvider();
// Get all registered server providers with schema and options
var webServerManager = serviceProvider.GetService <WebServerManager>();
if (webServerManager == null)
{
var cache = serviceProvider.GetService <IMemoryCache>();
var env = serviceProvider.GetService <IHostingEnvironment>();
webServerManager = new WebServerManager(cache, env);
serviceCollection.AddSingleton(webServerManager);
}
// Check if we don't have already added this scope name provider to the remote orchestrator list
if (webServerManager.Contains(webServerOrchestrator.ScopeName))
{
throw new ArgumentException($"Orchestrator with scope name {webServerOrchestrator.ScopeName} already exists in the service collection");
}
// add it to the singleton collection
webServerManager.Add(webServerOrchestrator);
return(serviceCollection);
}
/// <summary>
/// handles the web server state
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StartWebServerButton_Click(object sender, RoutedEventArgs e)
{
try
{
if (!WebServerManager.WebServerStarted)
{
int.TryParse(OptionsManager.CurrentOptions.Port, out var port);
if (port == 0)
{
port = 8080;
LogManager.AddLogMessage("invalid port, fallback to port 8080");
}
WebServerManager.StartWebServer(port);
//AddonCompiler.Insatnce.WebServer = new WebServerClient();
//AddonCompiler.Insatnce.WebServer.Start();
}
else
{
AddonCompiler.Insatnce.WebServer.Stop();
}
}
catch (Exception ex)
{
LogManager.AddErrorLog(ex);
WebServerManager.WebServerStarted = false;
}
WebServerButton.Content = WebServerManager.WebServerStarted ? "Stop Web Server" : "Start Web Server";
ApplicationWindows.TestWidnow.Update();
}
public long?CreateNewID(long?oldID)
{
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext("InstanceMgr.Init"))
{
var instances = context.Sites;
return(oldID == null || instances.Any(x => x.Id == oldID) ? instances.Max(x => x.Id) + 1 : oldID);
}
}
public void OnSubmitSignInCredentialsEvent(IEventBase obj)
{
if (obj is SubmitSignInCredentialsEvent)
{
SubmitSignInCredentialsEvent signInCred = (SubmitSignInCredentialsEvent)obj;
WebServerManager.UpdateSignInCredentials(signInCred.userName, signInCred.email, OnSignInSuccessfully, OnSignInFailed);
}
}
public static IServiceCollection AddSyncServer(this IServiceCollection serviceCollection, IConfiguration configuration, Type providerType,
string connectionString, string scopeName = SyncOptions.DefaultScopeName, SyncSetup setup = null, SyncOptions options = null, WebServerOptions webServerOptions = null)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
// Create default web server options
if (webServerOptions == null)
{
webServerOptions = new WebServerOptions();
}
options ??= new SyncOptions();
setup = setup ?? throw new ArgumentNullException(nameof(setup));
var serviceProvider = serviceCollection.BuildServiceProvider();
serviceCollection.AddMemoryCache();
// Get all registered server providers with schema and options
var webServerManager = serviceProvider.GetService <WebServerManager>();
// On first time, inject the singleton in the service collection provider
if (webServerManager == null)
{
var cache = serviceProvider.GetService <IMemoryCache>();
#if NET5_0 || NETCOREAPP3_1
var env = serviceProvider.GetService <IWebHostEnvironment>();
#elif NETSTANDARD
var env = serviceProvider.GetService <IHostingEnvironment>();
#endif
webServerManager = new WebServerManager(cache, env);
serviceCollection.AddSingleton(webServerManager);
}
// Check if we don't have already added this scope name provider to the remote orchestrator list
if (webServerManager.Contains(scopeName))
{
throw new ArgumentException($"Orchestrator with scope name {scopeName} already exists in the service collection");
}
// Create provider
var provider = (CoreProvider)Activator.CreateInstance(providerType);
provider.ConnectionString = connectionString;
// Create orchestrator
var webServerOrchestrator = new WebServerOrchestrator(provider, options, webServerOptions, setup, webServerManager.Cache, scopeName);
// add it to the singleton collection
webServerManager.Add(webServerOrchestrator);
return(serviceCollection);
}
private IEnumerable <Instance> GetIISInstances([CanBeNull] string defaultRootFolder = null)
{
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext())
{
ProfileSection.Argument("defaultRootFolder", defaultRootFolder);
IEnumerable <Site> sites = GetOperableSites(context, defaultRootFolder);
return(GetPartiallyCachedInstances(sites));
}
}
public static void Initialize([CanBeNull] string defaultRootFolder = null)
{
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext("Initialize instance manager"))
{
ProfileSection.Argument("defaultRootFolder", defaultRootFolder);
IEnumerable <Site> sites = GetOperableSites(context, defaultRootFolder);
PartiallyCachedInstances = GetPartiallyCachedInstances(sites);
Instances = GetInstances();
}
}
/// <summary>
/// started the web server
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StartWebServerButton_OnClick(object sender, RoutedEventArgs e)
{
int.TryParse(OptionsManager.CurrentOptions.Port, out var port);
if (port == 0)
{
port = 8080;
LogManager.AddLogMessage("invalid port, failling back to port 8080");
}
WebServerManager.StartWebServer(port);
Update();
}
public void Initialize([CanBeNull] string defaultRootFolder = null)
{
SitecoreEnvironmentHelper.RefreshEnvironments();
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext())
{
ProfileSection.Argument("defaultRootFolder", defaultRootFolder);
IEnumerable <Site> sites = GetOperableSites(context, defaultRootFolder);
PartiallyCachedInstances = GetPartiallyCachedInstances(sites);
Instances = GetInstances();
}
}
private void OnSendPlayerScoreData()
{
SetPlayerScoreEvent playerScore = new SetPlayerScoreEvent();
playerScore.layers = scores;
playerScore.totalScore = 0;
for (int i = 0; i < scores.Count; i++)
{
playerScore.totalScore += scores[i].TotalPoints;
}
EventManager.Raise <SetPlayerScoreEvent>(playerScore);
WebServerManager.UpdateUserScore(userName, companyName, playerScore.totalScore.ToString(), OnSendScoreToServerSuccessfully, OnSendScoreToServerFailed);
}
private static IEnumerable <Site> GetOperableSites([NotNull] WebServerManager.WebServerContext context, [CanBeNull] string defaultRootFolder = null)
{
Assert.IsNotNull(context, "Context cannot be null");
using (new ProfileSection("Getting operable sites"))
{
ProfileSection.Argument("context", context);
ProfileSection.Argument("defaultRootFolder", defaultRootFolder);
IEnumerable <Site> sites = context.Sites;
if (defaultRootFolder != null)
{
instancesFolder = defaultRootFolder.ToLower();
sites = sites.Where(s => WebServerManager.GetWebRootPath(s).ToLower().Contains(instancesFolder));
}
return(ProfileSection.Result(sites));
}
}
private string GetValidWebsiteName()
{
var instanceName = InstanceName;
Assert.IsNotNull(instanceName, nameof(instanceName));
var name = instanceName.Text.EmptyToNull();
Assert.IsNotNull(name, @"Instance name isn't set");
var websiteExists = WebServerManager.WebsiteExists(name);
if (websiteExists)
{
using (var context = WebServerManager.CreateContext())
{
var site = context.Sites.Single(s => s != null && s.Name.EqualsIgnoreCase(name));
var path = WebServerManager.GetWebRootPath(site);
if (FileSystem.FileSystem.Local.Directory.Exists(path))
{
Alert("The website with the same name already exists, please choose another instance name.");
return(null);
}
if (
WindowHelper.ShowMessage(
$"A website with the name {name} already exists. Would you like to remove it?",
MessageBoxButton.OKCancel, MessageBoxImage.Asterisk) != MessageBoxResult.OK)
{
return(null);
}
site.Delete();
context.CommitChanges();
}
}
websiteExists = WebServerManager.WebsiteExists(name);
Assert.IsTrue(!websiteExists, "The website with the same name already exists, please choose another instance name.");
return(name);
}
private string[] GetValidHostNames()
{
var hostName = HostNames;
Assert.IsNotNull(hostName, "HostNames is null");
var hostNamesString = hostName.Text.EmptyToNull();
Assert.IsNotNull(hostNamesString, "Host names can not be empty");
var hostNames = hostNamesString.Split(new[] { '\r', '\n', ',', '|', ';' }, StringSplitOptions.RemoveEmptyEntries);
Assert.IsTrue(hostNames.Any(), "Host names can not be empty");
foreach (var host in hostNames)
{
var hostExists = WebServerManager.HostBindingExists(host);
Assert.IsTrue(!hostExists, $"Website with the host name '{host}' already exists");
}
return(hostNames);
}
private static void AddSiteBinding(string instanceName, XmlElement action)
{
Assert.ArgumentNotNullOrEmpty(instanceName, nameof(instanceName));
Assert.ArgumentNotNull(action, nameof(action));
var host = action.GetAttribute("host");
if (host.IsNullOrEmpty())
{
return;
}
var protocol = action.HasAttribute("protocol") ? action.GetAttribute("protocol") : "http";
int port;
if (!action.HasAttribute("port") || !int.TryParse(action.GetAttribute("port"), out port))
{
port = 80;
}
var ip = action.HasAttribute("ip") ? action.GetAttribute("ip") : "*";
WebServerManager.AddHostBinding(instanceName, new BindingInfo(protocol, host, port, ip));
}
static void Main(string[] args)
{
GlobalContext.Properties["LogFileName"] = CurrentAssembly.ProcessNameBase;
log4net.Config.XmlConfigurator.Configure();
log.Debug("Application is starting...");
Options options = new Options();
var result = Parser.Default.ParseArguments <Options>(args);
log.Debug("Command line parameters have been processed.");
switch (result.Tag)
{
case ParserResultType.Parsed:
log.Debug("Command line options have been successfully parced.");
break;
case ParserResultType.NotParsed:
log.Error("Error by processing command line options.");
options.intPosX = -1;
break;
default:
log.Error("Unknown status by processing command line options.");
options.intPosX = -1;
break;
}
if (AppVersionHelper.IsNotDebug())
{
AppDomain.CurrentDomain.UnhandledException += frmExceptionBox.CurrentDomainUnhandledException;
Application.ThreadException += frmExceptionBox.ApplicationOnThreadException;
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
TaskScheduler.UnobservedTaskException += OnUnobservedException;
_fMain = new frmMain(
options.intMonitor,
options.intPosX,
options.intPosY,
options.intWidth,
options.intHeight,
options.isDisableStatusLine,
options.isDisableMainMenu,
options.strServerName,
options.strTemplate,
options.strDatabaseType,
options.isDisableNavigationPanel
);
_model = new MsSqlAuditorModel();
_fMain.SetModel(_model);
_model.Initialize();
_model.Settings.WarnAboutUnsignedQuery = args.All(a => a != "/!w");
_webServer = new WebServerManager(_model);
Thread.CurrentThread.CurrentUICulture = new CultureInfo(Model.Settings.InterfaceLanguage);
log.Debug("Inner data model has been initialized. Main form is going to be shown...");
Application.Run(_fMain);
log.Debug("Application is closed...");
}
/// <summary>
/// stop the web server
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void StopWebServerButton_Click(object sender, RoutedEventArgs e)
{
WebServerManager.StopWebServer();
Update();
}
// Injected thanks to Dependency Injection
public SyncController(WebServerManager manager, ContosoContext context)
{
this.manager = manager;
this.context = context;
}
public void OnGetLeaderboardEvent(IEventBase obj)
{
sendLeaderBoardData = true;
leaderBoardDataReady = false;
WebServerManager.GetLeaderBoardData(OnGetLeaderboardDataSuccessfully, OnGetLeaderboardDataFailed);
}
private bool BindingUsing(string hostname)
{
return(WebServerManager.HostBindingExists(hostname));
}
protected override void Process([NotNull] ReinstallArgs args)
{
Assert.ArgumentNotNull(args, "args");
WebServerManager.DeleteWebsite(args.WebsiteID);
}
// Injected thanks to Dependency Injection public SyncController(WebServerManager webServerManager) => this.webServerManager = webServerManager;
/// <summary>
/// compiles an addon and starts the web server
/// </summary>
/// <param name="addon"></param>
/// <param name="startWebServer"></param>
/// <returns></returns>
public async Task <bool> CompileAddon(C3Addon addon, bool startWebServer = true)
{
if (!ValidateFiles(addon))
{
IsCompilationValid = false;
return(false);
}
IsCompilationValid = true;
try
{
LogManager.CompilerLog.Insert($"compilation starting...");
//generate unique folder for specific addon class
var folderName = addon.Class.ToLower();
addon.AddonFolder = Path.Combine(OptionsManager.CurrentOptions.CompilePath, folderName);
//check for addon id
if (string.IsNullOrWhiteSpace(addon.AddonId))
{
addon.AddonId = $"{addon.Author}_{addon.Class}";
}
//clear out compile path
if (Directory.Exists(addon.AddonFolder))
{
LogManager.CompilerLog.Insert($"compile directory exists => { addon.AddonFolder}");
System.IO.Directory.Delete(addon.AddonFolder, true);
LogManager.CompilerLog.Insert($"removed compile directory...");
}
//create main compile directory
LogManager.CompilerLog.Insert($"recreating compile directory => { addon.AddonFolder}");
if (!Directory.Exists(OptionsManager.CurrentOptions.CompilePath))
{
System.IO.Directory.CreateDirectory(OptionsManager.CurrentOptions.CompilePath);
}
//create addon compile directory and addon specific paths
System.IO.Directory.CreateDirectory(addon.AddonFolder);
System.IO.Directory.CreateDirectory(Path.Combine(addon.AddonFolder, "lang"));
if (addon.Type != PluginType.Effect && addon.Type != PluginType.Theme)
{
System.IO.Directory.CreateDirectory(Path.Combine(addon.AddonFolder, "c3runtime"));
}
if (!string.IsNullOrWhiteSpace(addon.C2RunTime) || (addon.ThirdPartyFiles != null && addon.ThirdPartyFiles.Any(x => x.Value.C2Folder)))
{
System.IO.Directory.CreateDirectory(Path.Combine(addon.AddonFolder, "c2runtime"));
}
LogManager.CompilerLog.Insert($"compile directory created successfully => { addon.AddonFolder}");
if (addon.Type == PluginType.Effect)
{
//todo: effect validator http://shdr.bkcore.com/
CreateEffectFiles(addon, folderName);
}
else if (addon.Type == PluginType.Theme)
{
CreateThemeFiles(addon, folderName);
}
else
{
CreateAddonFiles(addon, folderName);
}
}
catch (Exception ex)
{
IsCompilationValid = false;
LogManager.AddErrorLog(ex);
LogManager.CompilerLog.Insert($"compilation terminated due to error...");
LogManager.CompilerLog.Insert($"error => {ex.Message}");
NotificationManager.PublishErrorNotification("There was an error generating the addon, please check the log.");
return(false);
}
//try and start the web server
try
{
if (startWebServer && IsCompilationValid)
{
//start web server installation
await Task.Run(() =>
{
int.TryParse(OptionsManager.CurrentOptions.Port, out var port);
if (port == 0)
{
port = 8080;
LogManager.AddLogMessage("invalid port, fallback to port 8080");
}
WebServerManager.StartWebServer(port);
//WebServer = new WebServerClient();
//WebServer.Start();
});
}
}
catch (Exception ex)
{
IsCompilationValid = false;
LogManager.AddErrorLog(ex);
LogManager.CompilerLog.Insert($"web server failed to start...");
NotificationManager.PublishErrorNotification("The web server failed to start... check that the port 8080, is not being used by another application.");
WebServerManager.WebServerStarted = false;
return(false);
}
return(true);
}
public static long SetupWebsite(bool enable32BitAppOnWin64, string webRootPath, bool forceNetFramework4, bool isClassic,
IEnumerable <BindingInfo> bindings, string name)
{
long siteId;
using (WebServerManager.WebServerContext context = WebServerManager.CreateContext())
{
ApplicationPool appPool = context.ApplicationPools.Add(ChooseAppPoolName(name, context.ApplicationPools));
appPool.ManagedRuntimeVersion = NetFrameworkV2;
var id = Settings.CoreInstallWebServerIdentity.Value;
ProcessModelIdentityType type = GetIdentityType(id);
appPool.ProcessModel.IdentityType = type;
appPool.ProcessModel.PingingEnabled = false;
if (forceNetFramework4)
{
appPool.SetAttributeValue("managedRuntimeVersion", "v4.0");
}
appPool.Enable32BitAppOnWin64 = enable32BitAppOnWin64;
appPool.ManagedPipelineMode = isClassic ? ManagedPipelineMode.Classic : ManagedPipelineMode.Integrated;
if (type == ProcessModelIdentityType.SpecificUser)
{
var password = Settings.CoreInstallWebServerIdentityPassword.Value;
appPool.ProcessModel.UserName = id;
appPool.ProcessModel.Password = password;
}
Product product = Product.Parse(ProductHelper.DetectProductFullName(webRootPath));
if (product.Name.EqualsIgnoreCase("Sitecore CMS"))
{
var ver = product.TwoVersion;
if (ver.StartsWith("6.0") || ver.StartsWith("6.1"))
{
appPool.Enable32BitAppOnWin64 = true;
appPool.ManagedPipelineMode = ManagedPipelineMode.Classic;
}
else if (ver.StartsWith("6.2"))
{
appPool.Enable32BitAppOnWin64 = true;
}
}
Site site = null;
foreach (BindingInfo binding in bindings)
{
var bindingInformation = $"{binding.IP}:{binding.Port}:{binding.Host}";
if (site == null)
{
site = context.Sites.Add(name, binding.Protocol, bindingInformation, webRootPath);
}
else
{
site.Bindings.Add(bindingInformation, binding.Protocol);
}
}
Assert.IsNotNull(site, nameof(site));
siteId = site.Id;
site.ApplicationDefaults.ApplicationPoolName = name;
context.CommitChanges();
}
return(siteId);
}
protected override void Process([NotNull] DeleteArgs args)
{
Assert.ArgumentNotNull(args, nameof(args));
WebServerManager.DeleteWebsite(args.InstanceID);
}
// Injected thanks to Dependency Injection public SyncController(WebServerManager manager) => this.manager = manager;
