コード例 #1
0
 void IOnBehalfAware.SetInterceptedComponentModel(ComponentModel target)
 {
     Contract.Ensures(_MetaInfo != null);
     Contract.Assume(target != null && target.Implementation != null);
     _MetaInfo = _Store.GetMetaFromType(target.Implementation);
     _State    = InterceptorState.Initialized;
 }
コード例 #2
0
 private void SetInterceptedComponentModel(ParentServiceRequestInfo target)
 {
     Contract.Ensures(_MetaInfo != null);
     Contract.Assume(target.ImplementationType != null);
     _MetaInfo = _Store.GetMetaFromType(target.ImplementationType);
     _State    = InterceptorState.Initialized;
 }
コード例 #3
0
        void IInterceptor.Intercept(IInvocation invocation)
        {
            Contract.Assume(_State == InterceptorState.Active || _State == InterceptorState.Initialized);
            Contract.Assume(invocation != null);

            var txManagerC = _Container.Resolve <TransactionManager>();
            ITransactionManager txManager = txManagerC;

            var mTxMethod = _MetaInfo.Do(x => x.AsTransactional(invocation.MethodInvocationTarget ?? invocation.Method));

            var mTxData = mTxMethod.Do(x => txManager.CreateTransaction(x));

            _State = InterceptorState.Active;

            try
            {
                if (!mTxData.HasValue)
                {
                    if (mTxMethod.HasValue && mTxMethod.Value.Mode == TransactionScopeOption.Suppress)
                    {
                        if (_Logger.IsEnabled(LogLevel.Information))
                        {
                            _Logger.LogInformation("supressing ambient transaction");
                        }

                        using (new TxScope(null, _AutoTxOptions.AmbientTransaction, _LoggerFactory.CreateChildLogger("TxScope", GetType())))
                            invocation.Proceed();
                    }
                    else
                    {
                        invocation.Proceed();
                    }

                    return;
                }

                var transaction = mTxData.Value.Transaction;
                Contract.Assume(transaction.State == TransactionState.Active,
                                "from post-condition of ITransactionManager CreateTransaction in the (HasValue -> ...)-case");

                if (mTxData.Value.ShouldFork)
                {
                    if (_AutoTxOptions.AmbientTransaction == AmbientTransactionOption.Disabled)
                    {
                        throw new TransactionException("Forking is not supported if ambient transactions are disabled");
                    }

                    var task = ForkCase(invocation, mTxData.Value);
                    txManagerC.EnlistDependentTask(task);
                }
                else
                {
                    SynchronizedCase(invocation, transaction);
                }
            }
            finally
            {
                _Container.Release(txManagerC);
            }
        }
コード例 #4
0
        void IInterceptor.Intercept(IInvocation invocation)
        {
            Contract.Assume(_State == InterceptorState.Active || _State == InterceptorState.Initialized);
            Contract.Assume(invocation != null);

            var txManagerC = _Kernel.Resolve <TransactionManager>();
            ITransactionManager txManager = txManagerC;

            var mTxMethod = _MetaInfo.Do(x => x.AsTransactional(invocation.MethodInvocationTarget ?? invocation.Method));

            var mTxData = mTxMethod.Do(x => txManager.CreateTransaction(x));

            _State = InterceptorState.Active;

            try
            {
                if (!mTxData.HasValue)
                {
                    if (mTxMethod.HasValue && mTxMethod.Value.Mode == TransactionScopeOption.Suppress)
                    {
                        _Logger.Info("supressing ambient transaction");
                        if (_Logger.IsInfoEnabled)
                        {
                            _Logger.Info("supressing ambient transaction");
                        }

                        using (new TxScope(null, _Logger.CreateChildLogger("TxScope")))
                            invocation.Proceed();
                    }
                    else
                    {
                        invocation.Proceed();
                    }

                    return;
                }

                var transaction = mTxData.Value.Transaction;
                Contract.Assume(transaction.State == TransactionState.Active,
                                "from post-condition of ITransactionManager CreateTransaction in the (HasValue -> ...)-case");

                if (mTxData.Value.ShouldFork)
                {
                    var task = ForkCase(invocation, mTxData.Value);
                    txManagerC.EnlistDependentTask(task);
                }
                else if (typeof(Task).IsAssignableFrom(invocation.MethodInvocationTarget.ReturnType))
                {
                    AsyncCase(invocation, transaction);
                }
                else
                {
                    SynchronizedCase(invocation, transaction);
                }
            }
            finally
            {
                _Kernel.ReleaseComponent(txManagerC);
            }
        }
