blob: ac574cda73c971623544629f54df43379288b1e1 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections.Generic;
using Apache.NMS.ActiveMQ.Commands;
using Apache.NMS.ActiveMQ.Util;
using Apache.NMS.Util;
namespace Apache.NMS.ActiveMQ.Transactions
{
public class RecoveryLoggerHarness : IRecoveryLogger
{
public delegate void HarnessedEventHandler();
public delegate void HarnessedLogRecoveryInfoHandler(XATransactionId xid, byte[] recoveryInfo);
public delegate void HarnessedLogRecoveredHandler(XATransactionId xid);
public delegate void HarnessedGetRecoverablesHandler(KeyValuePair<XATransactionId, byte[]>[] recoverables);
private static readonly FactoryFinder<RecoveryLoggerFactoryAttribute, IRecoveryLoggerFactory> FACTORY_FINDER =
new FactoryFinder<RecoveryLoggerFactoryAttribute, IRecoveryLoggerFactory>();
private IRecoveryLogger containedLogger;
public event HarnessedEventHandler PreInitializeEvent;
public event HarnessedEventHandler PostInitializeEvent;
public event HarnessedLogRecoveryInfoHandler PreLogRecoveryInfoEvent;
public event HarnessedLogRecoveryInfoHandler PostLogRecoveryInfoEvent;
public event HarnessedLogRecoveredHandler PreLogRecoverdEvent;
public event HarnessedLogRecoveredHandler PostLogRecoverdEvent;
public event HarnessedGetRecoverablesHandler PreGetRecoverablesEvent;
public event HarnessedGetRecoverablesHandler PostGetRecoverablesEvent;
public event HarnessedEventHandler PrePurgeEvent;
public event HarnessedEventHandler PostPurgeEvent;
public RecoveryLoggerHarness()
{
this.containedLogger = new RecoveryFileLogger();
}
public string ResourceManagerId
{
get { return this.containedLogger.ResourceManagerId; }
}
public void Initialize(string resourceManagerId)
{
if(this.PreInitializeEvent != null)
{
this.PreInitializeEvent();
}
this.containedLogger.Initialize(resourceManagerId);
if (this.PostInitializeEvent != null)
{
this.PostInitializeEvent();
}
}
public void LogRecoveryInfo(XATransactionId xid, byte[] recoveryInformation)
{
if (recoveryInformation == null || recoveryInformation.Length == 0)
{
return;
}
if (this.PreLogRecoveryInfoEvent != null)
{
this.PreLogRecoveryInfoEvent(xid, recoveryInformation);
}
this.containedLogger.LogRecoveryInfo(xid, recoveryInformation);
if (this.PostLogRecoveryInfoEvent != null)
{
this.PostLogRecoveryInfoEvent(xid, recoveryInformation);
}
}
public KeyValuePair<XATransactionId, byte[]>[] GetRecoverables()
{
KeyValuePair<XATransactionId, byte[]>[] result = new KeyValuePair<XATransactionId, byte[]>[0];
if (this.PreGetRecoverablesEvent != null)
{
this.PreGetRecoverablesEvent(result);
}
result = this.containedLogger.GetRecoverables();
if (this.PostGetRecoverablesEvent != null)
{
this.PostGetRecoverablesEvent(result);
}
return result;
}
public void LogRecovered(XATransactionId xid)
{
if (this.PreLogRecoverdEvent != null)
{
this.PreLogRecoverdEvent(xid);
}
this.containedLogger.LogRecovered(xid);
if (this.PostLogRecoverdEvent != null)
{
this.PostLogRecoverdEvent(xid);
}
}
public void Purge()
{
if (this.PrePurgeEvent != null)
{
this.PrePurgeEvent();
}
this.containedLogger.Purge();
if (this.PostPurgeEvent != null)
{
this.PostPurgeEvent();
}
}
public string LoggerType
{
get { return this.containedLogger.LoggerType; }
}
#region Harness Methods
public IRecoveryLogger Harnessed
{
get { return this.containedLogger; }
}
public string HarnessedType
{
get { return this.containedLogger != null ? this.containedLogger.LoggerType : ""; }
set
{
if (string.IsNullOrEmpty(value))
{
throw new NMSException(String.Format("Recovery Logger name invalid: [{0}]", value));
}
IRecoveryLoggerFactory factory = null;
try
{
factory = NewInstance(value.ToLower());
}
catch (NMSException)
{
throw;
}
catch (Exception e)
{
throw NMSExceptionSupport.Create("Error creating Recovery Logger", e);
}
this.containedLogger = factory.Create();
}
}
private static IRecoveryLoggerFactory NewInstance(string scheme)
{
try
{
Type factoryType = FindLoggerFactory(scheme);
if (factoryType == null)
{
throw new Exception("NewInstance failed to find a match for id = " + scheme);
}
return (IRecoveryLoggerFactory)Activator.CreateInstance(factoryType);
}
catch (Exception ex)
{
Tracer.WarnFormat("NewInstance failed to create an IRecoveryLoggerFactory with error: {1}", ex.Message);
throw;
}
}
private static Type FindLoggerFactory(string scheme)
{
try
{
return FACTORY_FINDER.FindFactoryType(scheme);
}
catch
{
throw new NMSException("Failed to find Factory for Recovery Logger type: " + scheme);
}
}
public Object Clone()
{
return this.MemberwiseClone();
}
#endregion
}
}