Fixed License [skip ci]

This commit is contained in:
Robin 2016-03-25 12:11:05 +01:00
commit deb054b6fb

View file

@ -1,26 +1,25 @@
/*
Dapplo - building blocks for desktop applications
Copyright (C) 2015-2016 Dapplo
For more information see: http://dapplo.net/
Dapplo repositories are hosted on GitHub: https://github.com/dapplo
This file is part of Dapplo.Addons
Dapplo.Addons is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Dapplo.Addons is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Dapplo.Addons. If not, see <http://www.gnu.org/licenses/>.
*/
// Dapplo - building blocks for desktop applications
// Copyright (C) 2015-2016 Dapplo
//
// For more information see: http://dapplo.net/
// Dapplo repositories are hosted on GitHub: https://github.com/dapplo
//
// This file is part of Dapplo.Addons
//
// Dapplo.Addons is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Dapplo.Addons is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have Config a copy of the GNU Lesser General Public License
// along with Dapplo.Addons. If not, see <http://www.gnu.org/licenses/lgpl.txt>.
#region using
using log4net;
using System;
@ -28,31 +27,24 @@ using System.Security.AccessControl;
using System.Security.Principal;
using System.Threading;
#endregion
namespace Greenshot.Helpers
{
/// <summary>
/// This comes from Dapplo.Addons, which was created for Greenshot, this file is copied here as this is the only part we use in 1.2.8
/// This protects your resources or application from running more than once
/// Simplifies the usage of the Mutex class, as described here: https://msdn.microsoft.com/en-us/library/System.Threading.Mutex.aspx
/// This protects your resources or application from running more than once
/// Simplifies the usage of the Mutex class, as described here:
/// https://msdn.microsoft.com/en-us/library/System.Threading.Mutex.aspx
/// </summary>
public class ResourceMutex : IDisposable
{
private static ILog LOG = LogManager.GetLogger(typeof(DestinationHelper));
private static readonly ILog Log = LogManager.GetLogger(typeof(DestinationHelper));
private readonly string _mutexId;
private readonly string _resourceName;
private Mutex _applicationMutex;
/// <summary>
/// Test if the Mutex was created and locked.
/// </summary>
public bool IsLocked
{
get;
set;
}
/// <summary>
/// Private constructor
/// Private constructor
/// </summary>
/// <param name="mutexId"></param>
/// <param name="resourceName"></param>
@ -63,7 +55,12 @@ namespace Greenshot.Helpers
}
/// <summary>
/// Create a ResourceMutex for the specified mutex id and resource-name
/// Test if the Mutex was created and locked.
/// </summary>
public bool IsLocked { get; set; }
/// <summary>
/// Create a ResourceMutex for the specified mutex id and resource-name
/// </summary>
/// <param name="mutexId">ID of the mutex, preferably a Guid as string</param>
/// <param name="resourceName">Name of the resource to lock, e.g your application name, usefull for logs</param>
@ -76,12 +73,12 @@ namespace Greenshot.Helpers
}
/// <summary>
/// This tries to get the Mutex, which takes care of having multiple instances running
/// This tries to get the Mutex, which takes care of having multiple instances running
/// </summary>
/// <returns>true if it worked, false if another instance is already running or something went wrong</returns>
public bool Lock()
{
LOG.DebugFormat("{0} is trying to get Mutex {1}", _resourceName, _mutexId);
Log.DebugFormat("{0} is trying to get Mutex {1}", _resourceName, _mutexId);
IsLocked = true;
// check whether there's an local instance running already, but use local so this works in a multi-user environment
@ -100,7 +97,7 @@ namespace Greenshot.Helpers
// 2) if the mutex wasn't created new get the right to it, this returns false if it's already locked
if (!createdNew && !_applicationMutex.WaitOne(100, false))
{
LOG.InfoFormat("{0} is already in use, mutex {1} is NOT locked for the caller", _resourceName, _mutexId);
Log.InfoFormat("{0} is already in use, mutex {1} is NOT locked for the caller", _resourceName, _mutexId);
IsLocked = false;
// Clean up
_applicationMutex.Close();
@ -108,45 +105,38 @@ namespace Greenshot.Helpers
}
else
{
if (createdNew)
{
LOG.InfoFormat("{0} has created & claimed the mutex {1}", _resourceName, _mutexId);
}
else
{
LOG.InfoFormat("{0} has claimed the mutex {1}", _resourceName, _mutexId);
}
Log.InfoFormat(createdNew ? "{0} has created & claimed the mutex {1}" : "{0} has claimed the mutex {1}", _resourceName, _mutexId);
}
}
catch (AbandonedMutexException e)
{
// Another instance didn't cleanup correctly!
// we can ignore the exception, it happend on the "waitone" but still the mutex belongs to us
LOG.WarnFormat("{0} didn't cleanup correctly, but we got the mutex {1}.", _resourceName, _mutexId);
LOG.Warn(e);
Log.WarnFormat("{0} didn't cleanup correctly, but we got the mutex {1}.", _resourceName, _mutexId);
Log.Warn(e);
}
catch (UnauthorizedAccessException e)
{
LOG.ErrorFormat("{0} is most likely already running for a different user in the same session, can't create/get mutex {1} due to error.", _resourceName, _mutexId);
LOG.Error(e);
Log.ErrorFormat("{0} is most likely already running for a different user in the same session, can't create/get mutex {1} due to error.", _resourceName, _mutexId);
Log.Error(e);
IsLocked = false;
}
catch (Exception ex)
{
LOG.ErrorFormat("Problem obtaining the Mutex {1} for {0}, assuming it was already taken!", _resourceName, _mutexId);
LOG.Error(ex);
Log.ErrorFormat("Problem obtaining the Mutex {1} for {0}, assuming it was already taken!", _resourceName, _mutexId);
Log.Error(ex);
IsLocked = false;
}
return IsLocked;
}
#region IDisposable Support
// To detect redundant Dispose calls
private bool _disposedValue = false;
private bool _disposedValue;
/// <summary>
/// The real disposing code
/// The real disposing code
/// </summary>
/// <param name="disposing">true if dispose is called, false when the finalizer is called</param>
protected virtual void Dispose(bool disposing)
@ -159,21 +149,20 @@ namespace Greenshot.Helpers
{
_applicationMutex.ReleaseMutex();
_applicationMutex = null;
LOG.InfoFormat("Released Mutex {0} for {1}", _mutexId, _resourceName);
Log.InfoFormat("Released Mutex {0} for {1}", _mutexId, _resourceName);
}
catch (Exception ex)
{
LOG.ErrorFormat("Error releasing Mutex {0} for {1}", _mutexId, _resourceName);
LOG.Error(ex);
Log.ErrorFormat("Error releasing Mutex {0} for {1}", _mutexId, _resourceName);
Log.Error(ex);
}
}
_disposedValue = true;
}
}
/// <summary>
/// Make sure the ApplicationMutex is disposed when the finalizer is called
/// Make sure the ApplicationMutex is disposed when the finalizer is called
/// </summary>
~ResourceMutex()
{
@ -182,7 +171,7 @@ namespace Greenshot.Helpers
}
/// <summary>
/// The dispose interface, which calls Dispose(true) to signal that dispose is called.
/// The dispose interface, which calls Dispose(true) to signal that dispose is called.
/// </summary>
public void Dispose()
{
@ -190,6 +179,7 @@ namespace Greenshot.Helpers
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
}
}
}