コード例 #5
0
		public TransactionInterceptor(IKernel kernel, ITransactionMetaInfoStore store)
		{
			Contract.Requires(kernel != null, "kernel must be non null");
			Contract.Requires(store != null, "store must be non null");
			Contract.Ensures(_State == InterceptorState.Constructed);

			_Kernel = kernel;
			_Store = store;
			_State = InterceptorState.Constructed;
		}
コード例 #6
0
        public TransactionInterceptor(IKernel kernel, ITransactionMetaInfoStore store)
        {
            Contract.Requires(kernel != null, "kernel must be non null");
            Contract.Requires(store != null, "store must be non null");
            Contract.Ensures(_State == InterceptorState.Constructed);

            _Logger.Debug("created transaction interceptor");

            _Kernel = kernel;
            _Store  = store;
            _State  = InterceptorState.Constructed;
        }
コード例 #7
0
		void IInterceptor.Intercept(IInvocation invocation)
		{
			Contract.Assume(_State == InterceptorState.Active || _State == InterceptorState.Initialized);
			Contract.Assume(invocation != null);

			var txManagerC = _Kernel.Resolve<TransactionManager>();
			ITransactionManager txManager = txManagerC;

			var mTxMethod = _MetaInfo.Do(x => x.AsTransactional(invocation.Method.DeclaringType.IsInterface
			                                                    	? invocation.MethodInvocationTarget
			                                                    	: invocation.Method));

			var mTxData = mTxMethod.Do(x => txManager.CreateTransaction(x));

			_State = InterceptorState.Active;

			try
			{
				if (!mTxData.HasValue)
				{
					if (mTxMethod.HasValue && mTxMethod.Value.Mode == TransactionScopeOption.Suppress)
					{
						if (_Logger.IsInfoEnabled)
							_Logger.Info("supressing ambient transaction");

						using (new TxScope(null, _Logger.CreateChildLogger("TxScope")))
							invocation.Proceed();
					}
					else invocation.Proceed();

					return;
				}

				var transaction = mTxData.Value.Transaction;
				Contract.Assume(transaction.State == TransactionState.Active,
				                "from post-condition of ITransactionManager CreateTransaction in the (HasValue -> ...)-case");

				if (mTxData.Value.ShouldFork)
				{
					var task = ForkCase(invocation, mTxData.Value);
					txManagerC.EnlistDependentTask(task);
				}
				else SynchronizedCase(invocation, transaction);
			}
			finally
			{
				_Kernel.ReleaseComponent(txManagerC);
			}
		}
コード例 #8
0
        public TransactionInterceptor(IContainer container, ITransactionMetaInfoStore store, ParentServiceRequestInfo parentServiceRequestInfo, AutoTxOptions autoTxOptions, ILoggerFactory loggerFactory)
        {
            Contract.Requires(container != null, "container must be non null");
            Contract.Requires(store != null, "store must be non null");
            Contract.Ensures(_State == InterceptorState.Constructed);

            _Container     = container;
            _Store         = store;
            _AutoTxOptions = autoTxOptions;
            _LoggerFactory = loggerFactory;
            _Logger        = loggerFactory.CreateLogger(GetType());
            _State         = InterceptorState.Constructed;

            _Logger.LogDebug($"created transaction interceptor for {parentServiceRequestInfo.ImplementationType}");

            SetInterceptedComponentModel(parentServiceRequestInfo);
        }
