Why is my Windows Service dying?

foamy
2499

600 views

Why is my Windows Service dying?

Hi all,

I have an issue with a Windows Service I wrote. This issue only comes up on one particular client's server and roughly once a day. The service is installed on about 40 servers, but this is the only place it happens :-S

The issue: The service simply stops doing what it's supposed to be doing. It doesn't write anything to the eventlog - even though I've made it so any exceptions will be written there.

Below is the main clump of code that this service consists of. It's quite simple. To break it down, the service starts a few threads each minute which does some measuring on disk space, available memory and so on. A lot of the writing to eventlog is part of my debugging the issue to try and solve it.

private static void StartProbing()
{
    int updateCount = 2;
    bool error = false;
    while (!Stop)
    {
        updateCount++;
        try
        {
            if (error)
                EventLog.WriteEntry("MyService", "Trying again. updateCount = " + updateCount, EventLogEntryType.Information);
            if (updateCount >= 2)
            {
                EventLog.WriteEntry("MyService", "Trying to get config.", EventLogEntryType.Information);
                GetConfig();
                updateCount = 0;
                if (error)
                {
                    error = false;
                    EventLog.WriteEntry("MyService", "Successfully connected to server.", EventLogEntryType.Information);
                }
            }
            foreach (Task task in tasks)
            {
                Thread t = null;
                switch (task.Type.ToLower())
                {
                    case "ping":
                        t = new Thread(new ParameterizedThreadStart(_Ping));
                        break;
                    case "diskcheck":
                        t = new Thread(new ParameterizedThreadStart(_DiskCheck));
                        break;
                    case "cpucheck":
                        t = new Thread(new ParameterizedThreadStart(_CpuCheck));
                        break;
                    case "memcheck":
                        t = new Thread(new ParameterizedThreadStart(_MemCheck));
                        break;
                    case "proccheck":
                        t = new Thread(new ParameterizedThreadStart(_ProcCheck));
                        break;
                }
                if (t != null)
                    t.Start(task);
            }
            if (Stop)
                break;
            Thread.Sleep(1000 * 60);
        }
        catch (Exception x)
        {
            error = true;
            EventLog.WriteEntry("MyService", "Probing loop: " + x.Message, EventLogEntryType.Error);
            Thread.Sleep(5000);
        }
    }
    if(Stop)
        EventLog.WriteEntry("MyService", "Stopping probing. updateCount = " + updateCount, EventLogEntryType.Error);
}

asked one year ago

add comment

last answered one year ago

6 answers

Sort:

tick

Well, that's telling us that a connection failure is occurring in the GetConfig() method. On the third and fourth updates, the failure is being caught as an exception in the StartProbing() method but on the fifth update something is happening which is not being caught and is hanging the service.

Assuming you agree with this analysis, I think you're going to have to include some more debugging code to identify on which line the failure is occurring.

On the face of it, the code is progressing past this line in GetConfig() on the fifth update otherwise an exception would be thrown again:

client.Connect(serverHost, port);

but I'd check that and also whether it's getting past these lines as well:

SendData(client, data);
data = ReceiveData(client);

My gut feeling is that this a connection problem rather than a 'shared state' threading problem with your Task objects because, if it were the latter, you'd be seeing similar problems on the other servers.

When you examine the logs for the 'successful' servers, do you see any evidence of repeated connection failures there?

answered one year ago by:

vulpes
17279

(x)

foamy
2499

every once in a while, a connection to another (random) service will fail, and immediately succeed. For some reason, this server stays down, so I think you're right about it being a connection failure. I'll add some logging to the GetConfig, SendData and ReceiveData methods and we'll have more for the next crash :-P

(x)

foamy
2499

It's also worth noting that there was a connection failure in the log on this server just before it died that went up to 20 retries and then succeeded...

(x)

vulpes
17279

I wondered whether there might be some significance in 5 retries but evidently there isn't .

(x)

foamy
2499

update: this morning I noticed that the log stopped when the service was trying to receive data. I therefore added a receive-timeout of 5 seconds to make sure it doesn't hang there forever. I'll let it run (with logging) and see where we're at

(x)

vulpes
17279

Sounds promising. If that is the problem, then it's easy to fix :)

(x)

