ProcessWatchImpl/Muffin/OriginalAlertApiReceiever.cs

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using SeedCreate.CommonLibrary.Threading;
using dbg = SeedCreate.CommonLibrary.DebugHelper;


namespace Toast.NicoNico
{
        public sealed class OriginalAlertApiReceiever:IDisposable
        {
                private static readonly string RequestFormat = 
                        "<?xml version=\"1.0\" encoding=\"utf-8\" ?> <thread thread=\"{0}\" version=\"20061206\" res_from=\"-200\"/>\0";

                private static readonly Regex Splitter;


                private class DelayController:IDisposable
                {
                        private static readonly TimeSpan RecoverLongDelay = new TimeSpan(0, 10, 0);
                        private static readonly TimeSpan RecoverShortDelay = new TimeSpan(0, 0, 10);
                        private static readonly int RetryThreshold = 2;

                        private AutoResetEvent delayGate;
                        private int tryCount;

                        public DelayController()
                        {
                                delayGate = new AutoResetEvent(false);
                                tryCount = 0;
                        }

                        public void WaitOne()
                        {
                                lock (delayGate)
                                {
                                        if (++tryCount > RetryThreshold)
                                        {
                                                delayGate.WaitOne(RecoverLongDelay);
                                        }
                                        else
                                        {
                                                delayGate.WaitOne(RecoverShortDelay);
                                        }
                                }
                        }

                        public void ResetCount()
                        {
                                lock (delayGate)
                                {
                                        tryCount = 0;
                                }
                        }

                        public void Dispose()
                        {
                                delayGate.Close();
                                GC.SuppressFinalize(this);
                        }
                }

                public event EventHandler<DetectProgramStartEventArgs> ProgramStarted;
                public event EventHandler<ReceieverStatusChangedEventArgs> StatusChanged;

                private Thread recieveWorker;
                private Thread eventWorker;

                private ExclusiveQueue<LiveProgram> queue;

                private ReceieverStatus status;
                private readonly object syncRoot = new object();
                private DelayController delayGate;
                private bool isRunning;


                static OriginalAlertApiReceiever()
                {
                        Splitter = new Regex("^<.*?>(?<id>.*?),(?<comunity>.*?),(?<user>.*?)<.*?>.*$");

                }

                public OriginalAlertApiReceiever(uint myId)
                {
                        recieveWorker = new Thread(new ThreadStart(RecieveProcess));
                        recieveWorker.Name = "ReceieverWorker";
                        recieveWorker.IsBackground = true;

                        eventWorker = new Thread(new ThreadStart(EventProcess));
                        eventWorker.Name = "EventWorker";
                        eventWorker.IsBackground = true;

                        queue = new ExclusiveQueue<LiveProgram>();

                        MyId = myId;
                        status = ReceieverStatus.PreRunning;

                        delayGate = new DelayController();
                }

                public uint MyId
                {
                        get;
                        private set;
                }

                public ReceieverStatus Status
                {
                        get
                        {
                                lock (syncRoot)
                                {
                                        return status;
                                }
                        }
                }

                public bool Start()
                {
                        lock (syncRoot)
                        {
                                if (isRunning)
                                {
                                        return false;
                                }


                                recieveWorker.Start();
                                eventWorker.Start();
                                isRunning = true;
                                return true;
                        }
                }

#if DEBUG_TESTING
                private bool IsDebug=false;

                public bool DebugStart()
                {
                        if (recieveWorker.ThreadState == ThreadState.Running)
                        {
                                return false;
                        }

                        IsDebug = true;

                        recieveWorker.Start();
                        eventWorker.Start();
                        return true;

                }
#endif

                public bool Stop()
                {
                        lock (syncRoot)
                        {
                                if (isRunning)
                                {
                                        recieveWorker.Abort();
                                        recieveWorker.Join();
                                        eventWorker.Interrupt();
                                        eventWorker.Join();

                                        isRunning = false;
                                        return true;
                                }
                                else
                                {
                                        return false;
                                }

                        }
                }

