Statistics
| Branch: | Revision:

root / trunk / Pithos.Client.WPF / App.xaml.cs @ e394ef0f

History | View | Annotate | Download (11 kB)

1
#region
2
/* -----------------------------------------------------------------------
3
 * <copyright file="App.xaml.cs" company="GRNet">
4
 * 
5
 * Copyright 2011-2012 GRNET S.A. All rights reserved.
6
 *
7
 * Redistribution and use in source and binary forms, with or
8
 * without modification, are permitted provided that the following
9
 * conditions are met:
10
 *
11
 *   1. Redistributions of source code must retain the above
12
 *      copyright notice, this list of conditions and the following
13
 *      disclaimer.
14
 *
15
 *   2. Redistributions in binary form must reproduce the above
16
 *      copyright notice, this list of conditions and the following
17
 *      disclaimer in the documentation and/or other materials
18
 *      provided with the distribution.
19
 *
20
 *
21
 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
22
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
25
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32
 * POSSIBILITY OF SUCH DAMAGE.
33
 *
34
 * The views and conclusions contained in the software and
35
 * documentation are those of the authors and should not be
36
 * interpreted as representing official policies, either expressed
37
 * or implied, of GRNET S.A.
38
 * </copyright>
39
 * -----------------------------------------------------------------------
40
 */
41
#endregion
42
using System;
43
using System.Collections.Generic;
44
using System.IO;
45
using System.Linq;
46
using System.Net;
47
using System.Reflection;
48
using System.Text;
49
using System.Threading;
50
using System.Threading.Tasks;
51
using System.Windows;
52
using Caliburn.Micro;
53
using Pithos.Client.WPF.Configuration;
54
using Pithos.Client.WPF.Properties;
55
using log4net.Appender;
56
using log4net.Core;
57
using log4net.Repository.Hierarchy;
58

    
59

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

    
70
        public App()
71
        {
72

    
73
            //var instanceMutex=new Mutex()
74

    
75
            InitializeLogging();
76

    
77

    
78
            DispatcherUnhandledException += OnDispatcherUnhandledException;
79
            AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
80
            TaskScheduler.UnobservedTaskException += OnUnobservedException;
81

    
82

    
83
            //Fix incorrect proxy settings by switching to default proxy, if the proxy server settings is empty
84
            if (Settings.Default.UseManualProxy && String.IsNullOrWhiteSpace(Settings.Default.ProxyServer))
85
            {
86
                Settings.Default.UseManualProxy = false;
87
                Settings.Default.UseDefaultProxy = true;
88
            }
89

    
90
            if (Settings.Default.IgnoreCertificateErrors)
91
                ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
92

    
93

    
94
            InitializeComponent();            
95
        }       
96

    
97

    
98
/*
99
        private void OnUpdateDetected(object sender, UpdateDetectedEventArgs e)
100
        {
101
            Log.InfoFormat("Update Detected {0}",e.LatestVersion.Version);    
102
        }
103
*/
104

    
105
        private static void InitializeLogging()
106
        {
107
            log4net.Config.XmlConfigurator.Configure();
108

    
109
            try
110
            {
111
                var pithosDataPath = PithosSettings.PithosDataPath;
112
                if (!Directory.Exists(pithosDataPath))
113
                    Directory.CreateDirectory(pithosDataPath);
114

    
115
                var loggerRepository = (Hierarchy)log4net.LogManager.GetRepository();
116

    
117
                var appenders = loggerRepository.GetAppenders();
118
                
119

    
120
                var lossyAppender = appenders.OfType<BufferingForwardingAppender>()
121
                    .FirstOrDefault(appender => appender.Name == "LossyFileAppender");
122
                if (lossyAppender!=null)
123
                {
124
                    var dumpAppender = lossyAppender.Appenders.OfType<RollingFileAppender>().First();
125
                    dumpAppender.File = Path.Combine(pithosDataPath, "errorlog.xml");
126
                    dumpAppender.ActivateOptions();
127
                }
128
                
129
                var debugAppender =appenders.OfType<RollingFileAppender>()
130
                    .FirstOrDefault(a => a.Name == "DebugFileAppender");
131
                if (debugAppender != null)
132
                {
133
                    debugAppender.File = Path.Combine(pithosDataPath, "debuglog.xml");
134
                    if (!Settings.Default.DebugLoggingEnabled)
135
                        debugAppender.Threshold = Level.Off;
136
                    debugAppender.ActivateOptions();
137
                }
138
            }
139
            catch (Exception exc)
140
            {
141
                Log.Error("Dumpl appender initialization failed",exc);                
142
            }
143
        }
144

    
145
        private Mutex _singleInstanceMutex;
146

    
147
        protected override void OnStartup(StartupEventArgs e)
