singrdk/base/Applications/ServiceManager/SMSClient/SMSClient.cs

///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  Note:   Service Manager client program
//
using System;
using System.Threading;

using Microsoft.SingSharp;
using Microsoft.SingSharp.Reflection;
using Microsoft.Singularity;
using Microsoft.Singularity.Applications;
using Microsoft.Singularity.Channels;
using Microsoft.Singularity.Configuration;
using Microsoft.Singularity.Contracts;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Io;
using Microsoft.Singularity.ServiceManager;
[assembly: Transform(typeof(ApplicationResourceTransform))]

namespace Microsoft.Singularity.Applications.ServiceManager
{
    [ConsoleCategory(HelpMessage="Service management client", DefaultAction=true)]
    internal class DefaultConfig
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        reflective internal DefaultConfig();

        internal int AppMain()
        {
            Console.WriteLine("Use -? for help.");
            return 0;
        }
    }

    [ConsoleCategory(Action="start", HelpMessage="Start a service")]
    internal class StartConfig
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        // [BoolParameter("w", Mandatory=false, HelpMessage="Wait for service to start.")]
        public bool wait;

        reflective internal StartConfig();

        internal int AppMain()
        {
            return SMSClient.StartService((!)serviceName, wait);
        }
    }

    [ConsoleCategory(Action="stop", HelpMessage="Stop a service")]
    internal class StopServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        // [BoolParameter("w", Mandatory=false, HelpMessage="Wait for service to stop.")]
        public bool wait;

        reflective internal StopServiceCommand();

        internal int AppMain()
        {
            return SMSClient.StopService((!)serviceName, wait);
        }
    }

    [ConsoleCategory(Action="list", HelpMessage="Show a list of services")]
    internal class ListConfig
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        reflective internal ListConfig();

        internal int AppMain()
        {
            return SMSClient.ListServices(this);
        }
    }

    [ConsoleCategory(Action="show", HelpMessage="Show details about a specific service.")]
    internal class ShowServiceParameters
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Position=0, Mandatory=true, HelpMessage="The service to examine.")]
        public string ServiceName;

        reflective internal ShowServiceParameters();

        internal int AppMain()
        {
            if (ServiceName == null) {
                Console.WriteLine("The 'service' parameter is required, but has not been provided.");
                return -1;
            }

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {
                ServiceError error = SMSClient.SelectService(svmanager, this.ServiceName);
                if (error != ServiceError.None)
                    return -1;

                bool errors = false;

                svmanager.SendQueryServiceConfig();
                switch receive {
                    case svmanager.CurrentServiceConfig(config):
                        SMSClient.ShowConfigDetailed(config);
                        config.Dispose();
                        break;

                    case svmanager.RequestFailed(err):
                        if (err == ServiceError.ServiceNotFound) {
                            Console.WriteLine("There is no service with name '{0}'.", this.ServiceName);
                            return -1;
                        }

                        Console.WriteLine("Failed to query service configuration.");
                        SMSClient.ShowServiceError(err);
                        errors = true;
                        break;

                    case svmanager.ChannelClosed():
                        Console.WriteLine("The Service Manager closed its channel unexpectedly.");
                        return -1;
                }

                svmanager.SendQueryServiceStatus();
                switch receive {
                    case svmanager.CurrentServiceStatus(status):
                        Console.WriteLine();
                        SMSClient.ShowStatusDetailed(status);
                        status.Dispose();
                        break;

                    case svmanager.RequestFailed(err):
                        Console.WriteLine("Failed to query service status.");
                        SMSClient.ShowServiceError(err);
                        errors = true;
                        break;

                    case svmanager.ChannelClosed():
                        Console.WriteLine("The Service Manager closed its channel unexpectedly.");
                        return -1;
                }

                if (errors)
                    return -1;
                else
                    return 0;

            }
            finally {
                delete svmanager;
            }
        }
    }

    [ConsoleCategory(Action="watch", HelpMessage="Watch the status of a service")]
    internal class WatchConfig
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        reflective internal WatchConfig();

        internal int AppMain()
        {
            return SMSClient.WatchService((!)serviceName);
        }
    }

    [ConsoleCategory(Action="watchall", HelpMessage="Watch the status of the Service Manager")]
    internal class WatchAllConfig
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

#if false
        [BoolParameter("c", Mandatory=false, HelpMessage="Watch all service configuration changes")]
        public bool watchConfigChanges;

        [BoolParameter("s", Mandatory=false, HelpMessage="Watch all service status changes")]
        public bool watchStatusChanges;