foamy
2499

The service hasn't failed for about a week now :) so this seems to have solved it :D

(x)

vulpes
17279

Thank goodness for that :)

add comment

This is the sort of problem where you can look at the code until you're blue in the face but still not find anything!

If nothing's being written to the event log, then my guess is that a deadlock is occurring between two (or more) of your threads which is causing the service to hang. There may be some aspect of the server on which this occurs which makes it more susceptible to deadlocks than the others though there's always the chance that it may eventually occur on one of the other servers as well.

If the threads are accessing any shared state, I'd have a look at your locks and which objects they're synchronized on to see if you can think of any cirumstances where a deadlock might occur i.e. where threads are waiting for each other to release a lock.

EDIT

No sign of any shared state or locks in that code :)

The only thing I can think of which could conceivably cause the service to hang is when you create a new PerformanceCounter. These, of course, use underlying system resources and so, if for some reason, the OS is unable to satisfy the resource allocation immediately the thread might hang.

I'd try writing something to the log just before the PerformanceCounter is 'newed' and then immediately afterwards.

answered one year ago by:

vulpes
17279
edited one year ago

add comment

The threads are (or should be) quite independent. This is an example of the code that starts a cpucheck:

private static void _CpuCheck(object o)
{
    Task t = (Task)o;
    string status = t.Status;
    string newstatus = "";
    try
    {
        newstatus = CpuCheck(t);
    }
    catch
    {
        newstatus = "down";
    }
    finally
    {
        try
        {
            SendResult(t, status, newstatus);
        }
        catch (Exception x)
        {
            EventLog.WriteEntry("MyService", "Error sending data: " + x.Message, EventLogEntryType.Error);
        }
    }
}

private static string CpuCheck(Task task)
{
    string result = "";
    bool local = false;
    System.Net.IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
    foreach (IPAddress ip in host.AddressList)
    {
        if (IPAddress.Parse(task.IP).Equals(ip))
        {
            //Target machine is local
            local = true;
            break;
        }
    }
    PerformanceCounter CPU;
    if (!local)
        CPU = new PerformanceCounter("Processor", "% Processor Time", "_Total", task.IP);
    else
        CPU = new PerformanceCounter("Processor", "% Processor Time", "_Total");
    using (CPU)
    {
        try
        {
            float value = CPU.NextValue();
            if (value > Convert.ToInt32(task.Limit))
            { result = "down"; }
            else
            { result = "up"; }
        }
        catch (Exception x)
        {
            result = "down";
            EventLog.WriteEntry("MyService", "cpucheck on " + task.IP + ": " + x.Message, EventLogEntryType.Error);
        }
    }
    return result;
}

Any ideas for further debugging? :)

answered one year ago by:

foamy
2499
edited one year ago

(x)

vulpes
17279

Please see my edit for a further idea.

add comment

I've just installed a version with that kind of logging, now we just have to wait for it to fail :-P

answered one year ago by:

foamy
2499

(x)

vulpes
17279

Good luck with that!

add comment

It seems my threads were sharing some data, only with the main thread. This is the workflow of my service:

Every minute: Start some threads to do work. These take in an object (instance of the Task class) as a parameter.
Every other minute: Ask the server for some work. This updates the collection of tasks.

I think that while the main thread was updating my tasks collection, another thread was trying to read an object in that collection. This is apparently a no-go, so I made this change:

//old
if (t != null)
   t.Start(task);

//new
if (t != null)
   t.Start(new Task(task.ID, task.IP, task.Type, task.Limit));

And the service hasn't failed since :D

Thanks for the help :)

answered one year ago by:

foamy
2499

(x)

vulpes
17279

Yes, List<Task>, if that's what you're using, is not thread-safe. I still don't understand why this problem should only manifest itself on one particular server but, no matter, if it's working OK now:)

(x)

foamy
2499

That's a mystery to me too. However, it seems that this particular server is rather overloaded so I guess that could be why :)

(x)

foamy
2499

blast, the damn thing just failed again. Any more ideas? :-S

(x)

vulpes
17279

Can you tell from the log where the code is failing?

(x)

foamy
2499

Unfortunately, in my glee I removed the extensive logging. I've just re-enabled it so I should get some better ideas next time this thing crashes and burns.

