public bool Setup(string serverType, string bootstrapUri, string assemblyImportRoot, IServerConfig config, string startupConfigFile)
{
m_AssemblyImporter = new AssemblyImport(assemblyImportRoot);
if (!string.IsNullOrEmpty(startupConfigFile))
{
AppDomain.CurrentDomain.ResetConfiguration(startupConfigFile);
}
var serviceType = Type.GetType(serverType);
m_AppServer = (IManagedApp)Activator.CreateInstance(serviceType);
var bootstrap = (IBootstrap)Activator.GetObject(typeof(IBootstrap), bootstrapUri);
var ret = m_AppServer.Setup(bootstrap, config);
if (ret)
{
m_Log = ((IAppServer)m_AppServer).Logger;
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
}
return(ret);
}
public bool NeedBeRecycled(IManagedApp app, StatusInfoCollection status)
{
var state = (app as IsolationApp).AssemblyUpdateState;
// not in running state
if (state == null)
{
return(false);
}
if (state.LastUpdatedTime > state.CurrentAssemblyTime)
{
// check to see if there is any latest update
// if yes, deplay much longer time
state.TryCheckUpdate();
return(IsDeplayOverdue(state.LastUpdatedTime));
}
// next check time has not reached yet
if (state.LastCheckTime.AddMinutes(m_CheckInterval) > DateTime.Now)
{
return(false);
}
if (!state.TryCheckUpdate())
{
return(false);
}
return(IsDeplayOverdue(state.LastUpdatedTime));
}
public bool NeedBeRecycled(IManagedApp app, StatusInfoCollection status)
{
var state = (app as IsolationApp).AssemblyUpdateState;
// not in running state
if (state == null)
return false;
if (state.LastUpdatedTime > state.CurrentAssemblyTime)
{
// check to see if there is any latest update
// if yes, deplay much longer time
state.TryCheckUpdate();
return IsDeplayOverdue(state.LastUpdatedTime);
}
// next check time has not reached yet
if (state.LastCheckTime.AddMinutes(m_CheckInterval) > DateTime.Now)
return false;
if (!state.TryCheckUpdate())
return false;
return IsDeplayOverdue(state.LastUpdatedTime);
}
public bool NeedBeRecycled(IManagedApp app, StatusInfoCollection status)
{
var memoryUsage = status[StatusInfoKeys.MemoryUsage];
if (memoryUsage == null)
return false;
return (long)memoryUsage >= m_MaxMemoryUsage;
}
protected override bool Setup(IManagedApp managedApp, IServerConfig config)
{
var ret = base.Setup(managedApp, config);
if (!ret)
return false;
SetupRecycleTriggers(managedApp, config);
return ret;
}
protected override bool Setup(IManagedApp managedApp, IServerConfig config)
{
var ret = managedApp.Setup(m_RemoteBootstrapWrap, config);
if (!ret)
return false;
SetupRecycleTriggers(managedApp, config);
return ret;
}
public bool NeedBeRecycled(IManagedApp app, StatusInfoCollection status)
{
var memoryUsage = status[StatusInfoKeys.MemoryUsage];
if (memoryUsage == null)
{
return(false);
}
return((long)memoryUsage >= m_MaxMemoryUsage);
}
protected override bool Setup(IManagedApp managedApp, IServerConfig config)
{
var ret = managedApp.Setup(m_RemoteBootstrapWrap, config);
if (!ret)
{
return(false);
}
SetupRecycleTriggers(managedApp, config);
return(ret);
}
public PerformanceMonitor(IRootConfig config, IEnumerable <IManagedApp> appServers, IManagedApp serverManager, ILogFactory logFactory)
{
m_PerfLog = logFactory.GetLog("Performance");
m_AppServers = appServers.ToArray();
m_ServerManager = serverManager;
m_Helper = new ProcessPerformanceCounterHelper(Process.GetCurrentProcess());
m_TimerInterval = config.PerformanceDataCollectInterval * 1000;
m_PerformanceTimer = new Timer(OnPerformanceTimerCallback);
}
public PerformanceMonitor(IRootConfig config, IEnumerable<IManagedApp> appServers, IManagedApp serverManager, ILoggerFactory logFactory)
{
m_PerfLogger = logFactory.GetLogger("Performance");
m_AppServers = appServers.ToArray();
m_ServerManager = serverManager;
m_Helper = new ProcessPerformanceCounterHelper(Process.GetCurrentProcess());
m_TimerInterval = config.PerformanceDataCollectInterval * 1000;
m_PerformanceTimer = new Timer(OnPerformanceTimerCallback);
}
void SetupRecycleTriggers(IManagedApp managedApp, IServerConfig config)
{
try
{
var recycleTriggers = config.OptionElements.GetChildConfig<RecycleTriggerConfigCollection>("recycleTriggers");
if (recycleTriggers != null && recycleTriggers.Count > 0)
{
var exportProvider = AppDomain.CurrentDomain.GetCurrentAppDomainExportProvider();
var recycleTriggerTypes = exportProvider.GetExports<IRecycleTrigger, IProviderMetadata>();
var triggers = new List<IRecycleTrigger>();
foreach (var triggerConfig in recycleTriggers)
{
var triggerType = recycleTriggerTypes.FirstOrDefault(t =>
t.Metadata.Name.Equals(triggerConfig.Name, StringComparison.OrdinalIgnoreCase));
if (triggerType == null)
{
Log.ErrorFormat("We cannot find a RecycleTrigger with the name '{0}'.", triggerConfig.Name);
continue;
}
var trigger = triggerType.Value;
if (!trigger.Initialize(triggerConfig.Options))
{
Log.ErrorFormat("Failed to initialize the RecycleTrigger '{0}'.", triggerConfig.Name);
continue;
}
triggers.Add(trigger);
}
if (triggers.Any())
{
(managedApp as IsolationApp).RecycleTriggers = triggers.ToArray();
}
}
}
catch (Exception e)
{
Log.Error("Failed to load recycle triggers.", e);
}
}
void SetupRecycleTriggers(IManagedApp managedApp, IServerConfig config)
{
try
{
var recycleTriggers = config.OptionElements.GetChildConfig <RecycleTriggerConfigCollection>("recycleTriggers");
if (recycleTriggers == null || !recycleTriggers.Any())
{
return;
}
var triggers = new List <IRecycleTrigger>();
foreach (var triggerConfig in recycleTriggers)
{
var triggerType = m_RecycleTriggers.FirstOrDefault(t =>
t.Metadata.Name.Equals(triggerConfig.Name, StringComparison.OrdinalIgnoreCase));
if (triggerType == null)
{
Logger.ErrorFormat("We cannot find a RecycleTrigger with the name '{0}'.", triggerConfig.Name);
continue;
}
var trigger = triggerType.Value;
if (!trigger.Initialize(triggerConfig.Options))
{
Logger.ErrorFormat("Failed to initialize the RecycleTrigger '{0}'.", triggerConfig.Name);
continue;
}
triggers.Add(trigger);
}
if (triggers.Any())
{
(managedApp as IsolationApp).RecycleTriggers = triggers.ToArray();
}
}
catch (Exception e)
{
Logger.Error("Failed to load recycle triggers.", e);
}
}
public bool Setup(string serverType, string bootstrapUri, string assemblyImportRoot, IServerConfig config)
{
m_AssemblyImporter = new AssemblyImport(assemblyImportRoot);
var serviceType = Type.GetType(serverType);
m_AppServer = (IManagedApp)Activator.CreateInstance(serviceType);
var bootstrap = (IBootstrap)Activator.GetObject(typeof(IBootstrap), bootstrapUri);
var ret = m_AppServer.Setup(bootstrap, config);
if (ret)
{
m_Log = ((IAppServer)m_AppServer).Logger;
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
}
return ret;
}
internal virtual bool SetupWorkItemInstance(IManagedApp workItem, IServerConfig serverConfig)
{
return(workItem.Setup(this, serverConfig));
}
/// <summary>
/// Initializes the bootstrap with the configuration, config resolver and log factory.
/// </summary>
/// <param name="serverConfigResolver">The server config resolver.</param>
/// <param name="logFactory">The log factory.</param>
/// <returns></returns>
public virtual bool Initialize(Func <IServerConfig, IServerConfig> serverConfigResolver, ILogFactory logFactory)
{
if (m_Initialized)
{
throw new Exception("The server had been initialized already, you cannot initialize it again!");
}
if (logFactory != null && !string.IsNullOrEmpty(m_Config.LogFactory))
{
throw new ArgumentException("You cannot pass in a logFactory parameter, if you have configured a root log factory.", "logFactory");
}
if (logFactory == null)
{
logFactory = GetBootstrapLogFactory(m_Config.LogFactory);
}
m_GlobalLog = logFactory.GetLog(this.GetType().Name);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
m_AppServers = new List <IManagedApp>(m_Config.Servers.Count());
IManagedApp serverManager = null;
//Initialize servers
foreach (var config in m_Config.Servers)
{
var serverConfig = config;
if (serverConfigResolver != null)
{
serverConfig = serverConfigResolver(config);
}
IManagedApp appServer;
try
{
var serverType = serverConfig.ServerType;
if (string.IsNullOrEmpty(serverType) && !string.IsNullOrEmpty(serverConfig.ServerTypeName))
{
var serverTypeProvider = m_Config.ServerTypes.FirstOrDefault(
t => t.Name.Equals(serverConfig.ServerTypeName, StringComparison.OrdinalIgnoreCase));
if (serverTypeProvider != null)
{
serverType = serverTypeProvider.Type;
}
}
if (string.IsNullOrEmpty(serverType))
{
throw new Exception("No server type configured or the configured server type was not found.");
}
appServer = CreateWorkItemInstance(serverType);
var serverMetadata = appServer.GetAppServerMetadata();
if (serverMetadata.IsServerManager)
{
serverManager = appServer;
}
if (m_GlobalLog.IsDebugEnabled)
{
m_GlobalLog.DebugFormat("The server instance {0} has been created!", serverConfig.Name);
}
}
catch (Exception e)
{
if (m_GlobalLog.IsErrorEnabled)
{
m_GlobalLog.Error(string.Format("Failed to create server instance {0}!", serverConfig.Name), e);
}
return(false);
}
var exceptionSource = appServer as IExceptionSource;
if (exceptionSource != null)
{
exceptionSource.ExceptionThrown += new EventHandler <ErrorEventArgs>(exceptionSource_ExceptionThrown);
}
var setupResult = false;
try
{
setupResult = SetupWorkItemInstance(appServer, serverConfig);
if (m_GlobalLog.IsDebugEnabled)
{
m_GlobalLog.DebugFormat("The server instance {0} has been initialized!", appServer.Name);
}
}
catch (Exception e)
{
m_GlobalLog.Error(e);
setupResult = false;
}
if (!setupResult)
{
if (m_GlobalLog.IsErrorEnabled)
{
m_GlobalLog.Error("Failed to setup server instance!");
}
return(false);
}
m_AppServers.Add(appServer);
}
if (!m_Config.DisablePerformanceDataCollector)
{
m_PerfMonitor = new PerformanceMonitor(m_Config, m_AppServers, serverManager, logFactory);
if (m_GlobalLog.IsDebugEnabled)
{
m_GlobalLog.Debug("The PerformanceMonitor has been initialized!");
}
}
if (m_GlobalLog.IsDebugEnabled)
{
m_GlobalLog.Debug("The Bootstrap has been initialized!");
}
try
{
RegisterRemotingService();
}
catch (Exception e)
{
if (m_GlobalLog.IsErrorEnabled)
{
m_GlobalLog.Error("Failed to register remoting access service!", e);
}
return(false);
}
m_Initialized = true;
return(true);
}
public ServerProxy(IManagedApp app)
{
m_ManagedApp = app;
}
private ManagedAppVersion UpdateAppVersion(IManagedPlatform platform, IManagedTenant tenant, AvailableApplication app, ICollection <ManagedApp> existingApps)
{
using (Profiler.Measure("PlatformService.UpdateAppVersion"))
{
IManagedApp managedApp = existingApps.FirstOrDefault(e => e.ApplicationId == app.ApplicationId);
IManagedAppVersion managedAppVersion = null;
// does it exit on the platform?
if (platform != null)
{
managedAppVersion = platform.AvailableAppVersions.FirstOrDefault(v => v.VersionId == app.ApplicationVersionId) ??
GetAppVersion(app.ApplicationVersionId);
}
// or the tenant?
if (tenant != null && managedAppVersion == null)
{
managedAppVersion = tenant.HasAppsInstalled.FirstOrDefault(i => i.VersionId == app.ApplicationVersionId);
}
// or in amongst the list of apps just being created?
if (managedAppVersion == null)
{
managedAppVersion = existingApps.SelectMany(a => a.Versions).FirstOrDefault(v =>
(v.VersionId == app.ApplicationVersionId) &&
(v.Version == app.PackageVersion) &&
(v.Name == app.Name));
}
if (managedAppVersion != null)
{
managedAppVersion = managedAppVersion.AsWritable <ManagedAppVersion>();
// it should have an app
if (managedAppVersion.Application != null)
{
managedApp = managedAppVersion.Application;
}
}
else
{
managedAppVersion = CastEntityHelper.CreateAppVersion();
managedAppVersion.VersionId = app.ApplicationVersionId;
}
managedAppVersion.Name = app.Name;
managedAppVersion.Version = app.PackageVersion;
managedAppVersion.PublishDate = app.ReleaseDate;
// does the app exist then?
if (managedApp == null)
{
managedApp = UpdateApp(app);
}
if (managedApp != null)
{
managedApp = managedApp.AsWritable <ManagedApp>();
managedApp.Versions.Add((ManagedAppVersion)managedAppVersion);
managedAppVersion.Application = managedApp;
existingApps.Add((ManagedApp)managedApp);
}
if (platform != null || tenant != null)
{
if (platform != null)
{
platform.AvailableAppVersions.Add((ManagedAppVersion)managedAppVersion);
}
if (tenant != null)
{
tenant.HasAppsInstalled.Add((ManagedAppVersion)managedAppVersion);
}
}
return((ManagedAppVersion)managedAppVersion);
}
}
internal override bool SetupWorkItemInstance(IManagedApp workItem, IServerConfig serverConfig)
{
return(workItem.Setup(m_Bootstrap, serverConfig));
}
public MarshalManagedApp(string appTypeName)
{
var appType = Type.GetType(appTypeName);
m_ManagedApp = (IManagedApp)Activator.CreateInstance(appType);
}
internal virtual bool SetupWorkItemInstance(IManagedApp workItem, IServerConfig serverConfig)
{
return workItem.Setup(this, serverConfig);
}
public virtual bool Initialize()
{
AnyLog.LoggerFactory.Configurate(ExportProvider, ConfigSource.LogFactory);
var loggerFactory = AnyLog.LoggerFactory.Current;
if (loggerFactory == null)
{
throw new Exception("Failed to load loggerFactory.");
}
LoggerFactory = loggerFactory;
Logger = loggerFactory.GetLogger(this.GetType().Name);
AppDomain.CurrentDomain.SetData("Bootstrap", this);
foreach (var config in ConfigSource.Servers.Where(s => s.StartupType != StartupType.Disabled))
{
IManagedApp server = null;
try
{
server = CreateAppInstance(config);
Logger.InfoFormat("The app server instance [{0}] is created.", config.Name);
}
catch (Exception e)
{
Logger.Error(string.Format("Failed to create the app server instance [{0}].", config.Name), e);
return(false);
}
if (server == null)
{
Logger.Error(string.Format("Failed to create the server instance [{0}]", config.Name));
return(false);
}
try
{
if (!Setup(server, config))
{
throw new Exception(string.Format("The app server instance [{0}] failed to be setup.", config.Name));
}
Logger.InfoFormat("The app server instance [{0}] is setup successfully.", config.Name);
}
catch (Exception e)
{
Logger.Error(string.Format("Failed to setup the app server instance [{0}]", config.Name), e);
return(false);
}
ManagedApps.Add(server);
}
try
{
RegisterRemotingService();
}
catch (Exception e)
{
if (Logger.IsErrorEnabled)
{
Logger.Error("Failed to register remoting access service!", e);
}
return(false);
}
return(true);
}
public ServerProxy(IManagedApp server)
{
m_Server = server;
}
internal override bool SetupWorkItemInstance(IManagedApp workItem, IServerConfig serverConfig)
{
return workItem.Setup(m_Bootstrap, serverConfig);
}
protected override bool Setup(IManagedApp managedApp, IServerConfig config)
{
return managedApp.Setup(m_RemoteBootstrapWrap, config);
}
protected virtual bool Setup(IManagedApp managedApp, IServerConfig config)
{
return managedApp.Setup(this, config);
}
/// <summary>
/// Initializes a new instance of the <see cref="AppDomainAppServer"/> class.
/// </summary>
/// <param name="serviceTypeName">Name of the service type.</param>
public MarshalAppServer(string serviceTypeName)
{
var serviceType = Type.GetType(serviceTypeName);
m_AppServer = (IManagedApp)Activator.CreateInstance(serviceType);
}
public ServerProxy(IManagedApp app)
{
m_ManagedApp = app;
}
public ServerProxy(IManagedApp server)
{
m_Server = server;
}
public MarshalManagedApp(string appTypeName)
{
var appType = Type.GetType(appTypeName);
m_ManagedApp = (IManagedApp)Activator.CreateInstance(appType);
}
protected virtual bool Setup(IManagedApp managedApp, IServerConfig config)
{
return(managedApp.Setup(this, config));
}