#endif

        reflective internal WatchAllConfig();

        internal int AppMain()
        {
#if false
            ServiceManagerEventMask desiredEvents = 0;

            if (watchConfigChanges)
                desiredEvents |= ServiceManagerEventMask.AnyServiceConfig;

            if (watchStatusChanges)
                desiredEvents |= ServiceManagerEventMask.AnyServiceStatus;

            if (desiredEvents == 0)
                desiredEvents = ServiceManagerEventMask.AnyServiceConfig | ServiceManagerEventMask.AnyServiceStatus;
#else
            ServiceManagerEventMask desiredEvents = ServiceManagerEventMask.AnyServiceConfig | ServiceManagerEventMask.AnyServiceStatus;
#endif

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();

            svmanager.SendWatchServiceManager(desiredEvents);

            switch receive {
                case svmanager.Ok():
                    break;

                case svmanager.RequestFailed(error):
                    Console.WriteLine("The Service Manager rejected the subscription request.");
                    SMSClient.ShowServiceError(error);
                    delete svmanager;
                    return -1;
            }

            Console.WriteLine("Watching Service Manager...");

            for (;;) {
                Console.WriteLine("Sending WaitNextServiceManagerChange");
                svmanager.SendWaitNextServiceManagerChange();

                Console.WriteLine("switch-receive");

                switch receive {
                    case svmanager.ServiceManagerChanged(events):
                        Console.WriteLine("Service Manager events fired: {0:x8}", ((uint)events));
                        break;
                }
            }
        }
    }

    [ConsoleCategory(Action="create", HelpMessage="Create a new service entry")]
    internal class CreateServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        [StringParameter("exe", Mandatory=false, HelpMessage="Executable to use; if omitted, uses service name.")]
        public string executableName;

        [StringParameter("display", Mandatory=false, HelpMessage="Display name to use; if omitted, uses service name.")]
        public string displayName;

        [BoolParameter("disabled", Mandatory=false, HelpMessage="Create in a disabled state.")]
        public bool isAdministrativelyDisabled;

        reflective internal CreateServiceCommand();

        internal int AppMain()
        {
            assert serviceName != null;
            if (serviceName.Length == 0) {
                Console.WriteLine("Invalid service name.");
                return -1;
            }

            if (executableName == null || executableName.Length == 0)
                executableName = serviceName;

            if (displayName == null || displayName.Length == 0)
                displayName = serviceName;

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {

                ServiceConfig config = new ServiceConfig();
                config.ServiceName = Bitter.FromString2(serviceName);
                config.ExecutableName = Bitter.FromString2(executableName);
                config.DisplayName = Bitter.FromString2(displayName);
                config.IsAdministrativelyDisabled = isAdministrativelyDisabled;
                config.MinProcesses = 0;
                config.MaxProcesses = 1;
                config.MaxClientsPerProcess = ServiceConfig.UnlimitedClientsPerProcess;
                config.MaxProcessAgeInSeconds = ServiceConfig.UnlimitedProcessAge;

                svmanager.SendCreateService(config);

                switch receive {
                    case svmanager.Ok():
                        Console.WriteLine("Service was successfully created.");
                        return 0;

                    case svmanager.RequestFailed(error):
                        Console.WriteLine("Failed to create service.");
                        SMSClient.ShowServiceError(error);
                        return -1;
                }

            }
            finally {
                delete svmanager;
            }
        }
    }

    [ConsoleCategory(Action="delete", HelpMessage="Delete an existing service")]
    internal class DeleteServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        reflective internal DeleteServiceCommand();

        internal int AppMain()
        {
            assert serviceName != null;
            if (serviceName.Length == 0) {
                Console.WriteLine("Invalid service name.");
                return -1;
            }

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {

                ServiceError error = SMSClient.SelectService(svmanager, serviceName);
                if (error != ServiceError.None)
                    return -1;

                svmanager.SendDeleteService();

                switch receive {
                    case svmanager.Ok():
                        Console.WriteLine("Service was successfully deleted.");
                        return 0;

                    case svmanager.RequestFailed(err):
                        Console.WriteLine("Failed to delete service.");
                        SMSClient.ShowServiceError(err);
                        return -1;
                }

            }
            finally {
                delete svmanager;
            }
        }
    }

    [ConsoleCategory(Action="enable", HelpMessage="Enable a service")]
    internal class EnableServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        reflective internal EnableServiceCommand();

        internal int AppMain()
        {
            assert serviceName != null;
            if (serviceName.Length == 0) {
                Console.WriteLine("Invalid service name.");
                return -1;
            }

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {

                ServiceError error = SMSClient.SelectService(svmanager, serviceName);
                if (error != ServiceError.None)
                    return -1;

                svmanager.SendEnableService(true);

                switch receive {
                    case svmanager.Ok():
                        Console.WriteLine("Service was successfully enabled.");
                        return 0;

                    case svmanager.RequestFailed(err):
                        Console.WriteLine("Failed to enable service.");
                        SMSClient.ShowServiceError(err);
                        return -1;
                }

            }
            finally {
                delete svmanager;
            }
        }
    }

    [ConsoleCategory(Action="disable", HelpMessage="Disable a service")]
    internal class DisableServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        reflective internal DisableServiceCommand();

        internal int AppMain()
        {
            assert serviceName != null;
            if (serviceName.Length == 0) {
                Console.WriteLine("Invalid service name.");
                return -1;
            }

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {

                ServiceError error = SMSClient.SelectService(svmanager, serviceName);
                if (error != ServiceError.None)
                    return -1;

                svmanager.SendEnableService(false);

                switch receive {
                    case svmanager.Ok():
                        Console.WriteLine("Service was successfully disabled.");
                        return 0;

                    case svmanager.RequestFailed(err):
                        Console.WriteLine("Failed to disable service.");
                        SMSClient.ShowServiceError(err);
                        return -1;
                }

            }
            finally {
                delete svmanager;
            }
        }
    }

    [ConsoleCategory(Action="kill", HelpMessage="Terminate the process(es) of a service.")]
    internal class TerminateServiceCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [StringParameter("service", Mandatory=true, Position=0)]
        internal string serviceName;

        [LongParameter("pid", Mandatory=false, Position=1, Default=-1)]
        internal long processId;

        reflective internal TerminateServiceCommand();

        internal int AppMain()
        {
            assert serviceName != null;
            if (serviceName.Length == 0) {
                Console.WriteLine("Invalid service name.");
                return -1;
            }

            ServiceManagerContract.Imp! svmanager = SMSClient.ConnectServiceManager();
            try {

                ServiceError error = SMSClient.SelectService(svmanager, serviceName);
                if (error != ServiceError.None)
                    return -1;

                if (processId != -1)
                    svmanager.SendTerminateServiceProcess((int)processId);
                else
                    svmanager.SendTerminateServiceAllProcesses();

                switch receive {
                    case svmanager.Ok():
                        return 0;

                    case svmanager.RequestFailed(err):
                        SMSClient.ShowServiceError(err);
                        return -1;
                }

            }
            finally {
                delete svmanager;
            }
        }
    }


    public class SMSClient
    {
        internal static ServiceManagerContract.Imp! ConnectServiceManager()
        {
            using (ImpatientWatcher watcher = new ImpatientWatcher("ConnectServiceManager", "create channel", 250)) {
                ErrorCode error;
                ServiceManagerContract.Imp! manager_imp;
                ServiceManagerContract.Exp! manager_exp;
                ServiceManagerContract.NewChannel(out manager_imp, out manager_exp);

                watcher.NextStep("NewClientEndpoint", 250);

                DirectoryServiceContract.Imp! rootds = DirectoryService.NewClientEndpoint();
                try {
                    watcher.NextStep("SdsUtils.Bind", 1000);
                    if (SdsUtils.Bind(ServiceManagerContract.ModuleName, rootds, manager_exp, out error)) {
                        watcher.NextStep("RecvSuccess", 250);
                        manager_imp.RecvSuccess();
                        return manager_imp;
                    }
                    else {
                        delete manager_imp;
                        Console.WriteLine("Failed to contact the Service Manager.  Error: " + SdsUtils.ErrorCodeToString(error));
                        throw new Exception("Failed to connect to Service Manager.");
                    }
                }
                finally {
                    delete rootds;
                }
            }
        }

        internal static ServiceError SelectService(ServiceManagerContract.Imp! svmanager, string! serviceName)
        {
            svmanager.SendSelectService(Bitter.FromString2(serviceName));
            switch receive {
                case svmanager.Ok():
                    // Console.WriteLine("Successfully selected service '{0}'.", serviceName);
                    return ServiceError.None;

                case svmanager.RequestFailed(error):
                    Console.WriteLine("Failed to select service '{0}'.", serviceName);
                    ShowServiceError(error);
                    return error;

                case svmanager.ChannelClosed():
                    throw new Exception("Service Manager closed channel before responding.");
            }
        }

        internal static void ShowServiceError(ServiceError error)
        {
            Console.WriteLine("ServiceError: " + ServiceEnums.ToString(error));
        }

        static internal int StartService(string! serviceName, bool wait)
        {
            ServiceManagerContract.Imp! svmanager = ConnectServiceManager();

            try {

                ServiceError error = SelectService(svmanager, serviceName);
                if (error != ServiceError.None) {
                    return -1;
                }

                if (wait) {
                    svmanager.SendStartServiceWait();

                    for (;;) {
                        switch receive {
                            case svmanager.RequestFailed(err):
                                ShowServiceError(err);
                                return -1;

                            case svmanager.ServiceStarting():
                                Console.WriteLine("Service Manager accepted request to start service '{0}'.", serviceName);
                                return 0;

                            case timeout(TimeSpan.FromSeconds(10)):
                                Console.WriteLine("waiting...");
                                break;
                        }
                    }
                }
                else {
                    svmanager.SendStartServiceNoWait();

                    switch receive {
                        case svmanager.RequestFailed(err):
                            ShowServiceError(err);
                            return -1;

                        case svmanager.ServiceStarting():
                            Console.WriteLine("Service Manager accepted request to start service '{0}'.", serviceName);
                            return 0;
                    }
                }
            }
            finally {
                delete svmanager;
            }
        }

        internal static int StopService(string! serviceName, bool wait)
        {
            ServiceManagerContract.Imp! svmanager = ConnectServiceManager();

            try {

                ServiceError error = SelectService(svmanager, serviceName);
                if (error != ServiceError.None)
                    return -1;

                if (wait) {
                    svmanager.SendStopServiceWait();

                    for (;;) {
                        switch receive {
                            case svmanager.RequestFailed(err):
                                ShowServiceError(err);
                                if (err == ServiceError.CannotStopService) {
                                    Console.WriteLine("If this service is an 'always active' service, then the stop command cannot be used.");
                                    Console.WriteLine("Instead, use the 'disable' command.");
                                }
                                return -1;

                            case svmanager.ServiceStopping():
                                Console.WriteLine("Service Manager accepted request to stop service '{0}'.", serviceName);
                                return 0;

                            case timeout(TimeSpan.FromSeconds(10)):
                                Console.WriteLine("waiting...");
                                break;
                        }
                    }
                }
                else {
                    svmanager.SendStopServiceNoWait();

                    switch receive {
                        case svmanager.RequestFailed(err):
                            ShowServiceError(err);
                            return -1;

                        case svmanager.ServiceStopping():
                            Console.WriteLine("Service Manager accepted request to stop service '{0}'.", serviceName);
                            return 0;
                    }
                }
            }
            finally {
                delete svmanager;
            }
        }

        internal static int WatchService(string! serviceName)
        {
            ServiceManagerContract.Imp! svmanager = ConnectServiceManager();

            try {

                ServiceError error = SelectService(svmanager, serviceName);
                if (error != ServiceError.None) {
                    return -1;
                }

                svmanager.SendWatchServiceStatus();

                switch receive {
                    case svmanager.RequestFailed(err):
                        ShowServiceError(err);
                        return -1;

                    case svmanager.Ok():
                        Console.WriteLine("Service Manager accepted request to watch service '{0}'.", serviceName);
                        break;
                }

                for (;;) {
                    svmanager.SendWaitServiceChange();

                    switch receive {
                        case svmanager.ServiceStatusChanged(ServiceStatus status, bool missedChange):
                            Console.WriteLine("Status changed: ");
                            Console.WriteLine("    State:   " + ServiceEnums.ToString(status.State));
                            if (missedChange) {
                                Console.WriteLine("    Note: At least one status change was missed.");
                            }
                            break;

                        case svmanager.RequestFailed(err):
                            Console.WriteLine("Request failed.");
                            ShowServiceError(err);
                            return -1;

                        case svmanager.ChannelClosed():
                            Console.WriteLine("Service Manager closed channel!");
                            return -1;
                    }
                }

            }
            finally {
                delete svmanager;
            }
        }

        const string ListServiceFormat = "{0,-20} {1,-10} {2,-6} {3}";

        internal static int ListServices(ListConfig! config)
        {
            ServiceManagerContract.Imp! svmanager = ConnectServiceManager();


            try {
                Console.WriteLine(ListServiceFormat, "Name", "State", "PID", "Display Name");
                Console.WriteLine(ListServiceFormat,
                    new String('-', 20),
                    new String('-', 10),
                    new String('-', 6),
                    new String('-', 30));

                ServiceInfo[]! in ExHeap first_entries = new[ExHeap] ServiceInfo[40];
                svmanager.SendEnumerateServices(first_entries);

                for (;;) {
                    switch receive {
                        case svmanager.EnumerationTerminated(entries, count):
                            ListServices(entries, count);
                            delete entries;
                            return 0;

                        case svmanager.NextServiceInfo(entries, count):
                            ListServices(entries, count);
                            svmanager.SendEnumerateServices(entries);
                            break;

                        case svmanager.ChannelClosed():
                            Console.WriteLine("Service Manager channel closed");
                            return -1;

                    }
                }
            }
            finally {
                delete svmanager;
            }
        }

        static void ListServices(ServiceInfo[]! in ExHeap entries, int count)
        {
            for (int i = 0; i < count; i++) {
                expose(entries[i])
                {
                    string! serviceName = ToString(entries[i].Config.ServiceName);
                    string! displayName = ToString(entries[i].Config.DisplayName);
                    string! stateString = ServiceEnums.ToString(entries[i].Status.State);
                    string! processIdString = entries[i].Status.ProcessId != -1 ?
                        (!)entries[i].Status.ProcessId.ToString() : "";
                    Console.WriteLine(ListServiceFormat, serviceName, stateString, processIdString, displayName);
                }
            }
        }

        public static string! ToString(char[] in ExHeap str)
        {
            if (str != null)
                return Bitter.ToString2(str);
            else
                return "";
        }

        public static void ShowConfigDetailed(ServiceConfig config)
        {
            if (config.ServiceName == null) {
                Console.WriteLine("Error: A ServiceConfig structure had a null ServiceName field.");
                return;
            }
            string! serviceName = Bitter.ToString2(config.ServiceName);

            string! executableName = config.ExecutableName != null ? Bitter.ToString2(config.ExecutableName) : "";
            string! displayName = config.DisplayName != null ? Bitter.ToString2(config.DisplayName) : "";

            Console.WriteLine("Service Configuration");
            Console.WriteLine("---------------------");
            Console.WriteLine();
            Console.WriteLine(DetailFormat, "Service Name", serviceName);
            Console.WriteLine(DetailFormat, "Executable", executableName);
            Console.WriteLine(DetailFormat, "Display Name", displayName);
            Console.WriteLine(DetailFormat, "Activation Mode", ServiceEnums.ToString(config.ActivationMode));
            Console.WriteLine(DetailFormat, "Is Disabled?", config.IsAdministrativelyDisabled.ToString());

            Console.WriteLine(DetailFormat, "Min/Max Processes", String.Format("min {0} / {1}",
                config.MinProcesses,
                config.MaxProcesses == ServiceConfig.UnlimitedProcesses ? "no max" : "max " + config.MaxProcesses));

            string! max_age_text;
            if (config.MaxProcessAgeInSeconds == ServiceConfig.UnlimitedProcessAge)
                max_age_text = "unlimited";
            else {
                TimeSpan limit = TimeSpan.FromSeconds(config.MaxProcessAgeInSeconds);
                max_age_text = (!)limit.ToString();
            }
            Console.WriteLine(DetailFormat, "Max Process Age", max_age_text);

            string clients_per_process_text;
            if (config.MaxClientsPerProcess == ServiceConfig.UnlimitedClientsPerProcess) {
                clients_per_process_text = "unlimited";
            }
            else {
                clients_per_process_text = config.MaxClientsPerProcess.ToString();
            }
            Console.WriteLine(DetailFormat, "Max Clients per Process", clients_per_process_text);

        }

        const string DetailFormat = "{0,-25}: {1}";

        public static void ShowStatusDetailed(ServiceStatus status)
        {
            Console.WriteLine("Service Status");
            Console.WriteLine("--------------");
            Console.WriteLine();
            Console.WriteLine(DetailFormat, "State", ServiceEnums.ToString(status.State));
            if (status.State != ServiceState.Stopped) {
                Console.WriteLine(DetailFormat, "Process ID", status.ProcessId);
            }

            // This is not yet accurate.
            // Console.WriteLine(DetailFormat, "Total Active Clients", status.TotalActiveClients);

            Console.WriteLine(DetailFormat, "Total Active Processes", status.TotalActiveProcesses);
            Console.WriteLine(DetailFormat, "Connect Queue Length", status.ConnectQueueLength);

            Console.WriteLine(DetailFormat, "Last Process Start", status.LastStartFailed ? "FAILED" : "Succeeded");
            if (status.LastStartFailed) {
                Console.WriteLine(DetailFormat, "Last Start Error", ServiceEnums.ToString(status.LastStartError));
            }
        }
    }

}