add comment

This is the code I'm currently using (The whole damn thing :D)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;
using System.Net.Sockets;
using System.Net.NetworkInformation;
using System.Threading;
using System.Net;
using System.Diagnostics;
using System.IO;

namespace ClientService
{
    class Main
    {
        private static string serverHost;
        private static int port;
        private static List<Task> tasks = new List<Task>();
        public static bool Stop { get; set; }
        private static string logpath = "C:\\log.txt";

        public Main()
        {
            serverHost = "my.company.com";
            port = 31512;

            Stop = false;
            while (!Stop)
            {
                try
                {
                    //start doing something
                    StartProbing();
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Main loop: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static void StartProbing()
        {
            int updateCount = 2;
            bool error = false;
            EventLog.WriteEntry("MyService", "Starting...", EventLogEntryType.Information);
            File.AppendAllText(logpath, DateTime.Now + " - Starting" + Environment.NewLine);
            while (!Stop)
            {
                updateCount++;
                try
                {
                    File.AppendAllText(logpath, DateTime.Now + " - Trying again. updateCount = " + updateCount + Environment.NewLine);
                    if (updateCount >= 2)
                    {
                        if (error)
                            EventLog.WriteEntry("MyService", "Trying again. Update count: " + updateCount, EventLogEntryType.Information);
                        File.AppendAllText(logpath, DateTime.Now + " - Trying to get config." + Environment.NewLine);
                        GetConfig();
                        updateCount = 0;
                        File.AppendAllText(logpath, DateTime.Now + " - Successfully connected to server." + Environment.NewLine);
                        if (error)
                        {
                            EventLog.WriteEntry("MyService", "Successfully connected to server.", EventLogEntryType.Information);
                            error = false;
                        }
                    }
                    foreach (Task task in tasks)
                    {
                        Thread t = null;
                        switch (task.Type.ToLower())
                        {
                            case "ping":
                                t = new Thread(new ParameterizedThreadStart(_Ping));
                                break;
                            case "diskcheck":
                                t = new Thread(new ParameterizedThreadStart(_DiskCheck));
                                break;
                            case "cpucheck":
                                t = new Thread(new ParameterizedThreadStart(_CpuCheck));
                                break;
                            case "memcheck":
                                t = new Thread(new ParameterizedThreadStart(_MemCheck));
                                break;
                            case "proccheck":
                                t = new Thread(new ParameterizedThreadStart(_ProcCheck));
                                break;
                        }
                        if (t != null)
                            t.Start(new Task(task.ID, task.IP, task.Type, task.Limit));
                    }
                    if (Stop)
                        break;
                    Thread.Sleep(1000 * 60);
                }
                catch (Exception x)
                {
                    error = true;
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Probing loop: " + x.Message + Environment.NewLine);
                    Thread.Sleep(5000);
                }
            }
            File.AppendAllText(logpath, DateTime.Now + " - Stopping probing. updateCount = " + updateCount + Environment.NewLine);
        }

        private static void SendResult(Task task, string oldstatus, string newstatus)
        {
            if (oldstatus == "" || oldstatus != newstatus)
            {
                try
                {
                    //status of this task changed during the probing. Send an update to the server.
                    task.Status = newstatus;
                    using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
                    {
                        client.Connect(serverHost, port);
                        //client.Connect(System.Net.IPAddress.Parse(serverIP), port);
                        string data = "";
                        if (newstatus == "up")
                            data = "success;" + task.ID.ToString();
                        else
                            data = "fail;" + task.ID.ToString();
                        SendData(client, data);
                    }
                }
                catch(Exception x)
                {
                    EventLog.WriteEntry("MyService", "SendResult: " + x.ToString(), EventLogEntryType.Error);
                    //something bad happened when sending data to the server.
                    //revert the status of this task so we can try again later
                    task.Status = oldstatus;
                }
            }
        }

        private static void GetConfig()
        {
            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                client.Connect(serverHost, port);
                //client.Connect(System.Net.IPAddress.Parse(serverIP), port);
                string data = "config";
                SendData(client, data);
                data = ReceiveData(client);

                //Configuration:
                //config|id;ip;type;limit|id;ip;type;limit|...|...|
                if (data.ToLower().Trim().StartsWith("config"))
                {
                    List<Task> alltasks = new List<Task>();
                    string[] configs = data.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
                    for (int i = 1; i < configs.Length; i++)
                    {
                        string[] fields = configs[i].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (fields.Length == 4)
                        {
                            string id = fields[0];
                            string ip = fields[1];
                            string type = fields[2];
                            string limit = fields[3];
                            int inid = 0;
                            if (int.TryParse(id, out inid))
                            {
                                Task t = new Task(inid, ip, type, limit);
                                alltasks.Add(t);
                                if (!tasks.Contains(t))
                                    tasks.Add(t);
                                else
                                {
                                    foreach (Task task in tasks)
                                    {
                                        if (task.ID == t.ID)
                                        {
                                            task.IP = ip;
                                            task.Limit = limit;
                                            task.Type = type;
                                            break;
                                        }
                                    }                                    
                                }
                            }
                        }
                    }
                    if (tasks.Count > configs.Length - 1)
                    {
                        //One or more tasks are no longer applicable.
                        foreach (Task task in tasks)
                            if (!alltasks.Contains(task))
                                task.Status = "delete";
                        for (int i = tasks.Count - 1; i >= 0; i--)
                        {
                            Task task = tasks[i];
                            if (task.Status == "delete")
                                tasks.RemoveAt(i);
                        }
                    }
                }
            }
        }

        private static void SendData(Socket client, string data)
        {
            byte[] sendbuffer = BitConverter.GetBytes(data.Length);
            client.Send(sendbuffer);
            sendbuffer = Encoding.Default.GetBytes(data);
            client.Send(sendbuffer);
        }

        private static string ReceiveData(Socket client)
        {
            string result = "";
            byte[] lenBytes = new byte[4];
            int count = client.Receive(lenBytes);
            int readLength = BitConverter.ToInt32(lenBytes, 0);
            byte[] buffer = new byte[readLength];
            count = client.Receive(buffer);
            if (count != buffer.Length)
                File.AppendAllText(logpath, DateTime.Now + " - Possible data corruption!" + Environment.NewLine);
            result = Encoding.Default.GetString(buffer);
            return result;
        }

        #region probes

        private static void _Ping(object o)
        {
            Task t = (Task)o;
            string status = t.Status;
            string newstatus = "";
            try
            {
                newstatus = Ping(t);
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "Ping: " + x.ToString(), EventLogEntryType.Error);
                newstatus = "down";
            }
            finally
            {
                try
                {
                    SendResult(t, status, newstatus);
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Error sending data: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static string Ping(Task task)
        {
            string result = "";
            Ping ping = new Ping();
            PingReply reply = null;
            long time = 0;
            int packetslost = 0;
            for (int i = 0; i < 5; i++)
            {
                try
                {
                    reply = ping.Send(IPAddress.Parse(task.IP), Convert.ToInt32(task.Limit));
                    if (reply.Status == IPStatus.Success)
                        time += reply.RoundtripTime;
                    else
                        packetslost++;
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", "Ping: " + x.ToString(), EventLogEntryType.Error);
                    packetslost++;
                }
            }
            if (packetslost == 5 || (time / (5 - packetslost)) > Convert.ToInt32(task.Limit))
                result = "down";
            else
                result = "up";
            return result;
        }

        private static void _DiskCheck(object o)
        {
            Task t = (Task)o;
            string status = t.Status;
            string newstatus = "";
            try
            {
                newstatus = DiskCheck(t);
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "DiskCheck: " + x.ToString(), EventLogEntryType.Error);
                newstatus = "down";
            }
            finally
            {
                try
                {
                    SendResult(t, status, newstatus);
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Error sending data: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static string DiskCheck(Task task)
        {
            string result = "";
            foreach (string driveletter in GetDriveLetters(task.IP))
            {
                bool local = false;
                System.Net.IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
                foreach (IPAddress ip in host.AddressList)
                {
                    if (IPAddress.Parse(task.IP).Equals(ip))
                    {
                        //Target machine is local
                        local = true;
                        break;
                    }
                }
                File.AppendAllText(logpath, DateTime.Now + " - Creating disk performance counter." + Environment.NewLine);
                using (PerformanceCounter diskCounter = new PerformanceCounter())
                {
                    File.AppendAllText(logpath, DateTime.Now + " - Disk performance counter successfully created." + Environment.NewLine);
                    diskCounter.InstanceName = driveletter;
                    diskCounter.CategoryName = "LogicalDisk";
                    diskCounter.CounterName = "Free Megabytes";
                    if (!local)
                        diskCounter.MachineName = task.IP;
                    try
                    {

                        float value = diskCounter.NextValue();

                        if (value < Convert.ToInt32(task.Limit))
                        { result = "down"; break; }
                        else
                        { result = "up"; }
                    }
                    catch (Exception x)
                    {
                        EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                        result = "down";
                        File.AppendAllText(logpath, DateTime.Now + " - diskcheck on " + task.IP + ": " + x.Message + Environment.NewLine);
                    }
                }
            }
            return result;
        }

        private static void _CpuCheck(object o)
        {
            Task t = (Task)o;
            string status = t.Status;
            string newstatus = "";
            try
            {
                newstatus = CpuCheck(t);
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "CpuCheck: " + x.ToString(), EventLogEntryType.Error);
                newstatus = "down";
            }
            finally
            {
                try
                {
                    SendResult(t, status, newstatus);
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Error sending data: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static string CpuCheck(Task task)
        {
            string result = "";
            bool local = false;
            System.Net.IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress ip in host.AddressList)
            {
                if (IPAddress.Parse(task.IP).Equals(ip))
                {
                    //Target machine is local
                    local = true;
                    break;
                }
            }
            File.AppendAllText(logpath, DateTime.Now + " - Creating cpu performance counter." + Environment.NewLine);
            PerformanceCounter CPU;
            if (!local)
                CPU = new PerformanceCounter("Processor", "% Processor Time", "_Total", task.IP);
            else
                CPU = new PerformanceCounter("Processor", "% Processor Time", "_Total");
            File.AppendAllText(logpath, DateTime.Now + " - Cpu performance counter successfully created." + Environment.NewLine);
            using (CPU)
            {
                try
                {
                    float value = CPU.NextValue();
                    if (value > Convert.ToInt32(task.Limit))
                    { result = "down"; }
                    else
                    { result = "up"; }
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    result = "down";
                    File.AppendAllText(logpath, DateTime.Now + " - cpucheck on " + task.IP + ": " + x.Message + Environment.NewLine);
                }
            }
            return result;
        }

        private static void _MemCheck(object o)
        {
            Task t = (Task)o;
            string status = t.Status;
            string newstatus = "";
            try
            {
                newstatus = MemCheck(t);
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "MemCheck: " + x.ToString(), EventLogEntryType.Error);
                newstatus = "down";
            }
            finally
            {
                try
                {
                    SendResult(t, status, newstatus);
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Error sending data: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static string MemCheck(Task task)
        {
            string result = "";
            bool local = false;
            System.Net.IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress ip in host.AddressList)
            {
                if (IPAddress.Parse(task.IP).Equals(ip))
                {
                    //Target machine is local
                    local = true;
                    break;
                }
            }
            File.AppendAllText(logpath, DateTime.Now + " - Creating memory performance counter." + Environment.NewLine);
            using (PerformanceCounter MemCounter = new PerformanceCounter())
            {
                File.AppendAllText(logpath, DateTime.Now + " - Memory performance counter successfully created." + Environment.NewLine);
                MemCounter.CategoryName = "Memory";
                MemCounter.CounterName = "Available MBytes";
                if (!local)
                    MemCounter.MachineName = task.IP;
                try
                {
                    float value = MemCounter.NextValue();
                    if (value < Convert.ToInt32(task.Limit))
                    { result = "down"; }
                    else
                    { result = "up"; }
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    result = "down";
                    File.AppendAllText(logpath, DateTime.Now + " - memcheck on " + task.IP + ": " + x.Message + Environment.NewLine);
                }
            }
            return result;
        }

        private static void _ProcCheck(object o)
        {
            Task t = (Task)o;
            string status = t.Status;
            string newstatus = "";
            try
            {
                newstatus = ProcCheck(t);
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "ProcCheck: " + x.ToString(), EventLogEntryType.Error);
                newstatus = "down";
            }
            finally
            {
                try
                {
                    SendResult(t, status, newstatus);
                }
                catch (Exception x)
                {
                    EventLog.WriteEntry("MyService", x.ToString(), EventLogEntryType.Error);
                    File.AppendAllText(logpath, DateTime.Now + " - Error sending data: " + x.Message + Environment.NewLine);
                }
            }
        }

        private static string ProcCheck(Task task)
        {
            string result = "";
            bool local = false;
            System.Net.IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress ip in host.AddressList)
            {
                if (IPAddress.Parse(task.IP).Equals(ip))
                {
                    //Target machine is local
                    local = true;
                    break;
                }
            }
            try
            {
                Process[] procs;
                if (local)
                    procs = Process.GetProcessesByName(task.Limit);
                else
                    procs = Process.GetProcessesByName(task.Limit, task.IP);
                if (procs.Length == 0)
                    result = "down";
                else
                    result = "up";
            }
            catch (Exception x)
            {
                EventLog.WriteEntry("MyService", "ProcCheck: " + x.ToString(), EventLogEntryType.Error);
                result = "down";
            }
            return result;
        }

        #endregion probes

        private static List<string> GetDriveLetters(string ip)
        {
            List<string> result = new List<string>();
            ManagementScope scope = new ManagementScope(@"\\" + ip + @"\root\cimv2");
            using (ManagementObjectSearcher mos = new ManagementObjectSearcher(scope, new ObjectQuery("SELECT * FROM Win32_LogicalDisk")))
            {
                using (ManagementObjectCollection moc = mos.Get())
                {
                    foreach (ManagementObject mo in moc)
                    {
                        object mediatype = mo["MediaType"];
                        if (mediatype != null && Convert.ToInt32(mediatype) == 12)
                        {
                            object type = mo["DriveType"];
                            if (type != null && Convert.ToInt32(type) == 3)
                            {
                                object letter = mo["DeviceID"];
                                if (letter != null)
                                    result.Add(letter.ToString());
                            }
                        }
                    }
                }
            }
            return result;
        }
    }

    public class Task
    {
        public int ID { get; private set; }
        public string IP { get; set; }
        public string Type { get; set; }
        public string Limit { get; set; }
        public string Status { get; set; }

        public Task(int ID, string IP, string Type, string Limit)
        {
            this.ID = ID;
            this.IP = IP;
            this.Type = Type;
            this.Limit = Limit;
            this.Status = "";
        }

        public override string ToString()
        {
            return Type + " on " + IP;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is Task))
                return false;
            else
            {
                if (((Task)obj).ID == this.ID)
                    return true;
                else
                    return false;
            }
        }
    }
}

This is the output from my log when it went down last night:

26-03-2010 00:06:39 - Creating cpu performance counter.
26-03-2010 00:06:39 - Creating memory performance counter.
26-03-2010 00:06:39 - Cpu performance counter successfully created.
26-03-2010 00:06:39 - Memory performance counter successfully created.
26-03-2010 00:06:40 - Creating disk performance counter.
26-03-2010 00:06:40 - Disk performance counter successfully created.
26-03-2010 00:06:40 - Creating disk performance counter.
26-03-2010 00:06:40 - Disk performance counter successfully created.
26-03-2010 00:07:39 - Trying to get config.
26-03-2010 00:08:01 - Probing loop: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond 62.242.131.218:31512
26-03-2010 00:08:06 - Trying again. updateCount = 3
26-03-2010 00:08:06 - Trying to get config.
26-03-2010 00:08:27 - Probing loop: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond 62.242.131.218:31512
26-03-2010 00:08:32 - Trying again. updateCount = 4
26-03-2010 00:08:32 - Trying to get config.
26-03-2010 00:08:53 - Probing loop: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond 62.242.131.218:31512
26-03-2010 00:08:58 - Trying again. updateCount = 5
26-03-2010 00:08:58 - Trying to get config.

And that is the end of the log ... it just stops :-/

answered one year ago by:

foamy
2499
edited one year ago

(x)

foamy
2499

Oh, and the service (and thereby the .exe file) was still running this morning, apparently not doing anything.

add comment

Why is my Windows Service dying?

6 answers

Welcome to debugging.com!