private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
if (!transaction.DistributedTransaction)
{
transaction.Enlist(new RhinoTransactionResourceAdapter(transactionMode));
}
}
public StandardTransaction(TransactionDelegate onTransactionCommitted, TransactionDelegate onTransactionRolledback,
TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) :
this(transactionMode, isolationMode, distributedTransaction)
{
this.onTransactionCommitted = onTransactionCommitted;
this.onTransactionRolledback = onTransactionRolledback;
}
protected TransactionBase(string name, TransactionMode mode, IsolationMode isolationMode)
{
theName = name ?? string.Empty;
_TransactionMode = mode;
_IsolationMode = isolationMode;
Status = TransactionStatus.NoTransaction;
Context = new Hashtable();
}
public IsolatedApplication (IsolationMode mode)
{
if (mode == IsolationMode.None)
throw new ArgumentException ("mode");
channelId = RegisterRemotingChannel (mode);
backendController = new ApplicationBackendController (this, channelId);
backendController.StartBackend ();
OnBackendChanged (false);
}
public ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode,
bool distributedTransaction)
{
_current = new MockTransaction();
_transactions++;
return _current;
}
/// <summary>
/// Insert a rule into the rule cache. This method also
/// compiles the rule within the cache to improve performance.
/// </summary>
/// <param name="rule">
/// The rule to insert. This parameter must not be null.
/// </param>
/// <param name="runtimeMode">
/// Set to IsolationMode.Private to force the rule engine to
/// create a separate ScriptRuntime for the rule. Set to
/// IsolationMode.Shared to allow the rule to run in a shared
/// ScriptRuntime managed by the rule engine.
/// </param>
/// <returns>
/// The unique cache handle of the rule within this scope of
/// this rule engine.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown when the specified rule is null.
/// </exception>
public int InsertRule(IRule rule,
IsolationMode runtimeMode)
{
lock (_rulesContexts)
{
int handle = -1;
UpsertRule(rule, ref handle,
runtimeMode);
return(handle);
}
}
public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode iMode, bool isAmbient)
{
txMode = ObtainDefaultTransactionMode(txMode);
AssertModeSupported(txMode);
if (CurrentTransaction == null &&
(txMode == TransactionMode.Supported ||
txMode == TransactionMode.NotSupported))
{
return(null);
}
TransactionBase transaction = null;
if (CurrentTransaction != null)
{
if (txMode == TransactionMode.Requires || txMode == TransactionMode.Supported)
{
transaction = ((TransactionBase)CurrentTransaction).CreateChildTransaction();
_Logger.DebugFormat("Child transaction \"{0}\" created", transaction.Name);
}
}
if (transaction == null)
{
transaction = InstantiateTransaction(txMode, iMode, isAmbient);
if (isAmbient)
{
#if MONO
throw new NotSupportedException("Distributed transactions are not supported on Mono");
#else
transaction.Enlist(new TransactionScopeResourceAdapter(txMode, iMode));
#endif
}
_Logger.DebugFormat("Transaction \"{0}\" created", transaction.Name);
}
_ActivityManager.CurrentActivity.Push(transaction);
if (transaction.IsChildTransaction)
{
ChildTransactionCreated.Fire(this, new TransactionEventArgs(transaction));
}
else
{
TransactionCreated.Fire(this, new TransactionEventArgs(transaction));
}
return(transaction);
}
public IsolatedApplication(IsolationMode mode)
{
if (mode == IsolationMode.None)
{
throw new ArgumentException("mode");
}
channelId = RegisterRemotingChannel(mode);
backendController = new ApplicationBackendController(this, channelId);
backendController.StartBackend();
OnBackendChanged(false);
}
public static Application CreateApplication (IsolationMode mode)
{
switch (mode) {
case IsolationMode.None:
return new LocalApplication ();
case IsolationMode.ProcessTcp:
case IsolationMode.ProcessUnix:
return new IsolatedApplication (mode);
default:
throw new ArgumentException ("mode");
}
}
private TransactionBase InstantiateTransaction(TransactionMode mode, IsolationMode isolationMode, bool ambient, bool readOnly)
{
var t = new TalkactiveTransaction(mode, isolationMode, ambient, readOnly);
t.Logger = this.Logger.CreateChildLogger("TalkactiveTransaction");
t.TransactionCompleted += CompletedHandler;
t.TransactionRolledBack += RolledBackHandler;
t.TransactionFailed += FailedHandler;
return(t);
}
public override bool Parse()
{
var result = base.Parse();
if (result)
{
var match = Parser.Match(Message);
result = match.Success;
if (result)
{
TransactionId = long.Parse(match.Groups["TransactionId"].Value);
var isolationParams = match.Groups["IsolationParams"].Value;
var strings = isolationParams.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim())
.ToList();
int index;
IsolationMode = strings.Count >= 1 ? strings[0] : string.Empty;
if (IsolationMode.Equals("READ_COMMITTED", StringComparison.Ordinal))
{
var recordVersion = strings.Count >= 2 ? strings[1] : string.Empty;
if (recordVersion.Equals("REC_VERSION", StringComparison.Ordinal))
{
RecordVersion = true;
}
else if (recordVersion.Equals("NO_REC_VERSION", StringComparison.Ordinal))
{
RecordVersion = false;
}
index = 2;
}
else
{
index = 1;
}
var wait = strings.Count >= index + 1 ? strings[index++] : string.Empty;
Wait = wait.StartsWith("WAIT", StringComparison.Ordinal);
if (Wait)
{
var waitMatch = ParserWait.Match(wait);
if (waitMatch.Success)
{
WaitTime = TimeSpan.FromSeconds(long.Parse(waitMatch.Groups["Number"].Value));
}
}
var readWrite = strings.Count >= index + 1 ? strings[index] : string.Empty;
ReadOnly = readWrite.Equals("READ_ONLY", StringComparison.Ordinal);
RemoveFirstCharactersOfMessage(match.Groups[0].Length);
}
}
return(result);
}
private void UpsertRule(IRule rule,
ref int handle, IsolationMode runtimeMode)
{
if (rule == null)
{
throw new ArgumentNullException("rule");
}
lock (_rulesContexts)
{
CompiledCode compilation = null;
ScriptScope sharedScope = null;
ScriptRuntime runtime =
(runtimeMode == IsolationMode.Private)
? (_remoteAppDomain != null)
? ScriptRuntime.CreateRemote(
_remoteAppDomain,
_runtimeSetup)
: new ScriptRuntime(_runtimeSetup)
: _sharedRuntime;
ScriptEngine engine = runtime
.GetEngineByFileExtension(
rule.ContentType);
sharedScope = engine.CreateScope();
ScriptSource source = engine
.CreateScriptSourceFromString(
rule.Body);
compilation = source.Compile();
if (_rulesContexts.ContainsKey(handle))
{
DeleteRule(handle);
}
else
{
handle = System.Threading
.Interlocked.Increment(
ref _nextHandle);
}
_rulesContexts[handle] =
new RuleContext()
{
Rule = rule,
Code = compilation,
SharedScope = sharedScope,
IsIsolatedRuntime =
(runtimeMode == IsolationMode.Private)
};
}
}
public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode iMode, bool isAmbient, bool isReadOnly)
{
txMode = ObtainDefaultTransactionMode(txMode);
AssertModeSupported(txMode);
if (CurrentTransaction == null &&
(txMode == TransactionMode.Supported ||
txMode == TransactionMode.NotSupported))
{
return null;
}
TransactionBase transaction = null;
if (CurrentTransaction != null)
{
if (txMode == TransactionMode.Requires || txMode == TransactionMode.Supported)
{
transaction = ((TransactionBase)CurrentTransaction).CreateChildTransaction();
logger.DebugFormat("Child transaction \"{0}\" created with mode '{1}'.", transaction.Name, txMode);
}
}
if (transaction == null)
{
transaction = InstantiateTransaction(txMode, iMode, isAmbient, isReadOnly);
if (isAmbient)
{
#if MONO
throw new NotSupportedException("Distributed transactions are not supported on Mono");
#else
transaction.CreateAmbientTransaction();
#endif
}
logger.DebugFormat("Transaction \"{0}\" created. ", transaction.Name);
}
activityManager.CurrentActivity.Push(transaction);
if (transaction.IsChildTransaction)
ChildTransactionCreated.Fire(this, new TransactionEventArgs(transaction));
else
TransactionCreated.Fire(this, new TransactionEventArgs(transaction));
return transaction;
}
public AssemblyLoaderCrm(
ILog log,
byte[] assemblySource,
IOrganizationService organizationService,
IsolationMode isolationMode,
SourceType sourceType = SourceType.Database)
{
_log = log;
_assemblySource = assemblySource;
_isolationMode = isolationMode;
_sourceType = sourceType;
_organizationService = organizationService;
_ctx = new XrmServiceContext(_organizationService);
}
public AssemblyLoaderCrm(
ILog log,
string dllPath,
IOrganizationService organizationService,
IsolationMode isolationMode,
SourceType sourceType = SourceType.Database)
{
_log = log;
_assemblySource = File.ReadAllBytes(dllPath);
_isolationMode = isolationMode;
_sourceType = sourceType;
_organizationService = organizationService;
_ctx = new XrmServiceContext(_organizationService);
// XrmServiceContext ctx = new XrmServiceContext(null);
}
public static IDisposable StartIsolation(
IsolationMode isolationMode,
string isolationCommand,
string isolationArguments)
{
switch (isolationMode)
{
case IsolationMode.None: return(new NoopIsolation());
case IsolationMode.Process: return(new ProcessIsolation(isolationCommand, isolationArguments));
default:
throw new InvalidOperationException($"Isolation mode {isolationMode} is not supported.");
}
}
public void StoreIsolationModeByWeight()
{
if (staticSubtractionData.active && staticSubtractionData.calibrated)
{
isolationMode = IsolationMode.StaticSubtraction;
}
else if (chromakeying.active && chromakeying.calibrated)
{
isolationMode = IsolationMode.Chromakey;
}
else
{
isolationMode = IsolationMode.None;
}
}
public static Application CreateApplication(IsolationMode mode)
{
switch (mode)
{
case IsolationMode.None:
return(new LocalApplication());
case IsolationMode.ProcessTcp:
case IsolationMode.ProcessUnix:
return(new IsolatedApplication(mode));
default:
throw new ArgumentException("mode");
}
}
public AbstractTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction,
string name) : this()
{
this.transactionMode = transactionMode;
this.isolationMode = isolationMode;
this.distributedTransaction = distributedTransaction;
if (String.IsNullOrEmpty(name))
{
this.name = ObtainName();
}
else
{
this.name = name;
}
}
/// <summary>
/// Update an existing rule in the rule cache by handle. This
/// method also compiles the rule within the cache to improve
/// performance.
/// </summary>
/// <param name="handle">
/// The handle of the existing rule to update.
/// </param>
/// <param name="rule">
/// The rule to update. This parameter must not be null.
/// </param>
/// <param name="runtimeMode">
/// Set to IsolationMode.Private to force the rule engine to
/// create a separate ScriptRuntime for the rule. Set to
/// IsolationMode.Shared to allow the rule to run in a shared
/// ScriptRuntime managed by the rule engine.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the specified rule is null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown when the specified handle cannot be found in the rule cache.
/// </exception>
public void UpdateRule(int handle, IRule rule,
IsolationMode runtimeMode)
{
lock (_rulesContexts)
{
if (!_rulesContexts.ContainsKey(handle))
{
throw new ArgumentOutOfRangeException(
"handle", String.Format("The rule " +
"context with handle {0} cannot be " +
"updated in the cache because it " +
"does not exist.", handle));
}
UpsertRule(rule, ref handle,
runtimeMode);
}
}
string RegisterRemotingChannel (IsolationMode mode)
{
string remotingChannel;
if (mode == IsolationMode.ProcessTcp) {
remotingChannel = "tcp";
IChannel ch = ChannelServices.GetChannel ("tcp");
if (ch == null) {
ChannelServices.RegisterChannel (new TcpChannel (0), false);
}
} else {
remotingChannel = "unix";
IChannel ch = ChannelServices.GetChannel ("unix");
if (ch == null) {
string unixRemotingFile = Path.GetTempFileName ();
ChannelServices.RegisterChannel (new UnixChannel (unixRemotingFile), false);
}
}
return remotingChannel;
}
public Cart(IRule discountRule,
IsolationMode appDomainMode = IsolationMode.Shared,
IsolationMode runtimeMode = IsolationMode.Shared,
IsolationMode scopeMode = IsolationMode.Shared)
{
if (discountRule == null)
{
throw new ArgumentNullException(
"discountRule");
}
_appDomainMode = appDomainMode;
_runtimeMode = runtimeMode;
_scopeMode = scopeMode;
#if PASS_BY_VALUE
if (_appDomainMode == IsolationMode.Private)
{
discountRule.ExpectedReturnValueNames =
new[] { "cart" }
}
;
#endif
#if USE_SAFE_ENGINE
_ruleEngine = new RuleEngine(_appDomainMode);
_ruleHandle = _ruleEngine.InsertRule(
discountRule, _runtimeMode);
#else
_ruleEngine = new UnsafeRuleEngine();
_ruleHandle = _ruleEngine.InsertRule(
discountRule);
#endif
_ruleParameters =
new Dictionary <string, object>
{
{
"cart",
this
}
};
}
/// <summary>
/// Create a new engine for executing rules.
/// </summary>
/// <param name="appDomainMode">
/// Set to IsolationMode.Private to force all rules
/// in this engine to run in a separate application
/// domain. Set to IsolationMode.Shared to allow the
/// rules to run in the current application domain.
/// </param>
public RuleEngine(IsolationMode appDomainMode)
{
_runtimeSetup = new ScriptRuntimeSetup();
#if ENABLE_PYTHON
// Make sure that the IronPython.dll assembly
// is available to the application at runtime.
_runtimeSetup.LanguageSetups.Add(
new LanguageSetup(
"IronPython.Runtime.PythonContext, IronPython",
"IronPython",
new[] { "IronPython", "Python", "py" },
new[] { ".py" }));
#endif
#if ENABLE_RUBY
// Make sure that the IronRuby.dll assembly
// is available to the application at runtime.
_runtimeSetup.LanguageSetups.Add(
new LanguageSetup(
"IronRuby.Runtime.RubyContext, IronRuby",
"IronRuby",
new[] { "IronRuby", "Ruby", "rb" },
new[] { ".rb" }));
#endif
if (appDomainMode == IsolationMode.Private)
{
_remoteAppDomain = AppDomain.CreateDomain(
DateTime.UtcNow.ToString("s"));
}
_sharedRuntime =
(_remoteAppDomain != null)
? ScriptRuntime.CreateRemote(
_remoteAppDomain, _runtimeSetup)
: new ScriptRuntime(_runtimeSetup);
_rulesContexts =
new Dictionary <int, RuleContext>();
}
private static IsolationLevel TranslateIsolationLevel(IsolationMode mode)
{
switch (mode)
{
case IsolationMode.Chaos:
return(IsolationLevel.Chaos);
case IsolationMode.ReadCommitted:
return(IsolationLevel.ReadCommitted);
case IsolationMode.ReadUncommitted:
return(IsolationLevel.ReadUncommitted);
case IsolationMode.RepeatableRead:
return(IsolationLevel.RepeatableRead);
case IsolationMode.Serializable:
return(IsolationLevel.Serializable);
default:
return(IsolationLevel.Unspecified);
}
}
///<summary>
/// Create meta-information from the configuration about
/// what methods should be overridden.
///</summary>
public TransactionMetaInfo CreateMetaFromConfig(Type implementation, IList <MethodInfo> methods, IConfiguration config)
{
TransactionMetaInfo metaInfo = GetMetaFor(implementation);
if (metaInfo == null)
{
metaInfo = new TransactionMetaInfo();
}
foreach (MethodInfo method in methods)
{
String transactionMode = config.Attributes[TransactionModeAtt];
String isolationLevel = config.Attributes[IsolationModeAtt];
TransactionMode mode = ObtainTransactionMode(implementation, method, transactionMode);
IsolationMode level = ObtainIsolation(implementation, method, isolationLevel);
metaInfo.Add(method, new TransactionAttribute(mode, level));
}
Register(implementation, metaInfo);
return(metaInfo);
}
/// <summary>
/// Declares both the transaction mode and isolation
/// desired for this method. The transaction manager should
/// obey the declaration.
/// </summary>
/// <param name="transactionMode"></param>
/// <param name="isolationMode"></param>
public TransactionAttribute(TransactionMode transactionMode, IsolationMode isolationMode)
{
_transactionMode = transactionMode;
_isolationMode = isolationMode;
}
/// <summary>
/// Creates a transaction.
/// </summary>
/// <param name="transactionMode">The transaction mode.</param>
/// <param name="isolationMode">The isolation mode.</param>
/// <returns></returns>
public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode)
{
return CreateTransaction(transactionMode, isolationMode, false);
}
/// <summary>
/// Factory method for creating a transaction.
/// </summary>
/// <param name="transactionMode">The transaction mode.</param>
/// <param name="isolationMode">The isolation mode.</param>
/// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param>
/// <returns>A transaction</returns>
protected virtual AbstractTransaction InstantiateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
return new StandardTransaction(
new TransactionDelegate(RaiseTransactionCommitted),
new TransactionDelegate(RaiseTransactionRolledback),
new TransactionErrorDelegate(RaiseTransactionFailed),
transactionMode, isolationMode, distributedTransaction);
}
private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
//if (!transaction.Context.Contains(ContextKey))
{
IObjectContainer db4oContainer = (IObjectContainer) Kernel[typeof(IObjectContainer)];
transaction.Context[ContextKey] = true;
transaction.Enlist(new ResourceObjectContainerAdapter(db4oContainer));
}
}
public ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
CreateTransactionCalled++;
return(CurrentTransaction = new TestITransaction());
}
private TransactionBase InstantiateTransaction(TransactionMode mode, IsolationMode isolationMode, bool ambient)
{
var t = new TalkativeTransaction(mode, isolationMode, ambient);
t.TransactionCompleted += CompletedHandler;
t.TransactionRolledBack += RolledBackHandler;
t.TransactionFailed += FailedHandler;
return t;
}
/// <summary>
/// Sets the IsolationMode of the Context. This does not actually prevent Sandbox calls from being made.
/// </summary>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public PluginExecutionContextBuilder WithIsolationMode(IsolationMode mode)
{
Context.IsolationMode = (int)mode;
return(this);
}
public ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode,
bool distributedTransaction)
{
CreateTransactionCalled++;
return (CurrentTransaction = new TestITransaction());
}
private void InvokeTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
TransactionCreationInfoDelegate Delegate = TransactionCreated;
}
protected void RaiseChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode)
{
TransactionCreationInfoDelegate eventDelegate = (TransactionCreationInfoDelegate)_events[ChildTransactionCreatedEvent];
if (eventDelegate != null)
{
eventDelegate(transaction, transactionMode, isolationMode);
}
}
public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode)
{
if (transactionMode == TransactionMode.Unspecified)
{
transactionMode = ObtainDefaultTransactionMode(transactionMode);
}
CheckNotSupportedTransaction(transactionMode);
if (CurrentTransaction == null &&
(transactionMode == TransactionMode.Supported ||
transactionMode == TransactionMode.NotSupported))
{
return(null);
}
StandardTransaction transaction = null;
if (CurrentTransaction != null)
{
if (transactionMode == TransactionMode.Requires || transactionMode == TransactionMode.Supported)
{
transaction = (CurrentTransaction as StandardTransaction).CreateChildTransaction();
RaiseChildTransactionCreated(transaction, transactionMode, isolationMode);
}
}
if (transaction == null)
{
transaction = new StandardTransaction(
new TransactionDelegate(RaiseTransactionCommitted),
new TransactionDelegate(RaiseTransactionRolledback));
RaiseTransactionCreated(transaction, transactionMode, isolationMode);
}
_transactions.Push(transaction);
return(transaction);
}
public TalkactiveTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient, bool isReadOnly) :
base(null, transactionMode, isolationMode)
{
_IsAmbient = isAmbient;
_IsReadOnly = isReadOnly;
}
/// <summary>
/// Declares both the transaction mode and isolation
/// desired for this method. The transaction manager should
/// obey the declaration.
/// </summary>
/// <param name="transactionMode"></param>
/// <param name="isolationMode"></param>
public MvcTransactionAttribute(TransactionMode transactionMode, IsolationMode isolationMode)
{
TransactionMode = transactionMode;
IsolationMode = isolationMode;
Distributed = false;
}
/// <summary>
/// Gets the specified Isolation Mode value.
/// </summary>
/// <param name="isolationMode">IsolationMode enum.</param>
/// <returns>System.Int32.</returns>
public static int Get(IsolationMode isolationMode)
{
return((int)isolationMode);
}
/// <summary>
/// Initializes a new instance of the <see cref="TransactionScopeResourceAdapter"/> class.
/// </summary>
/// <param name="mode">The mode.</param>
/// <param name="isolationMode">The isolation mode.</param>
public TransactionScopeResourceAdapter(TransactionMode mode, IsolationMode isolationMode)
{
this.mode = mode;
this.isolationMode = isolationMode;
}
public TalkativeTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient, bool isReadOnly) :
base(null, transactionMode, isolationMode)
{
_IsAmbient = isAmbient;
_IsReadOnly = isReadOnly;
}
private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode)
{
transaction.Enlist(new TransactionScopeResourceAdapter(transactionMode));
}
private IsolationMode ReadValueFromConfigOrDefault(
string configName,
IsolationMode defaultValue) =>
Enum.TryParse <IsolationMode>(settingsResolver(configName), out var value) ? value : defaultValue;
/// <summary>
/// <see cref="ITransactionManager.CreateTransaction(Castle.Services.Transaction.TransactionMode,Castle.Services.Transaction.IsolationMode)"/>.
/// </summary>
public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode isolationMode)
{
return CreateTransaction(txMode, isolationMode, false);
}
public StandardTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) :
base(transactionMode, isolationMode, distributedTransaction)
{
}
private void InvokeChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
TransactionCreationInfoDelegate Delegate = ChildTransactionCreated;
}
public TalkativeTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient) :
base(null, transactionMode, isolationMode)
{
_IsAmbient = isAmbient;
}
/// <summary>
/// Creates a transaction.
/// </summary>
/// <param name="transactionMode">The transaction mode.</param>
/// <param name="isolationMode">The isolation mode.</param>
/// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param>
/// <returns></returns>
public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
{
if (transactionMode == TransactionMode.Unspecified)
{
transactionMode = ObtainDefaultTransactionMode(transactionMode);
}
CheckNotSupportedTransaction(transactionMode);
if (CurrentTransaction == null &&
(transactionMode == TransactionMode.Supported ||
transactionMode == TransactionMode.NotSupported))
{
return null;
}
AbstractTransaction transaction = null;
if (CurrentTransaction != null)
{
if (transactionMode == TransactionMode.Requires || transactionMode == TransactionMode.Supported)
{
transaction = ((StandardTransaction) CurrentTransaction).CreateChildTransaction();
RaiseChildTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction);
logger.DebugFormat("Child Transaction {0} created", transaction.GetHashCode());
}
}
if (transaction == null)
{
transaction = InstantiateTransaction(transactionMode, isolationMode, distributedTransaction);
if (distributedTransaction)
{
#if MONO
throw new TransactionException("Distributed transactions are not supported on Mono");
#else
transaction.Enlist(new TransactionScopeResourceAdapter(transactionMode, isolationMode));
#endif
}
RaiseTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction);
logger.DebugFormat("Transaction {0} created", transaction.GetHashCode());
}
transaction.Logger = logger.CreateChildLogger(transaction.GetType().FullName);
activityManager.CurrentActivity.Push(transaction);
return transaction;
}
public AbstractTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
: this(transactionMode, isolationMode, distributedTransaction, null)
{
}
protected void RaiseChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode,
IsolationMode isolationMode, bool distributedTransaction)
{
TransactionCreationInfoDelegate eventDelegate =
(TransactionCreationInfoDelegate) events[ChildTransactionCreatedEvent];
if (eventDelegate != null)
{
eventDelegate(transaction, transactionMode, isolationMode, distributedTransaction);
}
}
private static IsolationLevel TranslateIsolationLevel(IsolationMode mode)
{
switch (mode)
{
case IsolationMode.Chaos:
return IsolationLevel.Chaos;
case IsolationMode.ReadCommitted:
return IsolationLevel.ReadCommitted;
case IsolationMode.ReadUncommitted:
return IsolationLevel.ReadUncommitted;
case IsolationMode.RepeatableRead:
return IsolationLevel.RepeatableRead;
case IsolationMode.Serializable:
return IsolationLevel.Serializable;
default:
return IsolationLevel.Unspecified;
}
}
/// <summary>
/// Sets the IsolationMode of the Context. This does not actually prevent Sandbox calls from being made.
/// </summary>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public TDerived WithIsolationMode(IsolationMode mode)
{
return(WithIsolationMode((int)mode));
}
/// <summary>
/// <see cref="ITransactionManager.CreateTransaction(Castle.Services.Transaction.TransactionMode,Castle.Services.Transaction.IsolationMode)"/>.
/// </summary>
public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode isolationMode)
{
return(CreateTransaction(txMode, isolationMode, false));
}
/// <summary>
/// Declares both the transaction mode and isolation
/// desired for this method. The transaction manager should
/// obey the declaration.
/// </summary>
/// <param name="transactionMode"></param>
/// <param name="isolationMode"></param>
public TransactionAttribute(TransactionMode transactionMode, IsolationMode isolationMode)
{
_transactionMode = transactionMode;
_isolationMode = isolationMode;
}
public TalkativeTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient) :
base(null, transactionMode, isolationMode)
{
_IsAmbient = isAmbient;
}
private TransactionBase InstantiateTransaction(TransactionMode mode, IsolationMode isolationMode, bool ambient, bool readOnly)
{
var t = new TalkactiveTransaction(mode, isolationMode, ambient, readOnly);
t.Logger = this.Logger.CreateChildLogger("TalkactiveTransaction");
t.TransactionCompleted += CompletedHandler;
t.TransactionRolledBack += RolledBackHandler;
t.TransactionFailed += FailedHandler;
return t;
}
public static int Main(string[] args)
{
int n = 0;
IsolationMode mode = IsolationMode.None;
bool usePartial = false;
bool useGettext = false;
bool genEmpty = false;
bool useMultifile = false;
while (n < args.Length)
{
string arg = args[n];
if (arg.StartsWith("--language:"))
{
language = arg.Substring(11);
}
else if (arg.StartsWith("-l:"))
{
language = arg.Substring(3);
}
else if (arg.StartsWith("-lib:"))
{
libraries.Add(arg.Substring(5));
}
else if (arg.StartsWith("--library:"))
{
libraries.Add(arg.Substring(10));
}
else if (arg == "--generate" || arg == "-g")
{
break;
}
else if (arg == "--noisolation")
{
mode = IsolationMode.None;
}
else if (arg == "--gen-partial")
{
usePartial = true;
}
else if (arg == "--gen-gettext")
{
useGettext = true;
}
else if (arg == "--gen-multifile")
{
useMultifile = true;
}
else if (arg == "--gen-empty")
{
genEmpty = true;
}
else
{
break;
}
n++;
}
if (args.Length == 1 && args [0] == "--help")
{
Console.WriteLine(Catalog.GetString("Stetic - A GTK User Interface Builder"));
Console.WriteLine(Catalog.GetString("Usage:"));
Console.WriteLine("\tstetic [<file>]");
Console.WriteLine("\tstetic [--language:<language>] [-lib:<library>...] --generate <sourceFile> <projectFile> ...");
return(0);
}
Program = new Gnome.Program("Stetic", "0.0", Gnome.Modules.UI, args);
int ret;
if (args.Length - n > 2 && ((args [n] == "--generate" || args [n] == "-g")))
{
SteticApp = Stetic.ApplicationFactory.CreateApplication(IsolationMode.None);
GenerationOptions ops = new GenerationOptions();
ops.UsePartialClasses = usePartial;
ops.GenerateEmptyBuildMethod = genEmpty;
ops.UseGettext = useGettext;
ops.GenerateSingleFile = !useMultifile;
ret = GenerateCode(args [n + 1], args, n + 2, ops);
}
else
{
SteticApp = Stetic.ApplicationFactory.CreateApplication(mode);
SteticApp.AllowInProcLibraries = false;
ret = RunApp(args, n);
}
SteticApp.Dispose();
return(ret);
}
