Revision db8a9589 trunk/Pithos.Client.WPF/App.xaml.cs

b/trunk/Pithos.Client.WPF/App.xaml.cs
41 41
#endregion
42 42
using System;
43 43
using System.Collections.Generic;
44
using System.Configuration;
45
using System.Data;
46
using System.Diagnostics;
44
using System.IO;
47 45
using System.Linq;
48
using System.Net;
49
using System.Net.Mail;
50 46
using System.Reflection;
51 47
using System.Text;
52 48
using System.Threading;
53 49
using System.Threading.Tasks;
54 50
using System.Windows;
55 51
using Caliburn.Micro;
56
using Microsoft.Win32;
57
using Caliburn.Micro.Logging;
58 52
using Pithos.Client.WPF.Properties;
53
using log4net.Appender;
54
using log4net.Repository.Hierarchy;
59 55

  
60 56

  
61 57
namespace Pithos.Client.WPF
......
65 61
    /// </summary>
66 62
    public partial class App : Application
67 63
    {
68
        private readonly log4net.ILog _log = log4net.LogManager.GetLogger(typeof (App));
64
        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger( MethodBase.GetCurrentMethod().DeclaringType );
69 65

  
70 66
        public App()
71 67
        {
72
            log4net.Config.XmlConfigurator.Configure();            
73
            
74
            this.DispatcherUnhandledException += OnUnhandledException;
68
            InitializeLogging();
69

  
70

  
71
            DispatcherUnhandledException += OnDispatcherUnhandledException;
75 72
            AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
76 73
            TaskScheduler.UnobservedTaskException += OnUnobservedException;
77 74

  
......
85 82
            InitializeComponent();            
86 83
        }
87 84

  
85
        private static void InitializeLogging()
86
        {
87
            log4net.Config.XmlConfigurator.Configure();
88

  
89
            try
90
            {
91
                var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
92
                var pithosDataPath= Path.Combine(appDataPath , "GRNET");
93
                if (!Directory.Exists(pithosDataPath))
94
                    Directory.CreateDirectory(pithosDataPath);
95

  
96
                var loggerRepository = (Hierarchy)log4net.LogManager.GetRepository();
97
                
98
                var appenders = loggerRepository.GetAppenders();
99
                var lossyAppender = appenders.OfType<BufferingForwardingAppender>()
100
                    .First(appender => appender.Name == "LossyFileAppender");
101
                var dumpAppender = lossyAppender.Appenders.OfType<RollingFileAppender>().First();                
102
                dumpAppender.File = Path.Combine(pithosDataPath, "errorlog.txt");
103
                dumpAppender.ActivateOptions();
104
            }
105
            catch (Exception exc)
106
            {
107
                Log.Error("Dumpl appender initialization failed",exc);                
108
            }
109
        }
110

  
88 111
        protected override void OnStartup(StartupEventArgs e)
89 112
        {
90 113
            if (!Settings.Default.StartOnSystemStartup && e.Args.Contains("startup"))
91 114
            {
92
                this.Shutdown();
115
                Shutdown();
93 116
                return;
94 117
            }
95
            
96
            //TODO: Possibly add a delay here?
118

  
119
            //Delay during startup
97 120
            if (e.Args.Contains("startup"))
98 121
            {
99 122
                if (Settings.Default.StartupDelay>TimeSpan.Zero)
......
119 142
                return true;
120 143
            });
121 144

  
122
            ShowMessages("Oops!","Where did that come from? \r\nErm, an exception occured.\r\nWe apologize for the inconvenience", messages);
145
            Log.Error("Unobserved Task Exception",e.Exception);
146
            
147
            var message = String.Format(@"{0}\r\n{1}\r\n\r\n{2}", 
148
                WPF.Properties.Resources.Unexpected_Error,
149
                WPF.Properties.Resources.We_Apologize, 
150
                WPF.Properties.Resources.Please_Submit_Error);
151
            ShowMessages("Oops!",message, messages);
123 152
            e.SetObserved();
124 153
        }
125 154

  
126 155
        private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
127 156
        {
128
            var message = e.IsTerminating
129
                              ? "Unexpected Exception. The application must terminate"
130
                              : "Unexpected Exception";
157
            Log.Error("Unhandled exception", (Exception)e.ExceptionObject);
158

  
159
            var description = e.IsTerminating
160
                              ? WPF.Properties.Resources.Unexpected_Error_Terminating
161
                              : WPF.Properties.Resources.Unexpected_Error;
162
            var message = String.Format(@"{0}\r\n{1}\r\n\r\n{2}",
163
                description,
164
                WPF.Properties.Resources.We_Apologize,
165
                WPF.Properties.Resources.Please_Submit_Error);
131 166

  
132 167

  
168
            var exc = ((Exception) e.ExceptionObject);
133 169
            var messages = new[]{
134 170
                                   new UserMessage
135 171
                                       {
136
                                           Message = (e.ExceptionObject as Exception).Message,
137
                                           Details = e.ExceptionObject.ToString(),
172
                                           Message = exc.Message,
173
                                           Details = exc.ToString(),
138 174
                                           Severity = Severity.Error
139 175
                                       }
140 176
                               };
177

  
178

  
141 179
            ShowMessages("Oops!", message,messages);
142 180
        }
143 181

  
144
        void OnUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
145
        {                        
182
        void OnDispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
183
        {
184
            Log.Error("Unhandled Dispatcher exception", e.Exception);
185
            
146 186
            var messages = new[]{
147 187
                                   new UserMessage
148 188
                                       {
......
151 191
                                           Severity = Severity.Error
152 192
                                       }
153 193
                               };
154
            ShowMessages("Oops!", "Unexcpected Exception", messages);
194
            ShowMessages(WPF.Properties.Resources.Error_Title, 
195
                WPF.Properties.Resources.Unexpected_Error,
196
                messages);
155 197
            e.Handled=true;
156 198
        }
157 199

  
158 200
        void ShowMessages(string title,string message,IEnumerable<UserMessage> messages )
159 201
        {
160
            LogMessages(messages);
202
            var messageList = messages.ToList();
203
            LogMessages(messageList);
161 204
            Execute.OnUIThread(()=>{
162
                var messageView = new MessageView(messages);
163
                messageView.Title = title;
164
                messageView.Message = message;
165
                messageView.ShowDialog();
205
                                       var messageView = new MessageView(messageList)
206
                                                        {
207
                                                            Title = title, 
208
                                                            Message = message
209
                                                        };
210
                                       messageView.ShowDialog();
166 211
            });
167 212
        }
168 213

  
......
170 215
        {
171 216
            var logMessage = CreateMessage(messages);
172 217

  
173
            _log.Error(logMessage);
218
            Log.Error(logMessage);
174 219
        }
175 220

  
176 221
        private static string CreateMessage(IEnumerable<UserMessage> messages)

Also available in: Unified diff