                private void RecieveProcess()
                {
                        try
                        {
                                for (; ; )
                                {
                                        RequestResponse response = null;

                                        try
                                        {
                                                response = PreConnectControl.GetConnectInformation();

                                                byte[] buff = Encoding.UTF8.GetBytes(string.Format(RequestFormat, response.ThreadId));

                                                using (TcpClient Reciever = new TcpClient())
                                                {
                                                        Reciever.SendTimeout = Constants.DefaultTimeOut;
                                                        Reciever.ReceiveTimeout = Constants.DefaultTimeOut;
                                                        Reciever.Connect(response.Address, response.Port);

                                                        using (NetworkStream str = Reciever.GetStream())
                                                        {
                                                                str.Write(buff, 0, buff.Length);
                                                                str.Flush();
                                                                buff = null;

                                                                MemoryStream memstr = new MemoryStream();
                                                                int charbuff = 0;
                                                                StreamReader rdr = new StreamReader(memstr, Encoding.UTF8);


                                                                for (; ; )
                                                                {
                                                                        charbuff = str.ReadByte();

                                                                        if (charbuff == 0)
                                                                        {
                                                                                //NOTE:効率化のため、あり得ないコトやってる。完全に処理系依存なので、注意すること。
                                                                                memstr.Position = 0;
#if !DEBUG_TESTING
                                                                                Inspect(rdr.ReadLine());
#else
                                                                                if(IsDebug)
                                                                                {
                                                                                        DebugInspect(rdr.ReadLine());
                                                                                }
                                                                                else
                                                                                {
                                                                                        Inspect(rdr.ReadLine());
                                                                                }
#endif
                                                                                memstr.Position = 0;
                                                                                delayGate.ResetCount();
                                                                        }
                                                                        else
                                                                        {
                                                                                memstr.WriteByte((byte)charbuff);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                        catch (ThreadAbortException)
                                        {
                                                break;
                                        }
                                        catch (ThreadInterruptedException)
                                        {
                                                break;
                                        }
                                        catch
                                        {
                                                try
                                                {
                                                        delayGate.WaitOne();
                                                }
                                                catch
                                                {
                                                        throw;
                                                }
                                                continue;
                                        }
                                }
                        }
                        catch (ThreadAbortException)
                        {
                        }
                        catch (ThreadInterruptedException)
                        {
                        }

                }

                private void EventProcess()
                {
                        try
                        {
                                for (; ; )
                                {
                                        
                                        var info = queue.Dequeue();
                                        if (info.ValueU)
                                        {
                                                OnProgramStarted(this, new DetectProgramStartEventArgs(info.ValueT));
                                        }
                                }
                        }
                        catch (ThreadAbortException)
                        {
                        }
                        catch (ThreadInterruptedException)
                        {
                        }
                }

                private void Inspect(string Source)
                {
                        if (Splitter.IsMatch(Source == null ? string.Empty : Source))
                        {
                                uint UID = 0;
                                if (uint.TryParse(Splitter.Replace(Source, "${user}"), out UID))
                                {
                                        if (MyId == UID)
                                        {

                                                //Console.WriteLine(UID);
                                                uint lvid = 0;
                                                if (uint.TryParse(Splitter.Replace(Source, "${id}"), out lvid))
                                                {
                                                        RaiseEventPreProcess(lvid);
                                                }
                                        }
                                }
                        }
                }

#if DEBUG_TESTING
                private int Count = 0;

                private void DebugInspect(string Source)
                {
                        if (Splitter.IsMatch(Source == null ? string.Empty : Source))
                        {
                                if (++Count < 200)
                                {
                                        return;
                                }

                                if (Count % 50 == 0)
                                {
                                        if (Splitter.IsMatch(Source == null ? string.Empty : Source))
                                        {
                                                uint UID = 0;
                                                if (uint.TryParse(Splitter.Replace(Source, "${user}"), out UID))
                                                {

                                                        //Console.WriteLine(UID);
                                                        uint lvid = 0;
                                                        if (uint.TryParse(Splitter.Replace(Source, "${id}"), out lvid))
                                                        {
                                                                RaiseEventPreProcess(lvid);
                                                        }
                                                }
                                        }
                                }
                        }
                }
#endif


                private void RaiseEventPreProcess(uint Id)
                {
                        try
                        {
                                LiveProgram program = QueryProgramDetail.Query(Id);

                                Console.WriteLine("RaiseEvent:{0}\n\t{1}\n\t{2}", program.Title, program.CommunityName, program.Description);
                                Console.WriteLine();

                                queue.Enqueue(program);
                        }
                        catch
                        {
                                //TODO:ここにエラーレポートの処理挟む
                        }
                }


                private void OnProgramStarted(object sender, DetectProgramStartEventArgs e)
                {
                        if (ProgramStarted != null)
                        {
                                ProgramStarted(sender, e);
                        }
                }

                private void OnStatusChanged(object sender, ReceieverStatusChangedEventArgs e)
                {
                        if (StatusChanged != null)
                        {
                                StatusChanged(sender, e);
                        }

                        lock (syncRoot)
                        {
                                status = e.Current;
                        }
                }

                #region IDisposable メンバ

                public void Dispose()
                {
                        dbg::TinyDebugWriter.WriteLine();
                        dbg::TinyDebugWriter.WriteLine("Dispose process start");

                        while (!recieveWorker.Join(Constants.DefaultJoinWait))
                        {
                                try
                                {
                                        recieveWorker.Abort();
                                }
                                catch (ThreadStateException)
                                {
                                        //No need to anyting.
                                        dbg::TinyDebugWriter.WriteLine("RecieveWorker ThreadStateException occured");
                                }
                        }

                        dbg::TinyDebugWriter.WriteLine("Recieveworkker aborted");
                        dbg::TinyDebugWriter.WriteLine(string.Format("RecieveWorker.IsAlive={0}", recieveWorker.IsAlive));
                        dbg::TinyDebugWriter.WriteLine();

                        while (!eventWorker.Join(1000))
                        {
                                eventWorker.Interrupt();
                                dbg::TinyDebugWriter.WriteLine("ThreadState:{0}", eventWorker.ThreadState.ToString());
                        }

                        dbg::TinyDebugWriter.WriteLine("Eventworker interrupted");
                        dbg::TinyDebugWriter.WriteLine(string.Format("RecieveWorker.IsAlive={0}", recieveWorker.IsAlive));
                        dbg::TinyDebugWriter.WriteLine();


                        delayGate.Dispose();
                        queue.Dispose();

                        GC.SuppressFinalize(this);
                }

                #endregion
        }
}