148
        {
149
            if (!Settings.Default.StartOnSystemStartup && e.Args.Contains("startup"))
150
            {
151
                Shutdown();
152
                return;
153
            }
154

    
155
            bool firstInstance;
156
            _singleInstanceMutex = new Mutex(false, "PITHOSMUTEX", out firstInstance);
157
            if (!firstInstance)
158
            {
159
                _singleInstanceMutex.Dispose();
160
                _singleInstanceMutex = null;
161
                Shutdown();
162
                return;
163
            }
164

    
165
            //Delay during startup
166
            if (e.Args.Contains("startup"))
167
            {
168
                if (Settings.Default.StartupDelay>TimeSpan.Zero)
169
                    Thread.Sleep(Settings.Default.StartupDelay);
170
            }
171

    
172
            var splashScreen = new SplashScreen("images/pithos_logo-title-margin-splash-600-whitebg.png");
173
            splashScreen.Show(true);
174
            
175
            base.OnStartup(e);
176
        }
177

    
178
        protected override void OnExit(ExitEventArgs e)
179
        {
180
            try
181
            {
182
                if (_singleInstanceMutex!=null)
183
                    _singleInstanceMutex.Dispose();
184
                _singleInstanceMutex = null;
185
            }
186
            catch { }
187
            base.OnExit(e);
188
        }
189

    
190
        private void OnUnobservedException(object sender, UnobservedTaskExceptionEventArgs e)
191
        {
192
            Log.Error("Unobserved Task Exception", e.Exception); 
193
            
194
            var messages = new List<UserMessage>();
195
            e.Exception.Handle(exc=>{
196
                messages.Add(new UserMessage
197
                {
198
                    Message = "Unexpected Exception",
199
                    Details = exc.ToString(),
200
                    Severity = Severity.Error
201
                });
202
                return true;
203
            });
204

    
205

    
206
            var message = String.Format(@"{0}<LineBreak/>{1}<LineBreak/><LineBreak/>{2}", 
207
                WPF.Properties.Resources.Unexpected_Error,
208
                WPF.Properties.Resources.We_Apologize, 
209
                WPF.Properties.Resources.Please_Submit_Error);
210
            ShowMessages("Oops!",message, messages);
211
            e.SetObserved();
212
        }
213

    
214
        private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
215
        {
216
            Log.Error("Unhandled exception", (Exception)e.ExceptionObject);
217

    
218
            var description = e.IsTerminating
219
                              ? WPF.Properties.Resources.Unexpected_Error_Terminating
220
                              : WPF.Properties.Resources.Unexpected_Error;
221
            var message = String.Format(@"{0}<LineBreak/>{1}<LineBreak/><LineBreak/>{2}",
222
                description,
223
                WPF.Properties.Resources.We_Apologize,
224
                WPF.Properties.Resources.Please_Submit_Error);
225

    
226

    
227
            var exc = ((Exception) e.ExceptionObject);
228
            var messages = new[]{
229
                                   new UserMessage
230
                                       {
231
                                           Message = exc.Message,
232
                                           Details = exc.ToString(),
233
                                           Severity = Severity.Error
234
                                       }
235
                               };
236

    
237

    
238
            ShowMessages("Oops!", message,messages);
239
        }
240

    
241
        void OnDispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
242
        {
243
            Log.Error("Unhandled Dispatcher exception", e.Exception);
244
            
245
            var messages = new[]{
246
                                   new UserMessage
247
                                       {
248
                                           Message = e.Exception.Message, 
249
                                           Details = e.Exception.ToString(),
250
                                           Severity = Severity.Error
251
                                       }
252
                               };
253
            ShowMessages(WPF.Properties.Resources.Error_Title, 
254
                WPF.Properties.Resources.Unexpected_Error,
255
                messages);
256
            e.Handled=true;
257
        }
258

    
259
        void ShowMessages(string title,string message,IEnumerable<UserMessage> messages )
260
        {
261
            var messageList = messages.ToList();
262
            LogMessages(messageList);
263
            Execute.OnUIThread(()=>{
264
                                       var messageView = new MessageView(messageList)
265
                                                        {
266
                                                            Title = title, 
267
                                                            Message = message
268
                                                        };
269
                                       messageView.ShowDialog();
270
            });
271
        }
272

    
273
        private void LogMessages(IEnumerable<UserMessage> messages)
274
        {
275
            var logMessage = CreateMessage(messages);
276

    
277
            Log.Error(logMessage);
278
        }
279

    
280
        private static string CreateMessage(IEnumerable<UserMessage> messages)
281
        {
282
            var messageBuilder = messages.Aggregate(new StringBuilder("Unexpected Error\r\n"),
283
                                                    (builder, message) =>
284
                                                        {
285
                                                            builder.AppendFormat("\r\n[{0}] {1}\r\n{2}\r\n", message.Severity,
286
                                                                                 message.Message, message.Details);
287
                                                            return builder;
288
                                                        });
289
            var logMessage = messageBuilder.ToString();
290
            return logMessage;
291
        }
292
    }
293

    
294
}