1 files changed, 153 insertions, 0 deletions
diff --git a/samples/OpenIdOfflineProvider/TextLogProvider.cs b/samples/OpenIdOfflineProvider/TextLogProvider.cs
new file mode 100644
index 0000000..84be699
--- /dev/null
+++ b/samples/OpenIdOfflineProvider/TextLogProvider.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Remoting.Messaging;
+using System.ServiceModel.Dispatcher;
+
+using DotNetOpenAuth.Logging;
+using DotNetOpenAuth.Logging.LogProviders;
+using DotNetOpenAuth.OpenId.Extensions.AttributeExchange;
+
+namespace DotNetOpenAuth.OpenIdOfflineProvider {
+
+    /// <summary>
+    /// Sends logging events to a <see cref="TextWriter"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// An Appender that writes to a <see cref="TextWriter"/>.
+    /// </para>
+    /// <para>
+    /// This appender may be used stand alone if initialized with an appropriate
+    /// writer, however it is typically used as a base class for an appender that
+    /// can open a <see cref="TextWriter"/> to write to.
+    /// </para>
+    /// </remarks>
+    /// <author>Nicko Cadell</author>
+    /// <author>Gert Driesen</author>
+    /// <author>Douglas de la Torre</author>
+    public class TextWriterLogProvider : ILogProvider {
+        public class TextWriterLogger : ILog {
+            private const string LogSystem = "LibLog";
+
+            private readonly string _category;
+            private readonly WriteDelegate _logWriteDelegate;
+            private readonly int _skipLevel;
+
+            internal TextWriterLogger(string category, WriteDelegate logWriteDelegate) {
+                _category = category;
+                _logWriteDelegate = logWriteDelegate;
+                _skipLevel = 1;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception) {
+                if (messageFunc == null) {
+                    //nothing to log..
+                    return true;
+                }
+
+                _logWriteDelegate((int)ToLogMessageSeverity(logLevel), LogSystem, _skipLevel, exception, true, 0, null,
+                    _category, null, messageFunc.Invoke());
+
+                return true;
+            }
+
+            public TraceEventType ToLogMessageSeverity(LogLevel logLevel) {
+                switch (logLevel) {
+                    case LogLevel.Trace:
+                        return TraceEventType.Verbose;
+                    case LogLevel.Debug:
+                        return TraceEventType.Verbose;
+                    case LogLevel.Info:
+                        return TraceEventType.Information;
+                    case LogLevel.Warn:
+                        return TraceEventType.Warning;
+                    case LogLevel.Error:
+                        return TraceEventType.Error;
+                    case LogLevel.Fatal:
+                        return TraceEventType.Critical;
+                    default:
+                        throw new ArgumentOutOfRangeException("logLevel");
+                }
+            }
+
+            /// <summary>
+            /// The form of the Loupe Log.Write method we're using
+            /// </summary>
+            internal delegate void WriteDelegate(
+                int severity,
+                string logSystem,
+                int skipFrames,
+                Exception exception,
+                bool attributeToException,
+                int writeMode,
+                string detailsXml,
+                string category,
+                string caption,
+                string description,
+                params object[] args
+                );
+        }
+
+         private static bool _providerIsAvailableOverride = true;
+        private readonly TextWriterLogger.WriteDelegate _logWriteDelegate;
+
+        public TextWriterLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("Gibraltar.Agent.Log (Loupe) not found");
+            }
+
+            _logWriteDelegate = GetLogWriteDelegate();
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether [provider is available override]. Used in tests.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if [provider is available override]; otherwise, <c>false</c>.
+        /// </value>
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public ILog GetLogger(string name)
+        {
+            return new TextWriterLogProvider.TextWriterLogger(name, _logWriteDelegate);
+        }
+
+        public static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && GetLogManagerType() != null;
+        }
+
+        private static Type GetLogManagerType()
+        {
+            return Type.GetType("Gibraltar.Agent.Log, Gibraltar.Agent");
+        }
+
+        private static TextWriterLogger.WriteDelegate GetLogWriteDelegate()
+        {
+            Type logManagerType = GetLogManagerType();
+            Type logMessageSeverityType = Type.GetType("Gibraltar.Agent.LogMessageSeverity, Gibraltar.Agent");
+            Type logWriteModeType = Type.GetType("Gibraltar.Agent.LogWriteMode, Gibraltar.Agent");
+
+            MethodInfo method = logManagerType.GetMethod("Write", new[]
+                                                                  {
+                                                                      logMessageSeverityType, typeof(string), typeof(int), typeof(Exception), typeof(bool), 
+                                                                      logWriteModeType, typeof(string), typeof(string), typeof(string), typeof(string), typeof(object[])
+                                                                  });
+
+            var callDelegate = (TextWriterLogger.WriteDelegate)Delegate.CreateDelegate(typeof(TextWriterLogger.WriteDelegate), method);
+            return callDelegate;
+        }
+    }
+}