private static Exception createWebServiceException(Exception e)
{
if (!(e is Wcf.AccessDeniedException))
{
TelemetryStatics.ReportError(e);
}
return(new FaultException(e.ToString()));
}
/// <summary>
/// Executes the specified method. Returns true if it is successful. If an exception occurs, this method returns false and details about the exception are emailed
/// to the developers and logged. This should not be necessary in web applications, as they have their own error handling.
/// Prior to calling this, you should be sure that system logic initialization has succeeded. This almost always means that ExecuteAppWithStandardExceptionHandling
/// has been called somewhere up the stack.
/// This method has no side effects other than those of the given method and the email/logging that occurs in the event of an error. This can be used
/// repeatedly inside any application as an alternative to a try catch block.
/// </summary>
public static bool ExecuteBlockWithStandardExceptionHandling(Action method)
{
assertClassInitialized();
try {
method();
return(true);
}
catch (Exception e) {
TelemetryStatics.ReportError(e);
return(false);
}
}
/// <summary>
/// Performs cleanup activities so the application can be shut down.
/// </summary>
public static void CleanUp()
{
assertClassInitialized();
try {
globalInitializer.CleanUpStatics();
AppMemoryCache.CleanUp();
}
catch (Exception e) {
TelemetryStatics.ReportError("An exception occurred during application cleanup:", e);
}
}
/// <summary>
/// Executes the specified method. Returns 0 if it is successful. If an exception occurs, this method returns 1 and details about the exception are emailed
/// to the developers and logged. This should only be used at the root level of a console application because it checks to ensure the system logic has
/// initialized properly and its return code is designed to be useful from the command line of such an application. Throw a DoNotEmailOrLogException to
/// cause this method to return 1 without emailing or logging the exception.
/// </summary>
public static int ExecuteAppWithStandardExceptionHandling(Action method)
{
assertClassInitialized();
if (secondaryInitFailed)
{
return(1);
}
try {
method();
}
catch (Exception e) {
if (!(e is DoNotEmailOrLogException))
{
TelemetryStatics.ReportError(e);
}
return(1);
}
return(0);
}
/// <summary>
/// Initializes the class. This includes loading application settings from the configuration file. The application name should be scoped within the system.
/// For non web applications, this method must be called directly from the main executable assembly and not from a supporting library.
///
/// To debug this method, create a folder called C:\AnyoneFullControl and give Everyone full control. A file will appear in that folder explaining how far
/// it got in init.
/// </summary>
/// <param name="globalInitializer">The system's global initializer. Do not pass null.</param>
/// <param name="appName"></param>
/// <param name="isClientSideProgram"></param>
/// <param name="useRelativeInstallationPath">Pass true to use a relative path for the installation folder. This means that the folder will be located using
/// the working directory rather than the assembly path. Use with caution.</param>
/// <param name="mainDataAccessStateGetter">A method that returns the current main data-access state whenever it is requested, including during this
/// AppTools.Init call. Do not allow multiple threads to use the same state at the same time. If you pass null, the data-access subsystem will not be
/// available in the application.</param>
public static void Init(
SystemInitializer globalInitializer, string appName, bool isClientSideProgram, bool useRelativeInstallationPath = false,
Func <DataAccessState> mainDataAccessStateGetter = null)
{
var initializationLog = "Starting init";
try {
if (initialized)
{
throw new ApplicationException("This class can only be initialized once.");
}
if (globalInitializer == null)
{
throw new ApplicationException("The system must have a global initializer and you must pass an instance of it to AppTools.Init.");
}
// Initialize ConfigurationStatics, including the general provider, before the exception handling block below because it's reasonable for the exception
// handling to depend on this.
ConfigurationStatics.Init(useRelativeInstallationPath, globalInitializer.GetType(), appName, isClientSideProgram, ref initializationLog);
// Setting the initialized flag to true must be done before executing the secondary init block below so that exception handling works.
initialized = true;
initializationLog += Environment.NewLine + "Succeeded in primary init.";
}
catch (Exception e) {
initializationLog += Environment.NewLine + e;
StandardLibraryMethods.EmergencyLog("Initialization log", initializationLog);
throw;
}
try {
var asposeLicense = ConfigurationStatics.SystemGeneralProvider.AsposeLicenseName;
if (asposeLicense.Any())
{
new Aspose.Pdf.License().SetLicense(asposeLicense);
new Aspose.Words.License().SetLicense(asposeLicense);
}
// This initialization could be performed using reflection. There is no need for AppTools to have a dependency on these classes.
AppMemoryCache.Init();
BlobFileOps.Init();
DataAccessStatics.Init();
DataAccessState.Init(mainDataAccessStateGetter);
EncryptionOps.Init();
HtmlBlockStatics.Init();
InstallationSupportUtility.ConfigurationLogic.Init1();
UserManagementStatics.Init();
AppTools.globalInitializer = globalInitializer;
globalInitializer.InitStatics();
}
catch (Exception e) {
secondaryInitFailed = true;
// Suppress all exceptions since they would prevent apps from knowing that primary initialization succeeded. EWF apps need to know this in order to
// automatically restart themselves. Other apps could find this knowledge useful as well.
try {
TelemetryStatics.ReportError("An exception occurred during application initialization:", e);
}
catch {}
}
}
public static void EmailAndLogError(string prefix, Exception exception)
{
TelemetryStatics.ReportError(prefix, exception);
}
public static void EmailAndLogError(Exception e)
{
TelemetryStatics.ReportError(e);
}
