//this utility handles photo sharing for http://itis-time.ru robots

//it runs local http server and listens to requests such as

// http://localhost:6556/?imageUrl=C:\someFSPath\someimgfile.jpg&email=bessgeor@gmail.com,bessgeor@itis-time.ru&tw=true

//which is standing for "send C:\someFSPath\someimgfile.jpg to bessgeor@gmail.com, and bessgeor@itis-time.ru and tweet it"

​

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Text;

using System.Timers;

using System.Net;

using System.Diagnostics;

using System.Threading.Tasks;

​

//NetworkCommunication and FileCommunication are defined in different files and may be shown too if needed

//They provide static methods to communicate with filesystem and external web resources as stated by their names 

​

namespace PhotoServiceDaemon

{

    class Program

    {

        static ConcurrentQueue<string[]> _queue;

        static public object QueueHandlerSendsPendingLock = new object();

        static public int QueueHandlerSendsPending = 0;

​

        static async void Send(string[] args)

        {

            lock (QueueHandlerSendsPendingLock)

                QueueHandlerSendsPending++;

            var result = NetworkCommunication.Send(args);

            switch (result)

            {

                case 0:

                    FileCommunication.WriteSuccess(args);

                    break;

                case 1:

                    FileCommunication.WriteResend(args);

                    break;

                default:  

                    string s;

                    //if there was an error that causes resend unavailability there will be information about it

                    while (!NetworkCommunication.Errors.TryRemove(args, out s)) { await Task.Delay(50); }

                    FileCommunication.WriteError(args, s);

                    break;

            }

        }

​

        static bool isTimerFiredAtLeastOnce = false;

​

        static async void QueueHandler_Elapsed(object sender, ElapsedEventArgs e)

        {

            //initialize loading of values that need re-sending from filesystem

            var _alreadyQueued = Task.Factory.StartNew(FileCommunication.GetResendQueue);

​

            var temporaryCollection = new List<string[]>();

            string[] tmp;

​

            //make a snapshot of current queue

            while (!_queue.IsEmpty)

            {

                while (!_queue.TryDequeue(out tmp)) await Task.Delay(10);

                temporaryCollection.Add(tmp);

            }

            //add to snapshot values that need re-sending

            while (!_alreadyQueued.Result.IsEmpty)

            {

                while (!_alreadyQueued.Result.TryDequeue(out tmp)) await Task.Delay(10);

                temporaryCollection.Add(tmp);

            }

​

            //procceed the values unsend

            var tmpCount = temporaryCollection.Count;

            if (tmpCount > 20)

                Parallel.ForEach(temporaryCollection, Send);

            else

                for (var i = 0; i < tmpCount; i++)

                    Send(temporaryCollection[i]);

​

            //to ensure that we already trying to send something

            isTimerFiredAtLeastOnce = true;

        }

​

        static void RestartAsAdmin()

        {

            var startInfo = new ProcessStartInfo("PhotoServiceDaemon.exe") { Verb = "runas" };

            Process.Start(startInfo);

            Environment.Exit(0);

        }

​

        static void ExecuteCommand(string command)

        {

            ProcessStartInfo processInfo;

            Process process;

​

            processInfo = new ProcessStartInfo("cmd.exe", "/c " + command);

            processInfo.CreateNoWindow = true;

            processInfo.UseShellExecute = false;

​

            process = Process.Start(processInfo);

            process.WaitForExit();

            process.Close();

        }

​

        static void Main(string[] args)

        {

            _queue = new ConcurrentQueue<string[]>();

            var QueueHandler = new Timer(5 * 60 * 1000);

            QueueHandler.Elapsed += QueueHandler_Elapsed;

            QueueHandler.AutoReset =  true;

            QueueHandler.Start();

​

            //start http listener

            var listener = new HttpListener();

            listener.Prefixes.Add("http://127.0.0.1:6556/");

​

            try

            {

                listener.Start();

            }

            catch (HttpListenerException e)

            {

                if (e.ErrorCode == 5)

                    RestartAsAdmin();

                else throw e;

            }

​

            while (true)

            {

                //listen for request

                var context = listener.GetContext();

                Console.WriteLine("got request");

                var _request = context.Request;

                var response = context.Response;

​

                //get request

                var req = _request.QueryString;

                var request = new Dictionary<string, string>();

​

                foreach (var key in req.AllKeys)

                {

                    request.Add(key, req[key]);

                    Console.WriteLine("{0}: {1}\n", key, key == "additionalInfo" ? WebUtility.UrlDecode(req[key]) : req[key]);

                }

​

                byte[] buff;

                System.IO.Stream outstream;

                if (request.Count < 2 || !request.ContainsKey("imageUrl"))

                {

                    #region send Bad Request response

                    response.AddHeader("Access-Control-Allow-Origin", "*");

                    response.StatusCode = 400;

                    buff = Encoding.UTF8.GetBytes("Incorrect request: querystring either contains lesser than two params or doesn't specify imageUrl param");

                    response.ContentLength64 = buff.LongLength;

                    outstream = response.OutputStream;

                    outstream.Write(buff, 0, buff.Length);

                    outstream.Close();

                    #endregion

                }

                else

                {

                    var img = request["imageUrl"];

                    string info = null;

                    if (request.ContainsKey("additionalInfo"))

                        info = WebUtility.UrlDecode(request["additionalInfo"]);

​

                    foreach (var key in request.Keys)

                    {

                        if (key == NetworkCommunication.mail)

                            foreach (var email in request[key].Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))

                                _queue.Enqueue(info == null ? new string[] { img, key, email } : new string[] { img, key, email, info });

                        else

                            if (NetworkCommunication.SocialNetworkList.Contains(key))

                            if (Convert.ToBoolean(request[key]))

                                _queue.Enqueue(info == null ? new string[] { img, key } : new string[] { img, key, info });

                    }

​

                    #region send OK response

                    response.AddHeader("Access-Control-Allow-Origin", "*");

                    buff = Encoding.UTF8.GetBytes("OK");

                    response.ContentLength64 = buff.LongLength;

                    outstream = response.OutputStream;

                    outstream.Write(buff, 0, buff.Length);

                    outstream.Close();

                    #endregion

                }

​

                if (request.ContainsKey("killdaemon") && Convert.ToBoolean(request["killdaemon"]))

                    break;

            }

            listener.Stop();

​

            int local;

            lock (QueueHandlerSendsPendingLock) local = QueueHandlerSendsPending;

            /*

             * QueueHandlerSendsPending - sendings pending counter/

             *   Also counts as sending part IO operations of logging.

             *   Also counts as sending IO reading of unsuccesful sendings

             * local - local stack copy sendings pending counter

             * isTimerFiredAtLeastOnce - crutch for case if killdaemon was sent before first timer tick

             * _queue.Count > 0 is for case when killdaemon was sent after timer.Elapsed fired but before any dequeues

             */

            while (local > 0 || !isTimerFiredAtLeastOnce || _queue.Count > 0)

            {

                System.Threading.Thread.Sleep(10000);

                lock (QueueHandlerSendsPendingLock) local = QueueHandlerSendsPending;

            }

            FileCommunication.Dispose();

        }

    }

}

​