public HWServiceImpl()
{
IServiceManager manager = ServiceManager.GetInstance();
telemetry = manager.GetService <ITelemetryServicesProvider>();
coreServer = manager.GetService <ICoreServerService>();
}
public DefaultTelemetryServicesProvider()
{
IServiceManager serviceManager = ServiceManager.GetInstance();
coreServer = serviceManager.GetService <ICoreServerService>();
taskManager = serviceManager.GetService <IScheduledTaskManager>();
}
private bool Initialize()
{
IServiceManager serviceManager = ServiceManager.GetInstance();
logger = serviceManager.GetService <ILoggingService>();
coreServer = serviceManager.GetService <ICoreServerService>("realserver");
encoder = serviceManager.GetService <IEncodingConverterService>();
clientSocket = (Socket)asyncResult.AsyncState;
int received;
TryGetSession();
if (session == null)
{
Dispose();
return(false);
}
received = Receive();
if (received == 0)
{
return(false);
}
byte[] receivedBuffer = new byte[received];
Array.Copy(session.SessionStorage, receivedBuffer, received);
uriRequest = encoder.ConvertToString(receivedBuffer);
return(true);
}
public HWUsageCollectorTask()
: base("HWUsageCollector", true, new ScheduledTaskInterval(0, 0, 0, 1), false)
{
IServiceManager manager = ServiceManager.GetInstance();
telemetry = manager.GetService <ITelemetryDataCollector>();
coreServer = manager.GetService <ICoreServerService>();
}
public SecurityManagementServiceImpl()
{
IServiceManager manager = ServiceManager.GetInstance();
controllerManager = manager.GetService <IControllerManager>();
interceptorManager = manager.GetService <IInterceptorManagerService>();
coreServer = ServiceManager.GetInstance().GetService <ICoreServerService>("realserver");
}
public ServerInfoController()
{
IServiceManager manager = ServiceManager.GetInstance();
controllerManager = manager.GetService <IControllerManager>();
coreServer = manager.GetService <ICoreServerService>("realserver");
hardware = manager.GetService <IHardwareServices>();
telemetry = manager.GetService <ITelemetryServicesProvider>();
}
private void InitializeServices()
{
IServiceManager manager = ServiceManager.GetInstance();
logger = manager.GetService <ILoggingService>();
encoder = manager.GetService <IEncodingConverterService>();
coreServer = manager.GetService <ICoreServerService>("realserver");
responseStorage = manager.GetService <IMemoryResponseStorage>();
}
public BasicControllerRequestProcess(RequestPreProcessor preProcessor)
{
serviceManager = ServiceManager.GetInstance();
logger = serviceManager.GetService <ILoggingService>();
basicController = serviceManager.GetService <IBasicServerController>();
coreServer = serviceManager.GetService <ICoreServerService>("realserver");
encoder = serviceManager.GetService <IEncodingConverterService>();
this.preProcessor = preProcessor;
}
public static void AddLock(IController controller, string actionName)
{
IServiceManager manager = ServiceManager.GetInstance();
ICoreServerService coreServer = manager.GetService <ICoreServerService>("realserver");
if (coreServer.GetConfiguration().IsSingleThreaded)
{
throw new Exception("Action blocking not allowed for single-threaded servers");
}
lockedActions.Add(new KeyValuePair <IController, string>(controller, actionName));
}
private ISocketClientConnection GetClient()
{
IServiceManager manager = ServiceManager.GetInstance();
logging = manager.GetService <ILoggingService>();
ICoreServerService coreServer = manager.GetService <ICoreServerService>();
ServerConfiguration config = coreServer.GetConfiguration();
ISocketClientConnection connection = SocketConnectionFactory
.GetConnection(new SocketClientSettings("localhost", config.Port, config.ServerEncoding));
return(connection);
}
public void Run()
{
IServiceManager manager = configurator.Services;
configurator.ConfigureServices(manager);
ServerConfiguration config = configurator.GetServerConfiguration();
ICoreServerService server = manager.GetService <ICoreServerService>("realserver");
server.SetConfiguration(config);
server.Start();
}
/// <summary>
/// Enables load balancing features on the current server
/// </summary>
/// <param name="maxAttemptsToGetAvailableSubServer">In a pool of sub-servers, determines the maximum number of attempts to obtain an eligible server to meet the request from the connected client</param>
/// <param name="cacheResultsForUnreachableServers">If the number of attempts to obtain a server from the pool has exceeded, it will return a cache of the last request successfully made in the controller/action</param>
/// <returns></returns>
protected LoadBalanceConfigurator EnableLoadBalanceServer(int maxAttemptsToGetAvailableSubServer = 3,
bool cacheResultsForUnreachableServers = false)
{
ICoreServerService coreServer = Services.GetService <ICoreServerService>("realserver");
coreServer.EnableBasicServerProcessorMode(typeof(LoadBalanceServer));
if (cacheResultsForUnreachableServers)
{
LoadBalanceServer.EnableCachedResultsForUnreachableServers();
}
LoadBalanceServer.SetAttemptsToGetSubServerAvailable(maxAttemptsToGetAvailableSubServer);
return(new LoadBalanceConfigurator());
}
public void LoadAll()
{
IServiceManager manager = ServiceManager.GetInstance();
ICoreServerService coreServer = manager.GetService <ICoreServerService>();
double serverVersion;
double.TryParse(coreServer.GetServerVersion(), out serverVersion);
foreach (IExtensibleFrameworkInterface extension in Extensions)
{
try
{
if (string.IsNullOrEmpty(extension.ExtensionName))
{
throw new Exception($"Cannot be load unknown extension from assembly '{extension.GetType().Assembly.FullName}'");
}
if (string.IsNullOrEmpty(extension.ExtensionVersion))
{
throw new Exception($"Cannot be read extension version for '{extension.ExtensionName}'");
}
if (string.IsNullOrEmpty(extension.ExtensionPublisher))
{
throw new Exception($"Cannot be load unknown publisher extension for '{extension.ExtensionName}'");
}
double minServerVersion = double.Parse(extension.MinServerVersion);
if (serverVersion < minServerVersion)
{
throw new Exception($"The extension '{extension.ExtensionName}' could not be loaded because it requires server v{extension.MinServerVersion}");
}
Console.ForegroundColor = ConsoleColor.Green;
logger.WriteLog($" => Loading extension '{extension.ExtensionName}'");
logger.WriteLog($" => version {extension.ExtensionVersion}");
logger.WriteLog($" => by {extension.ExtensionPublisher}");
extension.Load(manager);
logger.WriteLog($" => Extension '{extension.ExtensionName}' successfully loaded");
Console.ForegroundColor = ConsoleColor.White;
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
logger.WriteLog($"Extension '{extension.ExtensionName}' fail to load: {ex.Message}", Logging.ServerLogType.ERROR);
Console.ForegroundColor = ConsoleColor.White;
}
}
}
public ServerInfo()
{
IServiceManager manager = ServiceManager.GetInstance();
ISecurityManagementService securityManagement = manager.GetService <ISecurityManagementService>();
ICoreServerService coreServer = manager.GetService <ICoreServerService>("realserver");
Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
if (coreServer.IsLoadBalanceEnabled())
{
IsLoadBanancingServer = true;
}
RequiresAuthentication = securityManagement.IsAuthenticationEnabled();
ServerVersion = version;
ServerControllers = new List <ControllerInfo>();
MachineName = Environment.MachineName;
}
public ServerEncodingConverterServiceImpl()
{
coreServer = ServiceManager.GetInstance().GetService <ICoreServerService>("realserver");
}
public override void ConfigureServices(IServiceManager serviceManager)
{
ICoreServerService coreServer = serviceManager.GetService <ICoreServerService>("realserver");
coreServer.EnableBasicServerProcessorMode(typeof(BasicServer));
}
public ProxyCoreServer()
{
instanceStr = $"ProxyCoreServer_{Guid.NewGuid().ToString().Replace("-", "")}";
realServer = ServiceManager.GetInstance().GetService <ICoreServerService>("realserver");
}
/// <summary>
/// Disables standard telemetry services on the server
/// WARNING!: Disabling telemetry services can bring some extra performance to the server (even if perhaps imperceptible). However it will not be possible to collect metrics to implement improvements in your code
/// </summary>
protected void DisableTelemetryServices()
{
ICoreServerService coreServer = Services.GetService <ICoreServerService>();
coreServer.DisableTelemetryServices();
}
