public void Send(OutputEntry entry)
 {
     lock (entries)
     {
         entries.Enqueue(entry);
     }
     signal.Signal();
 }
예제 #2
0
 static void Send(LogTarget target, OutputEntry output)
 {
     if (target == null)
     {
         lock (logTargets)
             foreach (var tar in logTargets)
             {
                 tar.Send(output);
             }
     }
     else
     {
         target.Send(output);
     }
 }
        void OutputThread()
        {
            try
            {
                var list = new OutputEntry [ProgramLog.LOG_THREAD_BATCH_SIZE];

                while (exit == false || EntryCount() > 0)
                {
                    int items = 0;

                    lock (entries)
                    {
                        while (entries.Count > 0)
                        {
                            list[items++] = entries.Dequeue ();
                            if (items == ProgramLog.LOG_THREAD_BATCH_SIZE) break;
                        }
                    }

                    if (items == 0)
                    {
                        if (exit)
                            break;
                        else
                            signal.WaitForIt ();
                    }

                    for (int i = 0; i < items; i++)
                    {
                        var entry = list[i];
                        list[i] = default(OutputEntry);

                        if (entry.prefix != null)
                        {
                            file.Write (entry.prefix);
                        }

                        if (entry.message is string)
                        {
                            var str = (string) entry.message;
                            file.WriteLine (str);
                            file.Flush ();
                        }
                        else if (entry.message is ProgressLogger)
                        {
                            var prog = (ProgressLogger) entry.message;
                            var str = "";

                            if (entry.arg == -1) // new one
                            {
                                str = String.Format ("{0}: started.", prog.Message);
                            }
                            else if (entry.arg == -2) // finished one
                            {
                                str = prog.Format (true);
                            }
                            else // update
                            {
                                str = prog.Format (prog.Max != 100, entry.arg);
                            }

                            file.WriteLine (str);
                            file.Flush ();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine (e.ToString());
            }

            try
            {
                file.Close ();
            }
            catch {}
        }
 public void Send(OutputEntry entry)
 {
     lock (entries)
     {
         entries.Enqueue (entry);
     }
     signal.Signal ();
 }
        protected virtual void OutputThread()
        {
            try
            {
                var list = new OutputEntry [ProgramLog.LOG_THREAD_BATCH_SIZE];
                var progs = new List<ProgressLogger> ();
                var backspace = 0;

                while (exit == false || EntryCount() > 0)
                {
                    int items = 0;

                    lock (entries)
                    {
                        while (entries.Count > 0)
                        {
                            list[items++] = entries.Dequeue ();
                            if (items == ProgramLog.LOG_THREAD_BATCH_SIZE) break;
                        }
                    }

                    if (items == 0)
                    {
                        if (exit)
                            break;
                        else if (progs.Count == 0)
                            signal.WaitForIt ();
                    }

                    if (backspace > 0)
                    {
                        writer.Write ("\r");
                    }

                    for (int i = 0; i < items; i++)
                    {
                        var entry = list[i];
                        list[i] = default(OutputEntry);

                        if (entry.prefix != null)
                        {
                            SetColor (ConsoleColor.DarkGray);
                            writer.Write (entry.prefix);
                            backspace -= entry.prefix.Length;
                        }

                        if (entry.color != null)
                            SetColor ((ConsoleColor) entry.color);
                        else
                            SetColor (ConsoleColor.Gray);

                        if (entry.message is string)
                        {
                            var str = (string) entry.message;
                            writer.WriteLine(str);
                            HandleConsoleHook(str, entry.logger);
                            backspace -= str.Length;
                        }
                        else if (entry.message is ProgressLogger)
                        {
                            var prog = (ProgressLogger) entry.message;
                            var str = "";

                            if (entry.arg == -1) // new one
                            {
                                progs.Add (prog);
                                str = String.Format ("{0}: started.", prog.Message);
                            }
                            else if (entry.arg == -2) // finished one
                            {
                                progs.Remove (prog);
                                str = prog.Format (true);
                            }
                            else // update
                            {
                                str = prog.Format (prog.Max != 100, entry.arg);
                            }

                            backspace -= str.Length;
                            if (backspace <= 0)
                            {
                                writer.WriteLine(str);
                                HandleConsoleHook(str, entry.logger);
                            }
                            else
                            {
                                writer.Write(str);
                                for (int j = 0; j < backspace; j++)
                                    writer.Write(" ");
                            }
                        }

                        ResetColor ();
                    }

                    backspace = 0;
                    foreach (var prog in progs)
                    {
                        var str = String.Format ("[ {0} ] ", prog.Format());
                        backspace += str.Length;
                        writer.Write (str);
                    }

                    if (progs.Count > 0)
                        SignalIncompleteLine ();

                    if (backspace > 0 && EntryCount() == 0)
                    {
                        signal.WaitForIt (100);
                    }
                }
            }
            catch (Exception e)
            {
                if (! passExceptions)
                    Console.Error.WriteLine (e.ToString());
                else
                    throw;
            }
        }
예제 #6
0
        static void LogDispatchThread()
        {
            try
            {
                var list  = new LogEntry[LOG_THREAD_BATCH_SIZE];
                var progs = new List <ProgressLogger>();
                var last  = default(OutputEntry);
                var run   = 0;

                while (exit == false || EntryCount() > 0)
                {
                    int items = 0;

                    lock (entries)
                    {
                        while (entries.Count > 0)
                        {
                            list[items++] = entries.Dequeue();
                            if (items == LOG_THREAD_BATCH_SIZE)
                            {
                                break;
                            }
                        }
                    }

                    if (items == 0)
                    {
                        if (exit)
                        {
                            break;
                        }
                        else
                        {
                            logSignal.WaitForIt();
                        }
                    }

                    for (int i = 0; i < items; i++)
                    {
                        var entry = list[i];
                        list[i] = default(LogEntry);
                        OutputEntry output;

                        Build(entry, out output);

                        if (entry.message is ProgressLogger)
                        {
                            var prog = (ProgressLogger)entry.message;

                            if (progs.Remove(prog))
                            {
                                // it's done
                                output.arg = -2;
                            }
                            else
                            {
                                // new one
                                progs.Add(prog);
                                output.arg = -1;
                            }
                        }
                        else
                        {
                            // force updates of progress loggers in the same thread
                            foreach (var prog in progs)
                            {
                                if (prog.Thread == entry.thread)
                                {
                                    var upd = new OutputEntry {
                                        prefix = output.prefix, message = prog, arg = prog.Value
                                    };
                                    Send(entry.target, upd);
                                    last = upd;
                                    run  = 0;
                                }
                            }
                        }

                        if (output.message.Equals(last.message) && output.prefix == last.prefix && output.arg == last.arg)
                        {
                            run += 1;
                            //System.ProgramLog.Log (run);
                        }
                        else if (run > 0)
                        {
                            //System.ProgramLog.Log ("sending");
                            last.message = String.Format("Log message repeated {0} times", run);
                            Send(entry.target, last);
                            last = output;
                            run  = 0;
                            Send(entry.target, output);
                        }
                        else
                        {
                            last = output;
                            Send(entry.target, output);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.ToString());
            }

            lock (logTargets)
                foreach (var tar in logTargets)
                {
                    tar.Close();
                }

            //Statics.IsActive = false;
            Terraria.Netplay.disconnect = true;
        }
예제 #7
0
        //static int nextPoolIndex = 0;

        static void Build(LogEntry entry, out OutputEntry output)
        {
            Exception error = null;

            output = default(OutputEntry);

            if (entry.channel != null)
            {
                output.color = entry.channel.Color;
            }
            else if (entry.color != null)
            {
                output.color = entry.color.Value;
            }

            output.logger = entry.logger;

            try
            {
                if (entry.message is string)
                {
                    var text = (string)entry.message;

                    if (entry.args != null)
                    {
                        var args = (object[])entry.args;
                        try
                        {
                            text = String.Format(text, args);
                        }
                        catch (Exception)
                        {
                            text = String.Format("<Incorrect log message format string or argument list: message=\"{0}\", args=({1})>",
                                                 text, String.Join(", ", args));
                        }
                    }

                    output.message = text;
                }
                else if (entry.message is Exception)
                {
                    var e = (Exception)entry.message;

                    if (entry.args is string)
                    {
                        output.message = String.Format("{0}:{1}{2}", entry.args, Environment.NewLine, e.ToString());
                    }
                    else
                    {
                        output.message = e.ToString();
                    }
                }
                else
                {
                    output.message = entry.message;
                }

                var thread = "?";
                if (entry.thread != null)
                {
                    if (entry.thread.IsThreadPoolThread)
                    {
                        thread = "Pool";
                        //						string name;
                        //						if (poolNames.TryGetValue (entry.thread, out name))
                        //						{
                        //							thread = name;
                        //						}
                        //						else
                        //						{
                        //							thread = String.Format ("P{0:000}", nextPoolIndex++);
                        //							poolNames[entry.thread] = thread;
                        //						}
                    }
                    else if (entry.thread.Name != null)
                    {
                        thread = entry.thread.Name;
                    }
                }

                if (entry.thread != null && entry.time != default(DateTime))
                {
                    output.prefix = String.Format("{0} {1}> ", entry.time, thread);
                }
            }
            catch (Exception e)
            {
                error = e;
            }

            if (error != null)
            {
                try
                {
                    System.Console.WriteLine("Error writing log entry:");
                    System.Console.WriteLine(error.ToString());
                }
                catch (Exception) { }
            }
        }
        void OutputThread()
        {
            try
            {
                var list = new OutputEntry [ProgramLog.LOG_THREAD_BATCH_SIZE];

                while (exit == false || EntryCount() > 0)
                {
                    int items = 0;

                    lock (entries)
                    {
                        while (entries.Count > 0)
                        {
                            list[items++] = entries.Dequeue();
                            if (items == ProgramLog.LOG_THREAD_BATCH_SIZE)
                            {
                                break;
                            }
                        }
                    }

                    if (items == 0)
                    {
                        if (exit)
                        {
                            break;
                        }
                        else
                        {
                            signal.WaitForIt();
                        }
                    }

                    for (int i = 0; i < items; i++)
                    {
                        var entry = list[i];
                        list[i] = default(OutputEntry);

                        if (entry.prefix != null)
                        {
                            file.Write(entry.prefix);
                        }

                        if (entry.message is string)
                        {
                            var str = (string)entry.message;
                            file.WriteLine(str);
                            file.Flush();
                        }
                        else if (entry.message is ProgressLogger)
                        {
                            var prog = (ProgressLogger)entry.message;
                            var str  = "";

                            if (entry.arg == -1)                             // new one
                            {
                                str = String.Format("{0}: started.", prog.Message);
                            }
                            else if (entry.arg == -2)                             // finished one
                            {
                                str = prog.Format(true);
                            }
                            else                             // update
                            {
                                str = prog.Format(prog.Max != 100, entry.arg);
                            }

                            file.WriteLine(str);
                            file.Flush();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine(e.ToString());
            }

            try
            {
                file.Close();
            }
            catch {}
        }
        protected virtual void OutputThread()
        {
            try
            {
                var list      = new OutputEntry [ProgramLog.LOG_THREAD_BATCH_SIZE];
                var progs     = new List <ProgressLogger> ();
                var backspace = 0;

                while (exit == false || EntryCount() > 0)
                {
                    int items = 0;

                    lock (entries)
                    {
                        while (entries.Count > 0)
                        {
                            list[items++] = entries.Dequeue();
                            if (items == ProgramLog.LOG_THREAD_BATCH_SIZE)
                            {
                                break;
                            }
                        }
                    }

                    if (items == 0)
                    {
                        if (exit)
                        {
                            break;
                        }
                        else if (progs.Count == 0)
                        {
                            signal.WaitForIt();
                        }
                    }

                    if (backspace > 0)
                    {
                        writer.Write("\r");
                    }

                    for (int i = 0; i < items; i++)
                    {
                        var entry = list[i];
                        list[i] = default(OutputEntry);

                        if (entry.prefix != null)
                        {
                            SetColor(ConsoleColor.DarkGray);
                            writer.Write(entry.prefix);
                            backspace -= entry.prefix.Length;
                        }

                        if (entry.color != null)
                        {
                            SetColor((ConsoleColor)entry.color);
                        }
                        else
                        {
                            SetColor(ConsoleColor.Gray);
                        }

                        if (entry.message is string)
                        {
                            var str = (string)entry.message;
                            writer.WriteLine(str);
                            HandleConsoleHook(str, entry.logger);
                            backspace -= str.Length;
                        }
                        else if (entry.message is ProgressLogger)
                        {
                            var prog = (ProgressLogger)entry.message;
                            var str  = "";

                            if (entry.arg == -1)                             // new one
                            {
                                progs.Add(prog);
                                str = String.Format("{0}: started.", prog.Message);
                            }
                            else if (entry.arg == -2)                             // finished one
                            {
                                progs.Remove(prog);
                                str = prog.Format(true);
                            }
                            else                             // update
                            {
                                str = prog.Format(prog.Max != 100, entry.arg);
                            }

                            backspace -= str.Length;
                            if (backspace <= 0)
                            {
                                writer.WriteLine(str);
                                HandleConsoleHook(str, entry.logger);
                            }
                            else
                            {
                                writer.Write(str);
                                for (int j = 0; j < backspace; j++)
                                {
                                    writer.Write(" ");
                                }
                            }
                        }

                        ResetColor();
                    }

                    backspace = 0;
                    foreach (var prog in progs)
                    {
                        var str = String.Format("[ {0} ] ", prog.Format());
                        backspace += str.Length;
                        writer.Write(str);
                    }

                    if (progs.Count > 0)
                    {
                        SignalIncompleteLine();
                    }

                    if (backspace > 0 && EntryCount() == 0)
                    {
                        signal.WaitForIt(100);
                    }
                }
            }
            catch (Exception e)
            {
                if (!passExceptions)
                {
                    Console.Error.WriteLine(e.ToString());
                }
                else
                {
                    throw;
                }
            }
        }