コード例 #9
0
		void IInterceptor.Intercept(IInvocation invocation)
		{
			Contract.Assume(_State == InterceptorState.Active || _State == InterceptorState.Initialized);
			Contract.Assume(invocation != null);

			var txManager = _Kernel.Resolve<ITransactionManager>();

			var mTxMethod = _MetaInfo.Do(x => x.AsTransactional(invocation.Method.DeclaringType.IsInterface
			                                                    	? invocation.MethodInvocationTarget
			                                                    	: invocation.Method));

			var mTxData = mTxMethod.Do(x => txManager.CreateTransaction(x));

			_State = InterceptorState.Active;

			if (!mTxData.HasValue)
			{
				if (mTxMethod.HasValue && mTxMethod.Value.Mode == TransactionScopeOption.Suppress)
					using (new TransactionScope(null))
						invocation.Proceed();

				else invocation.Proceed();

				return;
			}

			var transaction = mTxData.Value.Transaction;

			Contract.Assume(transaction.State == TransactionState.Active,
			                "from post-condition of ITransactionManager CreateTransaction in the (HasValue -> ...)-case");

			// TODO 3.0GA: implement functionality for getting tasks and awating them
#pragma warning disable 168
			Task forkCase;
#pragma warning restore 168
			if (mTxData.Value.ShouldFork)
				// TODO: Handle case where child transaction aborts and task is never waited upon!
				ForkCase(invocation, mTxData.Value);
			else
				SynchronizedCase(invocation, transaction);
		}
コード例 #10
0
    public override void Update()
    {
        base.Update();
        if (aggroed)
        {
            if (interceptorState == InterceptorState.Attack)
            {
                interceptDestination = AggroTarget.position + Vector3.up * interceptDistanceFromPlayer;
                MoveTowardsVector(interceptDestination);

                if (canFire && WithinFiringRange(AggroTarget))
                {
                    Shoot();
                }
                if (Vector3.Distance(interceptDestination, transform.position) < 7.5f)
                {
                    speedMultiplier  = 1.0f;
                    interceptorState = InterceptorState.LoopAround;
                }
            }
            else if (interceptorState == InterceptorState.LoopAround)
            {
                Vector3 targetDir = AggroTarget.position - transform.position;

                // The step size is equal to speed times frame time.
                float step = rotateSpeed * Time.deltaTime;

                Vector3 newDir = Vector3.RotateTowards(transform.forward, targetDir, step, 0.0f);

                // Move our position a step closer to the target.
                transform.rotation = Quaternion.LookRotation(newDir);

                transform.eulerAngles = new Vector3(0, transform.eulerAngles.y, 0);

                MoveInDirection(transform.forward, false);

                Vector3 targetPositionSameYPos = new Vector3(AggroTarget.position.x, transform.position.y, AggroTarget.position.z);
                Vector3 targetDirSameYPos      = targetPositionSameYPos - transform.position;

                if (Vector3.Angle(transform.forward, targetDirSameYPos) < 10.0f)
                {
                    speedMultiplier  = 0.7f;
                    interceptorState = InterceptorState.Attack;
                }
            }
            else
            {
                MoveTowardsTransform(AggroTarget);
                if (WithinFiringRange(AggroTarget))
                {
                    speedMultiplier  = 0.7f;
                    interceptorState = InterceptorState.Attack;
                }
            }
        }
        else
        {
            speedMultiplier  = 1.0f;
            interceptorState = InterceptorState.Approach;
            MoveInDirection(transform.forward);
        }
    }
コード例 #11
0
		void IOnBehalfAware.SetInterceptedComponentModel(ComponentModel target)
		{
			Contract.Ensures(_MetaInfo != null);
			Contract.Assume(target != null && target.Implementation != null);
			_MetaInfo = _Store.GetMetaFromType(target.Implementation);
			_State = InterceptorState.Initialized;
		}