modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Services/ServiceManager/ServiceManager.sg

2487 lines
120 KiB
Plaintext
Raw Blame History

///////////////////////////////////////////////////////////////////////////////
//
// Microsoft Research Singularity
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
//A service can be started for one of the following reasons:
// * The configuration says the service should always be running.
// * A client has connected to one of the advertised names of the service.
// * A management client has requested that the service be started.
//
//
using System;
using System.Diagnostics;
using System.Collections;
using System.Collections.Specialized;
using Microsoft.Contracts;
using Microsoft.SingSharp;
using Microsoft.Singularity;
using Microsoft.Singularity.Applications;
using Microsoft.Singularity.Channels;
using Microsoft.Singularity.Configuration;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Security;
using Microsoft.Singularity.ServiceManager;
using Microsoft.Singularity.Xml;
using Microsoft.Singularity.V1.Processes;
[assembly: ApplicationPublisherAttribute("singularity.microsoft.com")]
[assembly: AssertPrivilegeAttribute("$register-privilege.localhost")]
namespace Microsoft.Singularity.Services.ServiceManager
{
internal sealed class ServiceManager : ITracked
{
///
//<summary>
// The kernel creates the Service Manager process when the system starts.
// This happens in Kernel\Singularity.Io\IoSystem.sg, in the InitializeServiceManager()
// method. That method scans the system manifest (the in-memory, parsed XML document)
// for service definitions, and then builds the argument vector for this process.
// For each service, the method adds three arguments to the argument vector:
// the service name, the executable (manifest) name, and the service type, which is
// "managed" or "unmanaged". (We only support "managed".)
//
// The kernel also sets up the endpoint vector, with exactly one endpoint at entry zero.
// This is an instance of DirectoryServiceContract.Imp. The current implementation of
// the Service Manager does not use this endpoint, and so at startup time, we extract
// and delete that endpoint.
//
// Startup endpoints:
//
// 0 - DirectoryServiceContract.Imp:Ready
//
// 1 - ServiceProviderContract.Exp:Start
// This is a service provider channel registered at '/service/services'.
// The kernel creates this service provider channel before starting the
// Service Manager. Unit test apps can also create instances of the Service
// Manager at different paths.
//
//
//</summary>
//
public static int Main(string[]! args)
{
tracePrintLevel = TraceLevel.Notice;
Binder.Initialize();
Endpoint* in ExHeap ep0 = Process.GetStartupEndpoint(0);
if (ep0 == null) {
Dbg(TraceLevel.Error, "ERROR: Startup endpoint 0 is not set. Service Manager cannot start.");
Dbg(TraceLevel.Error, "Service Manager cannot start.");
return -1;
}
DirectoryServiceContract.Imp:Ready rootds = ep0 as DirectoryServiceContract.Imp:Ready;
if (rootds == null) {
delete ep0;
Dbg(TraceLevel.Error, "ERROR: Startup endpoint 0 is set, but is not DirectoryServiceContract.Imp:Ready.");
Dbg(TraceLevel.Error, "Service Manager cannot start.");
return -1;
}
Endpoint* in ExHeap ep1 = Process.GetStartupEndpoint(1);
if (ep1 == null) {
Dbg(TraceLevel.Error, "ERROR: Startup endpoint is not set. Service Manager cannot start.");
Dbg(TraceLevel.Error, "Service Manager cannot start.");
delete rootds;
return -1;
}
ServiceProviderContract.Exp:Start services_namespace_provider = ep1 as ServiceProviderContract.Exp:Start;
if (services_namespace_provider == null) {
Dbg(TraceLevel.Error, "ERROR: Startup endpoint is set, but is not ServiceProviderContract.Exp:Start.");
Dbg(TraceLevel.Error, "Service Manager cannot start.");
delete rootds;
delete ep1;
return -1;
}
ServiceManager! manager = new ServiceManager(rootds, services_namespace_provider);
try {
//
// All of the resources we need to run are now set up. Next, process the list of
// services passed to this process by the kernel. The kernel parses the system
// manifest, and builds the argument vector for this process by searching for
// <service> elements (xpath /system/serviceConfig/service). For each service,
// the kernel appends three strings to the argument vector: the service name,
// the executable (manifest) name, and service type ("managed" or "unmanaged").
//
manager.CreateInitialServices(args);
int result = manager.Run();
return result;
}
finally {
manager.Dispose();
}
}
ServiceManager(
[Claims]DirectoryServiceContract.Imp:Ready! rootds,
[Claims]ServiceProviderContract.Exp:Start! services_namespace_provider)
{
this.rootds = rootds;
this.services_namespace_provider = services_namespace_provider;
this.ForgetLastStartFailedInterval = TimeSpan.FromSeconds(30);
}
#region Data Fields
/// <summary>
/// Controls which calls to Dbg() are also sent to DebugStub.WriteLine().
/// </summary>
internal static TraceLevel tracePrintLevel;
readonly ServiceConnectRequest[]! connectRequestLookasideList = new ServiceConnectRequest[0x20];
int connectRequestLookasideCount;
TimeSpan ForgetLastStartFailedInterval;
readonly IDictionary/*<String,Service!>*/! services = new ListDictionary(CaseInsensitiveComparer.DefaultInvariant);
Service[] servicesSnapshot;
/// <summary>
/// This channel is provided by the kernel (or whatever process created this Service Manager process).
/// This endpoint is passed to this process as startup endpoint 0.
///
/// Currently, this field is not used. However, if this process does perform any Directory operations,
/// it should use this as its root.
/// </summary>
readonly DirectoryServiceContract.Imp! rootds;
/// <summary>
/// This channel is provided by the kernel (or whatever process created this Service Manager process).
/// This endpoint is a namespace service provider, registered with the Directory service, usually at
/// '/service/services'. However, a creating process may use a different name or path, so the Service Manager
/// should never assume that the path is '/service/services'.
///
/// This endpoint is passed to this process as startup endpoint 1.
/// </summary>
readonly ServiceProviderContract.Exp! services_namespace_provider;
/// <summary>
/// Contains clients channels who send service control requests to the Service Manager.
/// Clients in this set (state) have not selected a specific service.
/// </summary>
readonly ESet<ServiceManagerContract.Exp:Ready>! clients =
new ESet<ServiceManagerContract.Exp:Ready>();
/// <summary>
/// Contains clients channels who send service control requests to the Service Manager.
/// </summary>
readonly EMap<ServiceManagerContract.Exp:ServiceSelected,Service!>! svclients =
new EMap<ServiceManagerContract.Exp:ServiceSelected,Service!>();
/// <summary>
/// Contains clients that are in the "Enumerate" state; they are enumerating the set of services.
/// The IEnumerator reference enumerates Service.
/// </summary>
readonly EMap<ServiceManagerContract.Exp:EnumeratingServices,IEnumerator!>! clients_enumerating =
new EMap<ServiceManagerContract.Exp:EnumeratingServices,IEnumerator!>();
/// <summary>
/// The clients whose endpoints in this endpoint map have subscribed to the status of services,
/// and the client is the next sender. The client will send either WaitServiceChange, or
/// StopWatchingService.
/// </summary>
readonly EMap<ServiceManagerContract.Exp:WaitingServiceChange,ServiceWatcher!>! clients_readywatch =
new EMap<ServiceManagerContract.Exp:WaitingServiceChange,ServiceWatcher!>();
/// <summary>
/// Clients can connect to the Service Manager namespace (/service/services) using DirectoryServiceContract.
/// This can be used to enumerate service, and to connect to services.
/// </summary>
readonly EMap<DirectoryServiceContract.Exp:Ready,DirectoryClientInfo!>! dirs =
new EMap<DirectoryServiceContract.Exp:Ready,DirectoryClientInfo!>();
/// <summary>
/// Contains directory clients who are enumerating.
/// </summary>
readonly EMap<DirectoryServiceContract.Exp:EnumerateAck,DirectoryClientInfo!>! dirs_enumerating =
new EMap<DirectoryServiceContract.Exp:EnumerateAck,DirectoryClientInfo!>();
/// <summary>
/// The set of endpoints that want to be notified when the service starts.
/// All of these endpoints (stored in a TRef within ServiceStartWatcher) came from
/// clients who issued a StartServiceWait request.
/// </summary>
readonly ArrayList/*<ServiceStartWatcher>*/! serviceStartWatchers = new ArrayList();
/// <summary>
/// The set of endpoints that want to be notified when a specific service stops.
/// All of these endpoints (stored in a TRef within ServiceStopWatcher) came from
/// clients who issued a StopServiceWait request.
/// </summary>
readonly ArrayList/*<ServiceStopWatcher>*/! serviceStopWatchers = new ArrayList();
/// <summary>
/// Contains notifier endpoints of services that are being started.
/// </summary>
readonly EMap<ServiceStarterContract.Imp:Starting,ServiceStarter!>! service_starters =
new EMap<ServiceStarterContract.Imp:Starting,ServiceStarter!>();
/// <summary>
/// Contains the control endpoints of services that are starting. We're waiting for the "Success"
/// message from these services before we consider them started.
/// </summary>
readonly EMap<ServiceProcessContract.Imp:Starting,ServiceProcess!>! svcontrols_starting =
new EMap<ServiceProcessContract.Imp:Starting,ServiceProcess!>();
/// <summary>
/// Contains the control endpoints of services that we have sent a "StopService" request to.
/// </summary>
readonly EMap<ServiceProcessContract.Imp:Stopping,ServiceProcess!>! svcontrols_stopping =
new EMap<ServiceProcessContract.Imp:Stopping,ServiceProcess!>();
/// <summary>
/// Contains the control endpoints of services that we have sent a "Connect" request to.
/// </summary>
readonly EMap<ServiceProcessContract.Imp:Connecting,ServiceProcess!>! svcontrols_connecting =
new EMap<ServiceProcessContract.Imp:Connecting,ServiceProcess!>();
/// <summary>
/// Contains the notification channels that are connect to service processes, which are
/// in the "Ready" state. In this state, the service process can send messages to the
/// Service Manager. The Service Manager always responds immediately, so there are no
/// other EMaps or ESets for these channels.
/// </summary>
readonly EMap<ServiceEventContract.Exp:Ready,ServiceProcess!>! svevents =
new EMap<ServiceEventContract.Exp:Ready,ServiceProcess!>();
/// <summary>
/// Contains the control endpoints of services that we have sent a "Knock" message to.
/// </summary>
readonly EMap<ServiceProcessContract.Imp:Knocking,ServiceProcess!>! svcontrols_knocking =
new EMap<ServiceProcessContract.Imp:Knocking,ServiceProcess!>();
/// <summary>
/// Contains instance of ServiceManagerWatcher, representing those management clients that
/// have subscribed to the overall status of the Service Manager.
/// </summary>
readonly ArrayList/*<ServiceManagerWatcher>*/! managerWatchers = new ArrayList();
/// <summary>
/// Contains endpoints of management clients that have subscribed to the overall status of the
/// Service Manager, and are ready to wait for the next event, or to end their subscription.
/// The next possible messages in this state are WaitNextServiceManagerChange and
/// StopWatchingServiceManager.
/// </summary>
readonly EMap<ServiceManagerContract.Exp:ReadyWatchServiceManager,ServiceManagerWatcher!>! managerWatchersReady
= new EMap<ServiceManagerContract.Exp:ReadyWatchServiceManager,ServiceManagerWatcher!>();
#endregion
public void Dispose()
{
delete clients;
delete clients_enumerating;
delete clients_readywatch;
delete service_starters;
delete svclients;
delete svcontrols_starting;
delete svcontrols_stopping;
delete svcontrols_connecting;
delete dirs;
delete dirs_enumerating;
delete rootds;
delete svevents;
delete svcontrols_knocking;
delete managerWatchersReady;
delete services_namespace_provider;
}
/// <summary>
/// Main service loop.
/// </summary>
int Run()
{
expose(this) {
//
// Now we enter our main message loop.
//
Dbg(TraceLevel.Notice, "Service Manager has started successfully.");
for (;;) {
//
// Before we process any new messages, check the integrity and
// consistency of our data structures.
//
AssertIntegrity();
ScanForStoppedProcesses();
switch receive {
#region Event handlers for message from Directory, for the '/service' registration
case services_namespace_provider.Connect(ServiceContract.Exp:Start! exp):
{
ServiceManagerContract.Exp:Start client = exp as ServiceManagerContract.Exp:Start;
DirectoryServiceContract.Exp:Start dir = exp as DirectoryServiceContract.Exp:Start;
if (client != null) {
Dbg(TraceLevel.Audit, "A client has connected, using ServiceManagerContract.");
client.SendSuccess();
clients.Add(client);
services_namespace_provider.SendAckConnect();
}
else if (dir != null) {
Dbg(TraceLevel.Audit, "A client has connected, using DirectoryServiceContract.");
DirectoryClientInfo info = new DirectoryClientInfo("/");
dir.SendSuccess();
dirs.Add(dir, info);
services_namespace_provider.SendAckConnect();
}
else {
Dbg(TraceLevel.Audit, "A client has connected, but has offered an unsupported channel contract.");
services_namespace_provider.SendNackConnect(exp);
break;
}
break;
}
case services_namespace_provider.ChannelClosed():
Dbg(TraceLevel.Audit, "The Directory has closed the namespace provider channel. Service manager will now terminate.");
return -1;
#endregion
#region Event handlers for 'clients' endpoint set
// These are event handlers for ServiceManagerContract clients in the "Ready" state.
// These are management clients that have connected to the Service Manager, but have
// not selected any particular service to operate on.
case client.SelectService(char[]! in ExHeap serviceName) in clients:
{
string! name = Bitter.ToString2(serviceName);
delete serviceName;
Service service = FindService(name);
if (service != null) {
Dbg(TraceLevel.Audit, "Client has selected service '{0}'.", name);
client.SendOk();
svclients.Add(client, service);
// -XXX- add reference count on service?
}
else {
Dbg(TraceLevel.Audit, "Client wants to select service '{0}', but there is no such service.", name);
client.SendRequestFailed(ServiceError.ServiceNotFound);
clients.Add(client);
}
break;
}
case client.CreateService(ServiceConfig config) in clients:
{
InternalServiceConfig local_config = new InternalServiceConfig(ref config);
ServiceError error = CreateService(local_config);
if (error == ServiceError.None) {
client.SendOk();
}
else {
Dbg(TraceLevel.Audit, "The request to create a service has failed, error = " + ServiceEnums.ToString(error));
client.SendRequestFailed(error);
}
config.Dispose();
clients.Add(client);
break;
}
case client.EnumerateServices(ServiceInfo[]! in ExHeap infos) in clients:
{
// It's possible to create just the enumerator here, and allow
// further messages (client.MoveNext) to drive that enumerator.
// However, it's also possible for the collection being enumerated
// to change, if a service is added or deleted. That would cause
// an exception during use of the enumerator later. Instead, we
// make a copy of the services.Values collection, if necessary.
Service[]! snapshot = GetServicesSnapshot();
IEnumerator! enumerator = snapshot.GetEnumerator();
EnumerateServiceInfos(client, infos, enumerator);
break;
}
case client.WatchServiceManager(ServiceManagerEventMask mask) in clients:
// The client wants to subscribe to the overall status and configuration
// of the Service Manager.
if (mask == 0) {
Dbg(TraceLevel.Audit, "Received 'WatchServiceManager', but the event mask specified is zero.");
client.SendRequestFailed(ServiceError.InvalidArguments);
clients.Add(client);
break;
}
const ServiceManagerEventMask known_events = ServiceManagerEventMask.AnyServiceConfig
| ServiceManagerEventMask.AnyServiceStatus;
if ((mask & ~known_events) != 0) {
Dbg(TraceLevel.Audit, "Received 'WatchServiceManager', but the client has specified events (bits) that we don't recognized.");
client.SendRequestFailed(ServiceError.InvalidArguments);
clients.Add(client);
break;
}
ServiceManagerWatcher watcher = new ServiceManagerWatcher();
watcher.DesiredEvents = mask;
watcher.EventsMissed = mask;
client.SendOk();
managerWatchers.Add(watcher);
managerWatchersReady.Add(client, watcher);
Dbg(TraceLevel.Audit, "A client has subscribed to global Service Manager events.");
Dbg(TraceLevel.Audit, "Watching: all service config = {0}, all service status = {1}",
((mask & ServiceManagerEventMask.AnyServiceConfig) != 0).ToString(),
((mask & ServiceManagerEventMask.AnyServiceStatus) != 0).ToString());
break;
case client.ChannelClosed() in clients:
{
// Dbg(TraceLevel.Audit, "A client client has disconnected.");
delete client;
break;
}
#endregion
#region Handlers for management clients in the ReadyWatchServiceManager state
// These event handlers are for management clients that have subscribed to the
// overall state of the Service Manager.
case client.WaitNextServiceManagerChange() in managerWatchersReady ~> watcher:
if (watcher.EventsMissed != 0) {
Dbg(TraceLevel.Audit, "Received 'WaitNextServiceManagerChange' on SM watcher, responding immediately with mask {0:x8}", ((uint)watcher.EventsMissed));
client.SendServiceManagerChanged(watcher.EventsMissed);
managerWatchersReady.Add(client, watcher);
}
else {
Dbg(TraceLevel.Audit, "Received 'WaitNextServiceManagerChange' on SM watcher; no events ready, parking endpoint.");
watcher.SetEndpoint(client);
}
break;
case client.StopWatchingServiceManager() in managerWatchersReady ~> watcher:
// The client wants to end its subscription to the Service Manager events.
managerWatchers.Remove(watcher);
watcher.Dispose();
clients.Add(client);
break;
#endregion
#region Handlers for 'svclients': ServiceManagerContract clients bound to a service
// These event handlers are for management clients that have connected, and
// have successfully selected a specific service.
case svclient.UnselectService() in svclients ~> service:
Dbg(TraceLevel.Audit, service, "Client has unselected service.");
clients.Add(svclient);
// -XXX- decrement reference count on service?
break;
case svclient.StartServiceNoWait() in svclients ~> service:
{
Dbg(TraceLevel.Audit, "Received StartServiceNoWait request for service '{0}.", service.ServiceName);
ServiceError error = StartServiceProcess(service);
if (error == ServiceError.None) {
Dbg(TraceLevel.Audit, service, " Request succeeded.");
svclient.SendServiceStarting();
}
else {
Dbg(TraceLevel.Audit, service, " Request failed: error = " + error);
svclient.SendRequestFailed(error);
}
svclients.Add(svclient, service);
PushService(service);
break;
}
case svclient.StartServiceWait() in svclients ~> service:
{
Dbg(TraceLevel.Audit, service, "Received StartServiceWait request for service '{0}'.", service.ServiceName);
ServiceError error = StartServiceProcess(service);
if (error == ServiceError.None) {
Dbg(TraceLevel.Audit, service, " Request succeeded. Parking endpoint in serviceStartWatchers.");
ServiceStartWatcher watcher = new ServiceStartWatcher(service, svclient);
serviceStartWatchers.Add(watcher);
}
else {
Dbg(TraceLevel.Audit, service, " Request failed: error = " + error);
svclient.SendRequestFailed(error);
svclients.Add(svclient, service);
}
PushService(service);
break;
}
case svclient.StopServiceNoWait() in svclients ~> service:
Dbg(TraceLevel.Audit, service, "Received request to stop service. Client does not want to be notified when service stops.");
ServiceError error = StopService(service);
if (error == ServiceError.None) {
svclient.SendServiceStopping();
}
else {
svclient.SendRequestFailed(error);
}
svclients.Add(svclient, service);
PushService(service);
break;
case svclient.StopServiceWait() in svclients ~> service:
Dbg(TraceLevel.Audit, service, "Received request to stop service. NYI");
svclient.SendRequestFailed(ServiceError.Unknown);
svclients.Add(svclient, service);
break;
case svclient.WatchServiceStatus() in svclients ~> service:
{
// A client wants to watch the status of a service.
// For now, we only allow watching services that exist.
// At some future point, we should allow subscriptions
// to services that do not exist. We should notifiy
// subscribers when the service is created, deleted, etc.
ServiceWatcher watcher = new ServiceWatcher(service);
service.StatusWatchers.Add(watcher);
svclient.SendOk();
clients_readywatch.Add(svclient, watcher);
Dbg(TraceLevel.Audit, service, "A client is now watching the status of a service.");
// -XXX- add reference to service?
break;
}
case svclient.DeleteService() in svclients ~> service:
ProcessDeleteServiceRequest(svclient, service);
svclients.Add(svclient, service);
break;
case svclient.QueryServiceConfig() in svclients ~> service:
{
ServiceConfig config = new ServiceConfig();
service.GetConfig(ref config);
svclient.SendCurrentServiceConfig(config);
svclients.Add(svclient, service);
break;
}
case svclient.QueryServiceStatus() in svclients ~> service:
{
InternalServiceStatus status = service.LastServiceStatusPublished;
ServiceStatus exstatus = status.ToExchange();
svclient.SendCurrentServiceStatus(exstatus);
svclients.Add(svclient, service);
break;
}
case svclient.ChannelClosed() in svclients ~> service:
// Dbg(TraceLevel.Audit, service, "A client that had selected this service has disconnected.");
delete svclient;
break;
case svclient.EnableService(bool enable) in svclients ~> service:
if (enable)
Dbg(TraceLevel.Audit, service, "A client wants to ENABLE the service.");
else
Dbg(TraceLevel.Audit, service, "A client wants to DISABLE the service.");
service.Config.IsAdministrativelyDisabled = !enable;
PushService(service);
svclient.SendOk();
svclients.Add(svclient, service);
break;
case svclient.TerminateServiceAllProcesses() in svclients ~> service:
{
Dbg(TraceLevel.Audit, service, "Received 'TerminateServiceAllProcesses'. Terminating all processes for this service.");
foreach (ServiceProcess! process in service.Processes) {
TerminateServiceProcess(process);
}
PushService(service);
svclient.SendOk();
svclients.Add(svclient, service);
break;
}
case svclient.TerminateServiceProcess(int processId) in svclients ~> service:
{
Dbg(TraceLevel.Audit, service, "Received 'TerminateServiceProcess' for process id {0}.", processId);
foreach (ServiceProcess! process in service.Processes) {
Process systemProcess = process.Process;
if (systemProcess != null && systemProcess.Id == processId) {
TerminateServiceProcess(process);
break;
}
}
PushService(service);
svclient.SendOk();
svclients.Add(svclient, service);
break;
}
#endregion
#region Handlers for 'clients_readywatch' endpoint map
// These event handlers are for clients that have subscribed to the
// status of a particular service.
case client.WaitServiceChange() in clients_readywatch ~> watcher:
{
// A client wants to receive the next status change.
Assert(!watcher.EndpointCanSend);
if (watcher.MissedChange) {
// The watcher missed the last update, because the watcher had not yet
// placed its channel in a state where the service manager could send
// a status update. So now we send a status update immediately.
Dbg(TraceLevel.Audit, watcher.Service, "Received WaitServiceChange - client missed an update; sending status now");
watcher.MissedChange = false;
InternalServiceStatus status = watcher.Service.LastServiceStatusPublished;
ServiceStatus exstatus = status.ToExchange();
client.SendServiceStatusChanged(exstatus, true);
clients_readywatch.Add(client, watcher);
}
else {
// The watcher wants an update. We move the endpoint from the local
// stack frame to the TRef in watcher, and mark the watcher as ready.
Dbg(TraceLevel.Audit, watcher.Service, "Received WaitServiceChange - watcher is now armed");
watcher.TakeEndpoint(client);
}
break;
}
case client.ChannelClosed() in clients_readywatch ~> watcher:
// Dbg(watcher.Service, "A client that was watching service status has disconnected.");
watcher.Service.StatusWatchers.Remove(watcher);
delete client;
break;
#endregion
#region Handlers for endpoints in 'clients_enumerating'
// These are the event handlers for ServiceManagerContract clients that
// are in the process of enumerating all services.
case client.EnumerateServices(ServiceInfo[]! in ExHeap infos) in clients_enumerating ~> enumerator:
EnumerateServiceInfos(client, infos, enumerator);
break;
case client.EndEnumeration() in clients_enumerating ~> enumerator:
Dbg(TraceLevel.Audit, "A client client has finished enumerating services.");
// There is no response message.
// enumerator.Dispose();
clients.Add(client);
break;
case client.ChannelClosed() in clients_enumerating ~> enumerator:
// Dbg(TraceLevel.Audit, "A client client has disconnected.");
// enumerator.Dispose();
delete client;
break;
#endregion
#region Wiring that allows us to know when ServiceStarter has completed.
case notifier.Succeeded() in service_starters ~> starter:
{
ServiceProcess! process = starter.Process;
Service! service = starter.Service;
Dbg(TraceLevel.Audit, process, "Worker thread has started service process. Now waiting for 'Success' message.");
assert process.State == ServiceProcessState.Starting;
assert process.Process == null;
delete notifier;
ServiceProcessContract.Imp:Starting! svcontrol;
ServiceEventContract.Exp:Ready! svevent;
Process! system_process;
starter.GetSuccessfulResults(out svcontrol, out svevent, out system_process);
process.SetProcess(system_process);
process.SetEventEndpoint(svevent);
svcontrols_starting.Add(svcontrol, process);
PushService(service);
break;
}
case notifier.Failed(error) in service_starters ~> starter:
{
// The notifier has already disposed of the process.
Service! service = starter.Service;
ServiceProcess! svprocess = starter.Process;
service.Processes.Remove(svprocess);
Dbg(TraceLevel.Audit, service, "Failed to start a service process. Error: {0}", error);
delete notifier;
service.LastStartError = error;
service.LastStartFailed = true;
service.LastStartFailedTime = SchedulerTime.Now;
PushService(service);
break;
}
#endregion
#region Handlers for 'svcontrols_starting'
// These handlers process messages that we receive from a "control" channel
// that we created for communicating with a service process.
//
// If process.IsTerminated is true when we receive a message on a control
// channel, then we have abandoned this process (or even terminated it), but
// because we cannot remove endpoints from endpoint maps, we can still receive
// a message from it. This could happen due to a race condition, or if the
// service transferred its control endpoint to a different process. In all
// cases, we must guard against receiving this message late.
case svcontrol.StartSucceeded() in svcontrols_starting ~> process:
{
// This message indicates that a service process has successfully started.
// We verify that we are still interested starting the service, and then
// we mark the service "Running", and then we check to see if there are
// any clients waiting to connect to the service.
Service! service = process.Service;
do {
if (process.State != ServiceProcessState.Starting) {
Dbg(TraceLevel.Audit, process, "Received 'StartSucceeded' from a process, but the process was abandoned earlier.");
Dbg(TraceLevel.Audit, process, "The process will be ignored, and the orphaned control channel will be closed.");
delete svcontrol;
break;
}
if (service.IsAdministrativelyDisabled) {
Dbg(TraceLevel.Audit, process, "The service was disabled after the service process was started.");
process.State = ServiceProcessState.Stopping;
process.NeedSendStopControl = true;
svcontrol.SendStop();
// -XXX- Need to set control endpoint state to Stopping
svcontrols_stopping.Add(svcontrol, process);
break;
}
Dbg(TraceLevel.Audit, process, "A service process has indicated that it has successfully started.");
if (process.State == ServiceProcessState.Starting) {
process.State = ServiceProcessState.Running;
if (process.EventEndpointIsReady) {
// Dbg(TraceLevel.Audit, process, "Binding service event channel.");
ServiceEventContract.Exp:Ready! svevent = process.GetEventEndpoint(EventChannelState.WaitingEvent);
svevents.Add(svevent, process);
}
else {
Dbg(TraceLevel.Audit, process, "Warning: No event channel was available for this service process.");
}
process.State = ServiceProcessState.Running;
process.SetControlEndpoint(svcontrol);
Dbg(TraceLevel.Audit, process, "The service process is now running.");
}
else if (process.State == ServiceProcessState.Running) {
Dbg(TraceLevel.Audit, process, "Received 'StartSucceeded' from a process, but it is already in the running state!");
Dbg(TraceLevel.Audit, process, "This should never happen.");
Util.IllegalStateReached();
process.SetControlEndpoint(svcontrol);
}
else {
Dbg(TraceLevel.Audit, process, "Illegal value for ServiceProcessState!");
Util.IllegalStateReached();
delete svcontrol;
}
} while (false);
PushService(service);
break;
}
case svcontrol.StartFailed(ServiceError error) in svcontrols_starting ~> process:
{
// This message indicates that a service process tried to start (initialize),
// but something went wrong, and so the service process cannot be used.
// In this case, we mark the service process as "defective", and close all
// channels to it. It's not yet clear what we should do with the process --
// wait for it to exit? terminate it immediately?
Service! service = process.Service;
switch (process.State) {
case ServiceProcessState.Starting:
Dbg(TraceLevel.Audit, process, "Received 'StartFailed'; service indicates that it has failed to start.");
process.State = ServiceProcessState.Stopping;
service.LastStartFailed = true;
service.LastStartFailedTime = SchedulerTime.Now;
MarkProcessDefective(process);
FailAllConnectRequests(service, ErrorCode.Unknown);
break;
case ServiceProcessState.Running:
// This should never happen.
Dbg(TraceLevel.Audit, process, "Received 'StartFailed' from a service, but we believe the service is already running.");
Util.IllegalStateReached();
break;
case ServiceProcessState.Stopping:
// We started a service process, and then changed our minds.
// This is a rare, but normal (acceptable) situation.
Dbg(TraceLevel.Audit, process, "Received 'StartFailed' from a service. We had already abandoned this service process, so no big deal.");
break;
default:
Util.IllegalStateReached();
break;
}
delete svcontrol;
process.CloseControlEndpoint();
PushService(process.Service);
break;
}
#endregion
#region Handlers for 'svcontrols_knocking'
case svcontrol.Alive() in svcontrols_knocking ~> process:
Dbg(TraceLevel.Audit, process, "Received 'Alive' from service.");
process.SetControlEndpoint(svcontrol);
PushService(process.Service);
break;
case svcontrol.ChannelClosed() in svcontrols_knocking ~> process:
Dbg(TraceLevel.Audit, process, "A service has closed its control channel unexpectedly.");
delete svcontrol;
MarkProcessDefective(process);
process.CloseControlEndpoint();
PushService(process.Service);
break;
#endregion
#region Event handlers for 'svcontrols_stopping'
case svcontrol.AckStop() in svcontrols_stopping ~> process:
{
// A service process has acknowledged the Service Manager's request
// to stop the process. We leave the process in the "stopping" state;
// later, when the process terminates, we'll remove the process from
// the process list for this service.
Dbg(TraceLevel.Audit, process, "Received 'AckStop' from service process.");
Assert(process.State == ServiceProcessState.Stopping);
delete svcontrol;
PushService(process.Service);
break;
}
case svcontrol.Busy() in svcontrols_stopping ~> process:
Dbg(TraceLevel.Audit, process, "Received 'Busy' from a service process that we are trying to stop.");
Dbg(TraceLevel.Audit, process, "Not sure what to do with this process!");
process.SetControlEndpoint(svcontrol);
PushService(process.Service);
break;
#endregion
#region Event handlers for 'svcontrols_connecting'
case svcontrol.AckConnect() in svcontrols_connecting ~> process:
{
if (process.State == ServiceProcessState.Running) {
Dbg(TraceLevel.Audit, process, "Received 'AckConnect' from service process.");
if (process.HasCurrentConnectDir) {
SchedulerTime timeStarted;
SchedulerTime timeRoutedToService;
DirectoryServiceContract.Exp:Ready! dir;
string! subpath;
DirectoryClientInfo! dirinfo;
process.GetCurrentConnectDir(out dir, out dirinfo, out subpath, out timeStarted, out timeRoutedToService);
dir.SendAckBind();
SchedulerTime timeFinished = SchedulerTime.Now;
dirs.Add(dir, dirinfo);
TimeSpan elapsed = timeFinished - timeStarted;
Dbg(TraceLevel.Audit, process, "Routing AckBind response to dir client. Service time: {0}", elapsed.ToString());
}
else {
Dbg(TraceLevel.Audit, process, "No current connect dir is set!! Cannot route bind response!");
DebugStub.Break();
}
}
else {
Dbg(TraceLevel.Audit, process, "Received 'AckConnect' from service process, but the process is stopping. Message will be ignored.");
}
process.SetControlEndpoint(svcontrol);
PushService(process.Service);
break;
}
case svcontrol.NakConnect(ErrorCode error, ServiceContract.Exp:Start exp) in svcontrols_connecting ~> process:
{
Dbg(TraceLevel.Audit, process, "Received 'NakConnect' from service, error = ", SdsUtils.ErrorCodeToString(error));
delete exp;
if (process.HasCurrentConnectDir) {
SchedulerTime timeStarted;
SchedulerTime timeRoutedToService;
DirectoryServiceContract.Exp:Ready! dir;
string! subpath;
DirectoryClientInfo! dirinfo;
process.GetCurrentConnectDir(out dir, out dirinfo, out subpath, out timeStarted, out timeRoutedToService);
dir.SendNakBind(null, error);
SchedulerTime now = SchedulerTime.Now;
TimeSpan elapsed = now - timeStarted;
Dbg(TraceLevel.Audit, process, "Routing NakBind response to client. Time elapsed: " + elapsed.ToString());
dirs.Add(dir, dirinfo);
}
else {
Dbg(TraceLevel.Audit, process, "No current connect dir is set!! Cannot route bind response!");
DebugStub.Break();
}
process.SetControlEndpoint(svcontrol);
PushService(process.Service);
break;
}
case svcontrol.ChannelClosed() in svcontrols_connecting ~> process:
Dbg(TraceLevel.Audit, process, "A service has closed its control channel unexpectedly.");
delete svcontrol;
MarkProcessDefective(process);
PushService(process.Service);
break;
#endregion
#region Handlers for events received from services
// These event handlers receive messages on an "event" channel that we have
// set up between the Service Manager and a service process. All of these
// handlers verify that we still want to receive these messages, by checking
// that process.State == ServiceProcessState.Running. We do this because
// we cannot currently remove endpoints from EMaps or ESets. Once the
// Service Manager has decided to tear down a service process, it sets the
// process state to Stopping, which is the cue for these event handlers to
// avoid processing received messages, and then to close the event channel.
case svevent.HealthChanged(ServiceHealth health) in svevents ~> process:
{
if (process.State == ServiceProcessState.Running) {
Dbg(TraceLevel.Audit, process, "Received 'HealthChanged' from service process, health = {0}", ServiceEnums.ToString(health));
process.Health = health;
svevent.SendAck();
svevents.Add(svevent, process);
}
else {
Dbg(TraceLevel.Audit, process, "Received 'HealthChanged' message, but on an orphaned event channel. Closing channel.");
process.CloseEventEndpoint();
svevent.SendAck();
delete svevent;
}
PushService(process.Service);
break;
}
case svevent.LoadChanged(ServiceLoad load) in svevents ~> process:
{
if (process.State == ServiceProcessState.Running) {
Dbg(TraceLevel.Audit, process, "Received 'LoadChanged' from service process, load = {0}", ServiceEnums.ToString(load));
process.Load = load;
svevent.SendAck();
svevents.Add(svevent, process);
}
else {
Dbg(TraceLevel.Audit, process, "Received 'LoadChanged' message, but on an orphaned event channel. Closing channel.");
process.CloseEventEndpoint();
svevent.SendAck();
delete svevent;
}
PushService(process.Service);
break;
}
case svevent.ChannelClosed() in svevents ~> process:
{
if (process.State == ServiceProcessState.Running) {
Dbg(TraceLevel.Audit, process, "A service process has unexpectedly closed its event channel!");
Dbg(TraceLevel.Audit, process, "The Service Manager will no longer be able to receive event messages from the service process.");
process.CloseEventEndpoint();
}
else {
Dbg(TraceLevel.Audit, process, "A service process has closed its event channel, as expected.");
process.CloseEventEndpoint();
}
delete svevent;
break;
}
#endregion
#region Handlers for DirectoryServiceContract
// The Service Manager does not support most of the requests defined by
// DirectoryServiceContract. The only requests supported are Bind
// and the enumeration pattern.
case dir.Bind(char[]! in ExHeap expath, ServiceContract.Exp:Start! exp) in dirs ~> dirinfo:
{
SchedulerTime timeStarted = SchedulerTime.Now;
string! path = Bitter.ToString2(expath);
delete expath;
Dbg(TraceLevel.Audit, dirinfo, "Received Bind('{0}').", path);
string! serviceName;
string! subpath;
int start = 0;
if (path.Length > 0 && path[0] == '/')
start++;
int index = path.IndexOf('/', start);
if (index != -1) {
serviceName = path.Substring(start, index);
subpath = path.Substring(index + 1);
}
else {
serviceName = path.Substring(start);
subpath = "";
}
Service service = FindService(serviceName);
if (service == null) {
Dbg(TraceLevel.Audit, dirinfo, "There is no service named '{0}'. Rejecting bind.", serviceName);
dir.SendNakBind(exp, ErrorCode.NotFound);
dirs.Add(dir, dirinfo);
break;
}
if (service.IsAdministrativelyDisabled) {
Dbg(TraceLevel.Audit, dirinfo, "The service '{0}' is administratively disabled. Rejecting bind.", service.ServiceName);
dir.SendNakBind(exp, ErrorCode.AccessDenied);
dirs.Add(dir, dirinfo);
break;
}
if (service.IsDefective) {
Dbg(TraceLevel.Audit, dirinfo, "The service '{0}' is currently considered defective. Rejecting bind.", service.ServiceName);
dir.SendNakBind(exp, ErrorCode.AccessDenied);
dirs.Add(dir, dirinfo);
break;
}
Dbg(TraceLevel.Audit, dirinfo, "Enqueuing connect request for service '{0}' at subpath '{1}'.", service.ServiceName, subpath);
service.EnqueueConnectRequest(dir, dirinfo, subpath, exp, timeStarted);
PushService(service);
break;
}
case dir.BeginEnumeration() in dirs ~> dirinfo:
{
// The only "path" that we support is the root directory.
if (dirinfo.Path != "/") {
Dbg(TraceLevel.Audit, "A directory client wants to enumerate, but at a bogus path '{0}'.", dirinfo.Path);
dir.SendEnumerationTerminated(ErrorCode.NotFound);
dirs.Add(dir, dirinfo);
break;
}
Service[]! snapshot = GetServicesSnapshot();
EnumerationRecords[]! in ExHeap results = new[ExHeap] EnumerationRecords[snapshot.Length];
for (int i = 0; i < snapshot.Length; i++) {
Service! service = (!)snapshot[i];
expose(results[i]) {
delete results[i].Path;
results[i].Path = Bitter.FromString2(service.ServiceName);
results[i].Type = NodeType.ServiceProvider;
}
}
dir.SendEnumerationEntries(results, false);
dirs_enumerating.Add(dir, dirinfo);
break;
}
case dir.ReadEnumeration() in dirs_enumerating ~> dirinfo:
// We already sent everything in the first request.
// So this is a no-op.
dir.SendEnumerationTerminated(ErrorCode.NoError);
dirs.Add(dir, dirinfo);
break;
case dir.EndEnumeration() in dirs_enumerating ~> dirinfo:
dirs.Add(dir, dirinfo);
break;
case dir.ChannelClosed() in dirs_enumerating ~> dirinfo:
delete dir;
break;
case dir.Notify(path, pattern, existing, imp) in dirs ~> dirinfo:
delete path;
delete pattern;
dir.SendNakNotify(imp, ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.GetAttributes(path) in dirs ~> dirinfo:
delete path;
dir.SendNakGetAttributes(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.QueryACL(path, effective) in dirs ~> dirinfo:
delete path;
dir.SendNakQueryACL(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.Register(path, imp) in dirs ~> dirinfo:
delete path;
dir.SendNakRegister(imp, ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.Deregister(path) in dirs ~> dirinfo:
delete path;
dir.SendNakDeregister(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.CreateDirectory(path) in dirs ~> dirinfo:
delete path;
dir.SendNakCreateDirectory(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.DeleteDirectory(path) in dirs ~> dirinfo:
delete path;
dir.SendNakDeleteDirectory(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.CreateFile(path) in dirs ~> dirinfo:
delete path;
dir.SendNakCreateFile(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.CreateAndBindFile(path, exp) in dirs ~> dirinfo:
delete path;
dir.SendNakCreateAndBindFile(exp, ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.DeleteFile(path) in dirs ~> dirinfo:
delete path;
dir.SendNakDeleteFile(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.StoreACL(path, pattern, descendantPattern) in dirs ~> dirinfo:
delete path;
delete pattern;
delete descendantPattern;
dir.SendNakStoreACL(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.CreateLink(path, value) in dirs ~> dirinfo:
delete path;
delete value;
dir.SendNakCreateLink(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.DeleteLink(path) in dirs ~> dirinfo:
delete path;
dir.SendNakDeleteLink(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
case dir.GetLinkValue(path) in dirs ~> dirinfo:
delete path;
dir.SendNakGetLinkValue(ErrorCode.NotSupported);
dirs.Add(dir, dirinfo);
break;
#endregion
case timeout(TimeSpan.FromSeconds(30)):
// For now, we pop out of our select now and then, to check for
// changes in the status of child processes, etc. Need a better
// way to do this. Don't print anything here; too noisy.
PushAllServices();
break;
}
}
}
}
/// <summary>
/// This method marks a process as "defective", which prevents new clients from being routed
/// to the process. The Service Manager closes all of its endpoints (if possible; some endpoints
/// may be in endpoint maps, and so they will not be closed until a message is later received).
/// </summary>
void MarkProcessDefective(ServiceProcess! process)
{
Dbg(TraceLevel.Audit, process, "Marking process as defective.");
process.IsDefective = true;
process.CloseControlEndpoint();
process.CloseEventEndpoint();
// If there was a DirectoryServiceContract client who had requested a bind,
// and that client had been routed to this service process, then extract the
// DirectoryServiceContract endpoint and complete the bind request with an error.
if (process.HasCurrentConnectDir) {
DirectoryServiceContract.Exp:Ready! dir;
DirectoryClientInfo! dirinfo;
process.GetCurrentConnectDir(out dir, out dirinfo);
dir.SendNakBind(null, ErrorCode.Unknown);
expose (this) { dirs.Add(dir, dirinfo); }
}
}
/// <summary>
/// This method is called whenever a global Service Manager event has occurred, which includes:
///
/// * The status of any service has changed.
/// * The configuration of any service has changed.
/// * A service has been created.
/// * A service has been deleted.
///
/// These events are mapped to bits within ServiceManagerEventMask. All of the "status"
/// events map to ServiceManagerEventMask.AnyServiceStatus, and all of the "config" events
/// map to ServiceManagerEventMask.AnyServiceConfig.
///
/// No attempt is made to notify watchers of the specifics of these events. Doing so requires
/// keeping track of much more state. If a management client wants to know about details, it
/// should query the Service Manager after being notified of a status or config change.
/// </summary>
void NotifyServiceManagerWatchers(ServiceManagerEventMask events)
{
if (events == 0)
return;
expose(this) {
foreach (ServiceManagerWatcher! watcher in managerWatchers) {
// If a watcher endpoint is available, then we send a notification message
// immediately. If the watcher endpoint is not available, which typically
// will occur when SM events occur more quickly than a watcher can acknowledge
// them, we set bits in the watcher's EventsMissed mask. Later, when the
// watcher acknowledges a previous notification, it will be immediately
// notified with the events in the EventsMissed mask.
// Only consider those events that this watcher has subscribed to.
ServiceManagerEventMask events_relevant = (events & watcher.DesiredEvents);
if (events_relevant == 0)
continue;
if (watcher.IsEndpointReady) {
Dbg(TraceLevel.Audit, "Sending ServiceManagerChanged to global watcher");
ServiceManagerContract.Exp:WaitingServiceManagerChange! ep = watcher.GetEndpoint();
ep.SendServiceManagerChanged(events_relevant);
managerWatchersReady.Add(ep, watcher);
}
else {
Dbg(TraceLevel.Audit, "A global watcher is not ready to receive events; marking for later delivery.");
watcher.EventsMissed = watcher.EventsMissed | events_relevant;
}
}
}
}
void ProcessDeleteServiceRequest(
ServiceManagerContract.Exp! svclient,
Service! service)
{
Dbg(TraceLevel.Audit, service, "Received request to delete service.");
if (service.IsMarkedForDeletion) {
Dbg(TraceLevel.Audit, service, "The service is already marked for deletion; rejecting request.");
svclient.SendRequestFailed(ServiceError.ServiceIsMarkedForDeletion);
return;;
}
if (service.IsDeleted) {
Dbg(TraceLevel.Audit, service, "The service is already deleted; rejecting request.");
svclient.SendRequestFailed(ServiceError.ServiceIsDeleted);
return;
}
service.IsMarkedForDeletion = true;
svclient.SendOk();
// We may not be able to delete the service yet.
bool can_delete_now = true;
if (service.Processes.Count != 0) {
Dbg(TraceLevel.Audit, service, "Cannot delete service yet; still have service processes.");
can_delete_now = false;
StopService(service);
}
if (can_delete_now) {
service.IsDeleted = true;
services.Remove(service.ServiceName);
Dbg(TraceLevel.Audit, service, "The service has been deleted.");
}
else {
Dbg(TraceLevel.Audit, service, "The service has been marked for deletion.");
}
PushService(service);
}
void DeleteServiceProcessResources(ServiceProcess! process)
{
expose(this) {
Dbg(TraceLevel.Audit, process, "DeleteServiceProcessResources - deleting service process resources");
if (process.HasCurrentConnectDir) {
Dbg(TraceLevel.Audit, process, " A connect request was active. Rejecting bind.");
DirectoryServiceContract.Exp:Ready! dir;
DirectoryClientInfo! dirinfo;
string! subpath;
process.GetCurrentConnectDir(out dir, out dirinfo);
dir.SendNakBind(null, ErrorCode.Unknown);
dirs.Add(dir, dirinfo);
}
if (process.ControlEndpointIsReady) {
Dbg(TraceLevel.Audit, process, "Closing control channel");
ServiceProcessContract.Imp! svcontrol = process.GetControlEndpoint(ControlEndpointState.Disconnected);
delete svcontrol;
}
}
}
/// <summary>
/// For a particular service, this method checks to see if there is any reason to send
/// a message to the control channel of a service. Control messages
/// </summary>
void PushControlMessages(ServiceProcess! process)
{
expose (this) {
Service! service = process.Service;
if (!process.ControlEndpointIsReady) {
// If the control endpoint is not ready, there's nothing we can do here.
Dbg(TraceLevel.Audit, process, "PushControlMessages - control endpoint is not ready");
return;
}
switch (process.State) {
case ServiceProcessState.Starting:
// We don't have a control endpoint in this state.
break;
case ServiceProcessState.Running:
{
// Here is where we would check for things like polling service health.
// The order of these checks would determine the priority of the requests
// being sent to the control channel.
if (service.IsAdministrativelyDisabled) {
Dbg(TraceLevel.Audit, process, "PushControlMessages - service is disabled, cannot send messages to it");
return;
}
break;
}
case ServiceProcessState.Stopping:
{
if (process.NeedSendStopControl) {
Dbg(TraceLevel.Audit, process, "PushControlMessages - sending Stop message to service.");
ServiceProcessContract.Imp:Running! svcontrol = process.GetControlEndpoint(ControlEndpointState.Stopping);
svcontrol.SendStop();
svcontrols_stopping.Add(svcontrol, process);
process.NeedSendStopControl = false;
return;
}
break;
}
}
Dbg(TraceLevel.Audit, process, "PushControlMessages - no work to do");
}
}
void PushAllServices()
{
foreach (Service! service in (!)services.Values) {
PushService(service);
}
}
/// <summary>
/// This method checks the state of a service, and generally advances that state
/// toward its goal state. It's easier and more reliable to do this in a single
/// method, and to run this method when we believe something relevant to this
/// service has happened, rather than using a lot of methods that check specific
/// aspects of the service (e.g. pushing the connect queue).
///
/// This method:
///
/// * Starts a new service process, if necessary.
/// * Dequeues connection requests and forwards them to service processes.
/// * Determines the "next think time", which is the next time that we need
/// to reexamine the state of this service, without receiving a message
/// that drives the state of the service.
///
/// This method needs to be efficient, since it is called from many places, and
/// is called at the end of many different event handlers.
/// </summary>
void PushService(Service! service)
{
Assert(service.Config.MinProcesses <= service.Config.MaxProcesses);
// If we tried to start this service before, and some problem occurred when
// trying to start a service process, then check to see if enough time has
// passed that we can clear this error.
if (service.LastStartFailed) {
SchedulerTime now = SchedulerTime.Now;
TimeSpan elapsed = now - service.LastStartFailedTime;
if (elapsed > ForgetLastStartFailedInterval) {
Dbg(TraceLevel.Audit, service, "Clearing 'last start' error.");
service.LastStartFailed = false;
service.LastStartError = ServiceError.None;
service.LastStartFailedTime = new SchedulerTime();
}
}
// Scan all of the processes for this service. Count how many are in different
// states; this is interesting for several reasons that follow. The only state
// transition that we do here is to send a Stop() message to those processes
// that are already in the Stopping state, and have not yet received a Stop()
// message. All other work per process depends on whether the service is
// administratively disabled or not.
int processes_running = 0;
int processes_running_control_ready = 0;
int processes_starting = 0;
int processes_stopping = 0;
foreach (ServiceProcess! process in service.Processes) {
switch (process.State) {
case ServiceProcessState.Starting:
processes_starting++;
break;
case ServiceProcessState.Running:
processes_running++;
if (process.ControlEndpointIsReady)
processes_running_control_ready++;
break;
case ServiceProcessState.Stopping:
processes_stopping++;
if (process.NeedSendStopControl && process.ControlEndpointIsReady) {
Dbg(TraceLevel.Audit, process, "Sending 'Stop' request to process.");
process.NeedSendStopControl = false;
ServiceProcessContract.Imp! svcontrol = process.GetControlEndpoint(ControlEndpointState.Stopping);
svcontrol.SendStop();
expose (this) { svcontrols_stopping.Add(svcontrol, process); }
}
break;
}
}
if (!service.IsAdministrativelyDisabled) {
// Set to true if we want to start a new service process.
bool want_start_process = false;
int min_processes = service.Config.MinProcesses;
switch (service.Config.ActivationMode) {
case ServiceActivationMode.AlwaysActive:
// This service is always supposed to be active.
// Check to see if there are any services running.
min_processes = Math.Min(service.Config.MinProcesses, 1);
if (processes_running < min_processes) {
if (service.Processes.Count < service.Config.MaxProcesses) {
if (processes_starting == 0) {
Dbg(TraceLevel.Audit, service, "Need more running processes for always-active service.");
want_start_process = true;
}
else {
Dbg(TraceLevel.Audit, service, "Need to start another process for always-active service, but one is already starting.");
}
}
else {
Dbg(TraceLevel.Audit, service, "Need more running processes, but total number of processes has reached maximum.");
}
}
else {
Dbg(TraceLevel.Audit, service, "Number of processes running ({0}) is >= min processes ({1})", processes_running, min_processes);
}
break;
case ServiceActivationMode.Demand:
if (service.HasConnectRequests) {
if (processes_running_control_ready != 0) {
// At least one process is immediately available for a connect request.
// No need to start another.
}
else {
if (service.Processes.Count < service.Config.MaxProcesses) {
Dbg(TraceLevel.Audit, service, "Need more processes for demand-activated service.");
want_start_process = true;
}
}
}
break;
case ServiceActivationMode.Manual:
// Management clients have control over the lifetime of this service.
// We never create processes for the service without being instructed
// by a management client.
break;
}
if (want_start_process) {
if (processes_starting != 0) {
Dbg(TraceLevel.Audit, "Want to start another process, but cannot do so right now; another process is starting.");
}
else {
StartServiceProcess(service);
}
}
PushConnectQueue(service);
}
else {
// This service is disabled.
FailAllConnectRequests(service, ErrorCode.Unknown);
foreach (ServiceProcess! process in service.Processes) {
switch (process.State) {
case ServiceProcessState.Starting:
case ServiceProcessState.Running:
process.State = ServiceProcessState.Stopping;
process.NeedSendStopControl = true;
goto case ServiceProcessState.Stopping;
case ServiceProcessState.Stopping:
if (process.NeedSendStopControl && process.ControlEndpointIsReady) {
Dbg(TraceLevel.Audit, process, "Sending 'Stop' request to process.");
process.NeedSendStopControl = false;
ServiceProcessContract.Imp! svcontrol = process.GetControlEndpoint(ControlEndpointState.Stopping);
svcontrol.SendStop();
expose (this) { svcontrols_stopping.Add(svcontrol, process); }
}
break;
}
}
}
//
// This method has now completed any necessary changes in the state of the service.
// Next, build a new ServiceStatus (actually, InternalServiceStatus), which represents
// a brief summary of the status of the service. Then we will compare that to the last
// status that we published to service status watchers. If there is any change, then
// we will update the "last published" status, notify any watchers that are read to
// receive an update, and for those that are not ready, we record the fact that they
// missed an update.
//
ServiceState service_state;
if (processes_running != 0)
service_state = ServiceState.Running;
else if (processes_starting != 0)
service_state = ServiceState.Starting;
else if (processes_stopping != 0)
service_state = ServiceState.Stopping;
else
service_state = ServiceState.Stopped;
InternalServiceStatus status;
status.State = service_state;
status.TotalActiveClients = -1;
status.ConnectQueueLength = service.ConnectQueueLength;
status.TotalActiveProcesses = service.Processes.Count;
status.ProcessId = -1;
status.LastStartFailed = service.LastStartFailed;
status.LastStartError = service.LastStartError;
if (service.Processes.Count != 0) {
// For now, return the first process.
ServiceProcess! firstProcess = (ServiceProcess!)service.Processes[0];
Process firstSystemProcess = firstProcess.Process;
if (firstSystemProcess != null && firstSystemProcess.State == ProcessState.Active) {
status.ProcessId = firstSystemProcess.Id;
}
}
//
// Compare the last and current status, field by field.
//
bool status_changed = !InternalServiceStatus.IsEqual(ref status, ref service.LastServiceStatusPublished);
if (status_changed) {
Dbg(TraceLevel.Audit, service, "Service status has changed.");
InternalServiceStatus last_status = service.LastServiceStatusPublished;
service.LastServiceStatusPublished = status;
if (last_status.State != status.State)
Dbg(TraceLevel.Audit, service, " State {0} -> {1}", ServiceEnums.ToString(last_status.State), ServiceEnums.ToString(status.State));
if (last_status.TotalActiveProcesses != status.TotalActiveProcesses)
Dbg(TraceLevel.Audit, service, " TotalActiveProcesses {0} -> {1}", last_status.TotalActiveProcesses, status.TotalActiveProcesses);
if (last_status.ConnectQueueLength != status.ConnectQueueLength)
Dbg(TraceLevel.Audit, service, " ConnectQueueLength {0} -> {1}", last_status.ConnectQueueLength, status.ConnectQueueLength);
if (last_status.ProcessId != status.ProcessId)
Dbg(TraceLevel.Audit, service, " ProcessId {0} -> {1}", last_status.ProcessId, status.ProcessId);
if (last_status.LastStartFailed != status.LastStartFailed)
Dbg(TraceLevel.Audit, service, " LastStartFailed {0} -> {1}", last_status.LastStartFailed, status.LastStartFailed);
if (last_status.LastStartError != status.LastStartError)
Dbg(TraceLevel.Audit, service, " LastStartError {0} -> {1}", ServiceEnums.ToString(last_status.LastStartError), ServiceEnums.ToString(status.LastStartError));
// Scan through the set of service watchers for this service, and
// send changes of status to each.
ServiceStatus exstatus = status.ToExchange();
foreach (ServiceWatcher! watcher in service.StatusWatchers) {
if (watcher.EndpointCanSend) {
// The watcher is ready for a message. Send the status message
// to the client, and then put the client into an endpoint map,
// so we can receive it's ack message later.
ServiceManagerContract.Exp:WaitingServiceChange! client = watcher.AcquireEndpoint();
client.SendServiceStatusChanged(exstatus, false);
expose (this) { clients_readywatch.Add(client, watcher); }
}
else {
// The watcher is not ready to receive a message. Mark the
// watcher as having missed an update, and continue. Later,
// when the watcher sends WaitStatusChange, we'll immediately
// send a service status notification.
Dbg(TraceLevel.Audit, service, "Watcher is not ready for status update. Marking as 'missed change'.");
watcher.MissedChange = true;
}
}
// If the service was starting, then there may be clients that want to be
// informed when the service is no longer starting (whether it succeeded
// or failed).
NotifyServiceManagerWatchers(ServiceManagerEventMask.AnyServiceStatus);
}
}
/// <summary>
/// This method tries to match up clients who want to connect with the service
/// to available service processes. If necessary, it will schedule the creation
/// of a new service process.
/// </summary>
void PushConnectQueue(Service! service)
{
if (!service.HasConnectRequests)
return;
if (service.IsAdministrativelyDisabled) {
Dbg(TraceLevel.Audit, service, "PushConnectQueue - service is disabled, flushing queue");
FailAllConnectRequests(service, ErrorCode.AccessDenied);
return;
}
if (service.IsDefective) {
Dbg(TraceLevel.Audit, service, "PushConnectQueue - service is currently believed to be defective, flushing queue");
FailAllConnectRequests(service, ErrorCode.Unknown);
return;
}
// We treat all of our connection requests identically, so we don't bother
// to dequeue one until we have located a service process that can handle it.
while (service.HasConnectRequests) {
ServiceProcess bestProcess = null;
// bool found_running_service = false;
bool found_starting_service = false;
foreach (ServiceProcess! candidate in service.Processes) {
if (candidate.State == ServiceProcessState.Running) {
// found_running_service = true;
if (candidate.ControlEndpointIsReady && !candidate.HasCurrentConnectDir) {
// This service process is running, and so it is a candidate.
// Check to see if this process is a better candidate (has
// a lower load level) than the previous process.
if (bestProcess != null) {
int diff = CompareServiceLoads(bestProcess, candidate);
if (diff > 0)
bestProcess = candidate;
}
else {
bestProcess = candidate;
}
}
else {
// This service is busy processing a control message.
// Keep searching for another service process, if possible.
}
}
else if (candidate.State == ServiceProcessState.Starting) {
found_starting_service = true;
}
else if (candidate.State == ServiceProcessState.Stopping) {
// ignore services in the stopping state
}
else {
// illegal state!
Util.IllegalStateReached();
}
}
if (bestProcess != null) {
ServiceProcess! process = bestProcess;
Dbg(TraceLevel.Audit, process, "PushConnectQueue - Forwarding client connection request to process");
// Dequeue the connection request.
DirectoryServiceContract.Exp:Ready! dir;
DirectoryClientInfo! dirinfo;
string! subpath;
ServiceContract.Exp:Start! channel;
SchedulerTime timeStarted;
ServiceConnectRequest! connect = service.DequeueConnectRequest();
RecycleServiceConnectRequest(connect, out dir, out dirinfo, out subpath, out channel, out timeStarted);
// Acquire the control channel.
ServiceProcessContract.Imp! svcontrol = process.GetControlEndpoint(ControlEndpointState.Connecting);
char[] in ExHeap exsubpath = (subpath != null && subpath.Length != 0) ? Bitter.FromString2(subpath) : null;
svcontrol.SendConnect(exsubpath, channel);
expose(this) { svcontrols_connecting.Add(svcontrol, process); }
process.SetCurrentConnectDir(dir, dirinfo, subpath, timeStarted);
// Progress continues when:
// we receive AckConnect from service process
// we receive NakConnect from service process
}
else {
// There are no service processes that can immediately accept the client.
// Next, we decide what to do, based on whether we found any processes in
// the running state, starting state, defective, etc.
//
// If we found *any* process in the "starting" state, then we believe:
// * that there is reason to believe that the process will start,
// * that the process will service the connect queue once started,
// * that no other processes are in the "starting" state, so we
// cannot start any new processes.
//
// In this situation, there is nothing more we can do here. Stop now.
if (found_starting_service) {
Dbg(TraceLevel.Audit, service, "PushConnectQueue - Connect request must wait for service to start.");
break;
}
// No processes are starting. Are we allowed to start any new processes?
if (service.Processes.Count >= service.Config.MaxProcesses) {
// No, cannot start any new processes. Did we fail to start a process last
// time around? If so, then we should clear the entire queue and bail.
break;
}
if (service.Processes.Count < service.Config.MaxProcesses) {
Dbg(TraceLevel.Audit, service, "PushConnectQueue - Starting new service process...");
StartServiceProcess(service);
break;
}
Dbg(TraceLevel.Audit, service, "PushConnectQueue - Cannot forward client connection request yet.");
break;
}
}
}
/// <summary>
/// Compares two services, and selects the one with the best (lightest) load level.
/// </summary>
int CompareServiceLoads(ServiceProcess! left, ServiceProcess! right)
{
return 0;
}
void FailAllConnectRequests(Service! service, ErrorCode error)
{
expose(this) {
while (service.HasConnectRequests) {
DirectoryServiceContract.Exp:Ready! dir;
DirectoryClientInfo! dirinfo;
string! subpath;
ServiceContract.Exp:Start! channel;
SchedulerTime timeStarted;
ServiceConnectRequest! connect = service.DequeueConnectRequest();
RecycleServiceConnectRequest(connect, out dir, out dirinfo, out subpath, out channel, out timeStarted);
Dbg(TraceLevel.Audit, dirinfo, "Connect request for service '{0}', subpath '{1}' has failed, error = {2}.",
service.ServiceName,
subpath,
SdsUtils.ErrorCodeToString(error));
dir.SendNakBind(channel, error);
dirs.Add(dir, dirinfo);
}
}
}
Service[]! GetServicesSnapshot()
{
if (servicesSnapshot != null)
return servicesSnapshot;
Service[]! array = new Service[((!)services.Values).Count];
services.Values.CopyTo(array, 0);
servicesSnapshot = array;
return array;
}
void InvalidateServiceSnapshot()
{
servicesSnapshot = null;
}
void EnumerateServiceInfos(
[Claims]ServiceManagerContract.Exp! client,
[Claims]ServiceInfo[]! in ExHeap infos,
IEnumerator/*<Service>*/! enumerator)
{
int count = 0;
while (count < infos.Length && enumerator.MoveNext()) {
Service service = (Service)enumerator.Current;
Assert(service != null);
assert service != null;
// Dbg(TraceLevel.Audit, "Enumerating service entry - " + service.ServiceName);
expose (infos[count]) {
service.GetConfig(ref infos[count].Config);
infos[count].Status = service.LastServiceStatusPublished.ToExchange();
}
count++;
}
expose (this) {
if (count > 0) {
client.SendNextServiceInfo(infos, count);
clients_enumerating.Add(client, enumerator);
}
else {
// -XXX- enumerator.Dispose();
client.SendEnumerationTerminated(infos, count);
clients.Add(client);
}
}
}
ServiceError StartServiceProcess(Service! service)
{
if (service.IsAdministrativelyDisabled) {
Dbg(TraceLevel.Audit, service, "Cannot start service. It is disabled.");
return ServiceError.ServiceIsAdministrativelyDisabled;
}
if (service.IsDefective) {
Dbg(TraceLevel.Audit, service, "Cannot start a new service process. The service is currently believed to be defective.");
return ServiceError.ServiceIsDefective;
}
// Search the list of processes for this service.
// If any of them are in the Running state, then there is no need to start
// a new service process.
foreach (ServiceProcess! process in service.Processes) {
switch (process.State) {
case ServiceProcessState.Starting:
Dbg(TraceLevel.Audit, service, "Process {0} is already starting. No need to start another.", process);
return ServiceError.ServiceIsAlreadyStarting;
case ServiceProcessState.Running:
Dbg(TraceLevel.Audit, service, "Process {0} is already running. No need to start another.", process);
return ServiceError.ServiceIsAlreadyRunning;
case ServiceProcessState.Defective:
Dbg(TraceLevel.Audit, service, "Process {0} is defective. Cannot yet start another process.", process);
return ServiceError.None;
case ServiceProcessState.Stopping:
Dbg(TraceLevel.Audit, service, "Process {0} is stopping. Will ignore this process.", process);
break;
default:
throw new Exception("Invalid service process state");
}
}
if (service.Config.MaxProcesses == 0) {
Dbg(TraceLevel.Audit, service, "Configuration is busted; MaxProcesses is zero?!");
DebugStub.Break();
}
if (service.Processes.Count >= service.Config.MaxProcesses) {
Dbg(TraceLevel.Audit, service, "This service has reached its maximum process count.");
Dbg(TraceLevel.Audit, service, "No more service processes can be started at this time.");
return ServiceError.ServiceIsAlreadyRunning;
}
Dbg(TraceLevel.Audit, service, "Attempting to start new service process.");
ServiceProcess! process = new ServiceProcess(service);
process.State = ServiceProcessState.Starting;
ServiceStarter! starter;
ServiceStarterContract.Imp:Starting! notifier = ServiceStarter.StartService(process, out starter);
expose(this) { service_starters.Add(notifier, starter); }
service.Processes.Add(process);
return ServiceError.None;
// Further progress will occur when the ServiceStarter indicates that it has
// finished its request, either successfully or unsuccessfully. We receive
// this indication as a message on the ServiceStarterContract channel.
}
/// <summary>
/// Create the inital set of services that are specified in the system manifest.
/// </summary>
void CreateInitialServices(string[]! list)
{
for (int i = 1; i < list.Length - 2; i += 3) {
string serviceName = list[i];
string executableName = list[i + 1];
string activationModeText = list[i + 2];
if (serviceName == null || serviceName.Length == 0) {
Dbg(TraceLevel.Audit, "The initial service list contains an entry with null service name.");
continue;
}
if (executableName == null || executableName.Length == 0) {
Dbg(TraceLevel.Audit, "The initial service list contains an entry with null binary name. The service name is '{0}'.", serviceName);
continue;
}
if (activationModeText == null || activationModeText.Length == 0) {
Dbg(TraceLevel.Audit, "The initial service list contains an entry with a null 'activationMode' value. The service name is '{0}'.", serviceName);
continue;
}
InternalServiceConfig config;
config.ServiceName = serviceName;
config.ExecutableName = executableName;
config.DisplayName = serviceName;
config.IsAdministrativelyDisabled = false;
config.MinProcesses = 0;
config.MaxProcesses = 1;
config.MaxClientsPerProcess = -1;
config.MaxProcessAgeInSeconds = -1;
activationModeText = activationModeText.ToLower();
if (activationModeText == "demand") {
config.ActivationMode = ServiceActivationMode.Demand;
config.MinProcesses = 0;
}
else if (activationModeText == "manual") {
config.ActivationMode = ServiceActivationMode.Manual;
config.MinProcesses = 0;
}
else if (activationModeText == "alwaysactive") {
config.ActivationMode = ServiceActivationMode.AlwaysActive;
config.MinProcesses = 1;
}
else {
Dbg(TraceLevel.Audit, "Warning: The initial service entry '{0}' has an invalid activation mode of '{1}'.", serviceName, activationModeText);
Dbg(TraceLevel.Audit, "Setting the mode to Demand.");
config.ActivationMode = ServiceActivationMode.Demand;
}
if (services.Contains(serviceName)) {
Dbg(TraceLevel.Audit, "A service named '{0}' already exists. Ignoring duplicate entry.", serviceName);
continue;
}
ServiceError error = CreateService(config);
if (error != ServiceError.None) {
Dbg(TraceLevel.Audit, "Error: Failed to create service '{0}': {1}", serviceName, ServiceEnums.ToString(error));
continue;
}
}
}
ServiceError StopService(Service! service)
{
switch (service.Config.ActivationMode) {
case ServiceActivationMode.Manual:
case ServiceActivationMode.Demand:
break;
case ServiceActivationMode.AlwaysActive:
Dbg(TraceLevel.Audit, service, "This service uses the 'always active' activation mode, and so cannot be stopped.");
return ServiceError.CannotStopService;
}
if (service.Processes.Count == 0) {
Dbg(TraceLevel.Audit, service, "Cannot stop service; it is not running.");
return ServiceError.ServiceIsNotRunning;
}
foreach (ServiceProcess! process in service.Processes) {
switch (process.State) {
case ServiceProcessState.Running:
case ServiceProcessState.Starting:
process.State = ServiceProcessState.Stopping;
process.NeedSendStopControl = true;
break;
case ServiceProcessState.Stopping:
break;
}
}
FailAllConnectRequests(service, ErrorCode.Unknown);
return ServiceError.None;
}
void TerminateServiceProcess(ServiceProcess! process)
{
switch (process.State) {
case ServiceProcessState.Running:
case ServiceProcessState.Starting:
case ServiceProcessState.Stopping:
break;
default:
throw new Exception("Invalid state");
}
Process system_process = process.Process;
if (system_process != null) {
Dbg(TraceLevel.Warning, process, "Terminating service process.");
system_process.Join(TimeSpan.FromSeconds(2));
system_process.Stop();
system_process.Join();
}
}
void ScanForStoppedProcesses()
{
foreach (Service! service in (!)services.Values) {
ScanServiceForStoppedProcesses(service);
}
}
void ScanServiceForStoppedProcesses(Service! service)
{
bool any_stopped = false;
int i = 0;
while (i < service.Processes.Count) {
ServiceProcess! process = (ServiceProcess!)service.Processes[i];
if (process.State == ServiceProcessState.Stopping) {
Process system_process = process.Process;
if (system_process != null && system_process.State == ProcessState.Stopped) {
Dbg(TraceLevel.Audit, process, "Process has terminated.");
process.ReleaseProcess();
service.Processes.RemoveAt(i);
any_stopped = true;
// Do NOT increment i here.
continue;
}
}
i++;
}
if (any_stopped)
PushService(service);
}
static bool StringIsNullOrEmpty(string s)
{
return s == null || s.Length == 0;
}
ServiceError CreateService(InternalServiceConfig config)
{
if (StringIsNullOrEmpty(config.ServiceName)
|| StringIsNullOrEmpty(config.DisplayName)
|| StringIsNullOrEmpty(config.ExecutableName))
{
Dbg(TraceLevel.Audit, "Cannot create service. Required parameters are missing.");
return ServiceError.InvalidArguments;
}
if (config.MinProcesses < 0) {
Dbg(TraceLevel.Audit, "Cannot create service. MinProcesses value is invalid (negative).");
return ServiceError.InvalidArguments;
}
if (config.MaxProcesses <= 0) {
Dbg(TraceLevel.Audit, "Cannot create service. MaxProcesses value is invalid (negative or zero).");
return ServiceError.InvalidArguments;
}
if (config.MinProcesses > config.MaxProcesses) {
Dbg(TraceLevel.Audit, "Cannot create service. MinProcesses value is greater than MaxProcesses.");
return ServiceError.InvalidArguments;
}
if (config.MaxClientsPerProcess != -1 && config.MaxClientsPerProcess <= 0) {
Dbg(TraceLevel.Audit, "Cannot create service. MaxClientsPerProcess must be -1 (disabled), or must be greater than zero.");
return ServiceError.InvalidArguments;
}
switch (config.ActivationMode) {
case ServiceActivationMode.AlwaysActive:
case ServiceActivationMode.Demand:
case ServiceActivationMode.Manual:
break;
default:
Dbg(TraceLevel.Audit, "Cannot create service. ActivationMode is invalid.");
return ServiceError.InvalidArguments;
}
string! serviceName = config.ServiceName;
Service service = FindService(serviceName);
if (service != null) {
Dbg(TraceLevel.Audit, "Cannot create service. Service '{0}' already exists.");
return ServiceError.ServiceExists;
}
service = new Service(config);
// service.LastServiceStatusPublished = service.GetStatus();
services[serviceName] = service;
Dbg(TraceLevel.Audit, service, "Service successfully created.");
PushService(service);
return ServiceError.None;
}
Service FindService(string! name)
{
Service service = (Service)services[name];
return service;
}
#region Diagnostics
internal static string! MakeDbgPrefix(string! context)
{
return String.Format("SMS[{0,-20}] ", context);
}
internal static void TraceLog(TraceLevel level, string! line)
{
if (level >= tracePrintLevel) {
DebugStub.WriteLine(line);
}
// DebugStub.Break();
Tracing.Log((byte)level, line);
}
static void Dbg(TraceLevel level, string! line)
{
TraceLog(level, line);
}
static void Dbg(TraceLevel level, Service! service, string! line)
{
TraceLog(level, service.dbgprefix + line);
}
static void Dbg(TraceLevel level, ServiceProcess! process, string! line)
{
TraceLog(level, process.dbgprefix + line);
}
static void Dbg(TraceLevel level, DirectoryClientInfo! dirinfo, string! line)
{
TraceLog(level, dirinfo.dbgprefix + line);
}
#region Variants of Dbg that use String.Format
static void Dbg(TraceLevel level, string! format, params object[]! args)
{
Dbg(level, String.Format(format, args));
}
static void Dbg(TraceLevel level, Service! service, string! format, params object[]! args)
{
Dbg(level, service, String.Format(format, args));
}
static void Dbg(TraceLevel level, ServiceProcess! process, string! format, params object[]! args)
{
Dbg(level, process, String.Format(format, args));
}
static void Dbg(TraceLevel level, DirectoryClientInfo! dirinfo, string! format, params object[]! args)
{
Dbg(level, dirinfo, String.Format(format, args));
}
#endregion
static void DumpException(Exception! ex)
{
for (Exception focus = ex; focus != null; focus = focus.InnerException) {
Dbg(TraceLevel.Error, "{0}: {1}", ex.GetType().FullName, ex.Message);
}
}
void AssertIntegrity()
{
foreach (DictionaryEntry entry in services) {
Assert(entry.Key != null, "entry.Key != null");
Assert(entry.Value != null, "entry.Value != null");
string name = (string)entry.Key;
Service service = (Service)entry.Value;
Assert(name != null, "name != null");
Assert(service != null, "service != null");
assert service != null;
assert name != null;
if (name != service.ServiceName)
assert false;
// assert name == service.ServiceName;
}
foreach (ServiceStartWatcher! startWatcher in serviceStartWatchers) {
Service service = FindService(startWatcher.Service.ServiceName);
assert service != null;
assert service == startWatcher.Service;
}
foreach (ServiceStopWatcher! stopWatcher in serviceStartWatchers) {
Service service = FindService(stopWatcher.Service.ServiceName);
assert service != null;
assert service == stopWatcher.Service;
}
}
void Assert(bool condition, string! msg)
{
if (condition)
return;
Dbg(TraceLevel.Error, "Assertion failed: " + msg);
DebugStub.Break();
}
void Assert(bool condition)
{
if (condition)
return;
Dbg(TraceLevel.Error, "Assertion failed.");
DebugStub.Break();
}
#endregion
ServiceConnectRequest! AllocateServiceConnectRequest(
[Claims]DirectoryServiceContract.Exp:Ready! dir,
DirectoryClientInfo! dirinfo,
string! subpath,
[Claims]ServiceContract.Exp:Start! channel,
SchedulerTime timeStarted)
{
ServiceConnectRequest request;
if (connectRequestLookasideCount > 0) {
connectRequestLookasideCount--;
request = connectRequestLookasideList[connectRequestLookasideCount];
assert request != null;
request.Release(dir, dirinfo, subpath, channel, timeStarted);
return request;
}
else {
request = new ServiceConnectRequest(dir, dirinfo, subpath, channel, timeStarted);
return request;
}
}
void RecycleServiceConnectRequest(
ServiceConnectRequest! request,
out DirectoryServiceContract.Exp:Ready! dir,
out DirectoryClientInfo! dirinfo,
out string! subpath,
out ServiceContract.Exp:Start! channel,
out SchedulerTime timeStarted)
{
request.Acquire(out dir, out dirinfo, out subpath, out channel, out timeStarted);
// need to assert that request.Acquire() has been called
if (connectRequestLookasideCount < connectRequestLookasideList.Length) {
connectRequestLookasideList[connectRequestLookasideCount] = request;
connectRequestLookasideCount++;
}
else {
request.Dispose();
}
}
#region ITracked methods
void ITracked.Expose() {}
void ITracked.UnExpose() {}
void ITracked.Acquire() {}
void ITracked.Release() {}
#endregion
}
/// <summary>
/// Instances of this class are used to associate information with instances of
/// DirectoryServiceContract.Exp. The Service Manager allows clients to connect
/// to '/service/services' using DirectoryServiceContract. The Service Manager only
/// supports a few requests: service enumeration, and binding to services.
/// </summary>
class DirectoryClientInfo
{
public DirectoryClientInfo(string! path)
{
this.Path = path;
this.dbgprefix = ServiceManager.MakeDbgPrefix("dir '" + path + "'");
}
public string! Path;
public string! dbgprefix;
#if false
/// <summary>
/// Used while enumerating a particular directory.
/// </summary>
public IEnumerator/*<Service>*/ Enumerator;
#endif
}
class ServiceManagerWatcher
{
public ServiceManagerWatcher()
{
endpointIsReady = false;
endpointRef = null;
EventsMissed = 0;
}
public ServiceManagerEventMask DesiredEvents;
public ServiceManagerEventMask EventsMissed;
private bool endpointIsReady;
private TRef<ServiceManagerContract.Exp:WaitingServiceManagerChange> endpointRef;
public void SetEndpoint([Claims]ServiceManagerContract.Exp:WaitingServiceManagerChange! ep)
{
if (endpointIsReady)
throw new Exception("This ServiceManagerWatcher instance already has an endpoint.");
if (endpointRef != null)
endpointRef.Release(ep);
else
endpointRef = new TRef<ServiceManagerContract.Exp:WaitingServiceManagerChange>(ep);
endpointIsReady = true;
EventsMissed = 0;
}
public ServiceManagerContract.Exp:WaitingServiceManagerChange! GetEndpoint()
{
if (!endpointIsReady)
throw new Exception("This ServiceManagerWatcher instance does not have an endpoint.");
assert endpointRef != null;
ServiceManagerContract.Exp:WaitingServiceManagerChange! ep = endpointRef.Acquire();
endpointIsReady = false;
return ep;
}
public bool IsEndpointReady
{
get { return endpointIsReady; }
}
public void Dispose()
{
if (endpointIsReady) {
ServiceManagerContract.Exp:WaitingServiceManagerChange! ep = GetEndpoint();
delete ep;
}
}
}
/// <summary>
/// Keep these values in sync with the Tracing levels (System.Tracing).
/// </summary>
enum TraceLevel : byte
{
Fatal = 0xe, // system crashed.
Error = 0xc, // system will crash.
Warning = 0xa, // cause for immediate concern.
Notice = 0x8, // might be cause for concern.
Trace = 0x6, // may be of use in crash.
Audit = 0x4, // impact on performance.
Debug = 0x2, // used only for debugging.
}
}
Reference in New Issue View Git Blame Copy Permalink