public void loads_initial_validators_from_contract() { var initialValidator = TestItem.AddressA; SetupInitialValidators(initialValidator); IAuRaValidatorProcessor validator = new ContractValidator(_validator, new MemDb(), _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _logManager, 1); _block.Number = 1; _block.Beneficiary = initialValidator; validator.PreProcess(_block); // getValidators should have been called _transactionProcessor.Received(1) .Execute( Arg.Is <Transaction>(t => CheckTransaction(t, _getValidatorsData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); // finalizeChange should be called _transactionProcessor.Received(1) .Execute(Arg.Is <Transaction>(t => CheckTransaction(t, _finalizeChangeData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); // initial validator should be true validator.IsValidSealer(initialValidator).Should().BeTrue(); }
public void loads_initial_validators_from_contract(InitializeValidatorsTestParameters test) { var initialValidators = Enumerable.Range(1, test.InitialValidatorsCount).Select(i => Address.FromNumber((UInt256)i)).ToArray(); SetupInitialValidators(initialValidators); var validator = new ContractValidator(_validator, _stateProvider, _abiEncoder, _transactionProcessor, _logManager, test.StartBlockNumber); for (int i = 0; i < test.NumberOfSteps; i++) { _block.Number = test.BlockNumber + i; _block.Beneficiary = initialValidators[i % initialValidators.Length]; validator.PreProcess(_block); } // getValidators should have been called _transactionProcessor.Received(1) .Execute( Arg.Is <Transaction>(t => CheckTransaction(t, _getValidatorsData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); // finalizeChange should be called or not based on test spec _transactionProcessor.Received(test.ExpectedFinalizationCount) .Execute(Arg.Is <Transaction>(t => CheckTransaction(t, _finalizeChangeData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); // all initial validators should be true initialValidators.Select(a => validator.IsValidSealer(a)).Should().AllBeEquivalentTo(true); }
public void EditContract(Contract contract) { IValidator validator = ContractValidator.CreateValidator(contract, true, singleProfileName); validator.Validate(); repository.EditContract(contract); }
public void NewContract(Contract contract) { IValidator validator = ContractValidator.CreateValidator(contract, false, singleProfileName); validator.Validate(); repository.NewContract(contract); }
private void ValidateConstructorParameters(Type contractInterface, Type realProxyType, String channelId, AddressEndPoint remoteEp) { if (contractInterface == null) { ThrowHelper.ThrowArgumentNullException("contractInterface"); } if (realProxyType == null) { ThrowHelper.ThrowArgumentNullException("realProxyType"); } if (string.IsNullOrEmpty(channelId)) { ThrowHelper.ThrowArgumentNullException("channelId"); } if (!contractInterface.IsAssignableFrom(realProxyType)) { ThrowHelper.ThrowArgumentException("Provided client proxy does not implements the provided contract interface.", "realProxyType"); } if (remoteEp == null) { ThrowHelper.ThrowArgumentNullException("remoteEp"); } if (!ChannelServices.IsChannelRegistered(channelId)) { throw new ChannelNotFoundException(channelId); } ContractValidator.ValidateContractIntegrity(contractInterface); ImplementationValidator.ValidateProxyIntegration(realProxyType); this.mContractInterface = contractInterface; this.mRealProxyType = realProxyType; this.mChannel = ChannelServices.GetChannelById(channelId); this.mRemoteEndPoint = remoteEp; }
public void loads_initial_validators_from_contract(long blockNumber, bool producingBlock) { var initialValidator = TestItem.AddressA; SetupInitialValidators(initialValidator); var startBlockNumber = 1; IAuRaValidatorProcessor validator = new ContractValidator(_validator, new MemDb(), _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _receiptsStorage, _logManager, startBlockNumber); _block.Number = blockNumber; _block.Beneficiary = initialValidator; validator.PreProcess(_block, producingBlock ? ProcessingOptions.ProducingBlock : ProcessingOptions.None); // getValidators should have been called _transactionProcessor.Received(1) .Execute( Arg.Is <Transaction>(t => CheckTransaction(t, _getValidatorsData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); if (blockNumber == startBlockNumber) { // finalizeChange should be called _transactionProcessor.Received(1) .Execute(Arg.Is <Transaction>(t => CheckTransaction(t, _finalizeChangeData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); } // initial validator should be true validator.IsValidSealer(initialValidator, 5).Should().BeTrue(); }
/// <summary> /// Registers the contract. /// </summary> /// <param name="contractType">Type of the contract.</param> /// <param name="defaultChannelId">The default channel id.</param> /// <param name="defaultProxyType">Default type of the proxy.</param> /// <exception cref="System.InvalidOperationException">Contract has already registered.</exception> public static void RegisterContract(Type contractType, string defaultChannelId, Type defaultProxyType) { DoInitializeCheck(); if (contractType == null) { ThrowHelper.ThrowArgumentNullException("contractType"); } ContractValidator.ValidateContractIntegrity(contractType); if (!ChannelServices.IsChannelRegistered(defaultChannelId)) { ThrowHelper.ThrowArgumentException("Default channel identifier has not found."); } if (defaultProxyType != null) { ImplementationValidator.ValidateProxyIntegration(defaultProxyType); } lock (mContractDescriptors) { if (mContractDescriptors.ContainsKey(contractType)) { throw new InvalidOperationException("Contract has already registered."); } ContractClientSideDescriptor descriptor = new ContractClientSideDescriptor(contractType, defaultChannelId, defaultProxyType); mContractDescriptors.Add(contractType, descriptor); } }
public void nonconsecutive_non_producing_preProcess_loads_pending_validators_from_receipts(int lastLevelFinalized, int initialValidatorsIndex, int?expectedBlockValidators) { IEnumerable <Block> GetAllBlocks(BlockTree bt) { var block = bt.FindBlock(bt.Head.Hash, BlockTreeLookupOptions.None); while (block != null) { yield return(block); block = bt.FindBlock(block.ParentHash, BlockTreeLookupOptions.None); } } var validators = TestItem.Addresses[initialValidatorsIndex * 10]; var inMemoryReceiptStorage = new InMemoryReceiptStorage(); var blockTreeBuilder = Build.A.BlockTree().WithTransactions(inMemoryReceiptStorage, RopstenSpecProvider.Instance, delegate(Block block, Transaction transaction) { byte i = 0; return(new[] { Build.A.LogEntry.WithAddress(_contractAddress) .WithData(new[] { (byte)(block.Number * 10 + i++) }) .WithTopics(ValidatorContract.Definition.initiateChangeEventHash, block.ParentHash) .TestObject }); }) .OfChainLength(9, 0, 0, validators); var blockTree = blockTreeBuilder.TestObject; SetupInitialValidators(blockTree.Head, validators); IAuRaValidatorProcessor validator = new ContractValidator(_validator, _db, _stateProvider, _abiEncoder, _transactionProcessor, blockTree, inMemoryReceiptStorage, _logManager, 1); validator.SetFinalizationManager(_blockFinalizationManager); _abiEncoder.Decode(ValidatorContract.Definition.addressArrayResult, Arg.Any <byte[]>()) .Returns(c => { var addressIndex = c.Arg <byte[]>()[0]; return(new object[] { new Address[] { TestItem.Addresses[addressIndex] } }); }); _blockFinalizationManager.GetLastLevelFinalizedBy(blockTree.Head.ParentHash).Returns(lastLevelFinalized); validator.PreProcess(blockTree.FindBlock(blockTree.Head.Hash, BlockTreeLookupOptions.None)); byte[] expectedPendingValidatorsBytes = Rlp.OfEmptySequence.Bytes; if (expectedBlockValidators.HasValue) { var block = GetAllBlocks(blockTree).First(b => b.Number == expectedBlockValidators.Value); var pendingValidators = new ContractValidator.PendingValidators(block.Number, block.Hash, new [] { TestItem.Addresses[block.Number * 10] }); expectedPendingValidatorsBytes = Rlp.Encode(pendingValidators).Bytes; } _db.Received()[ContractValidator.PendingValidatorsKey.Bytes] = Arg.Is <byte[]>(r => r.SequenceEqual(expectedPendingValidatorsBytes)); }
public void creates_system_account_on_start_block() { SetupInitialValidators(Address.FromNumber(2000)); var validator = new ContractValidator(_validator, _stateProvider, _abiEncoder, _transactionProcessor, _logManager, 1); validator.PreProcess(_block); _stateProvider.Received(1).CreateAccount(Address.SystemUser, UInt256.Zero); _stateProvider.Received(1).Commit(Homestead.Instance); }
public void Validate() { var validator = new ContractValidator(); var validationResult = validator.Validate(this); if (!validationResult.IsValid) { throw new ValidationException(string.Join(";", validationResult.Errors.Select(i => i.ErrorCode))); } }
/// <summary> /// Creates the proxy. /// </summary> /// <returns>Contract</returns> public TContract CreateProxy() { ConstructorInfo c = mRealProxyType.GetConstructor(new Type[] { typeof(Channel), typeof(String) }); ProxyBase proxy = (ProxyBase)c.Invoke(new object[] { mChannel, mChannel.Connect(mRemoteEndPoint) }); WellKnownObjectModeEnum mode = WellKnownObjectModeEnum.PerSession; if (ContractValidator.GetWellKnownObjectMode(mContractInterface, out mode) && mode == WellKnownObjectModeEnum.PerSession) { ServiceBase.RegisterProxy(mChannel, mContractInterface, proxy.GetType(), proxy.SessionId, proxy.ProxyId, proxy); } return((TContract)(IRemoteContract)proxy); }
public async Task<bool> CreateContractAsync(DtoContract contract) { var validator = new ContractValidator(this.policy, this.calculator); var result = validator.Validate(contract); if (!result.IsValid) { return false; } var entity = Mapper.Map<Contract>(contract); this.contractRepository.Add(entity); await this.contractRepository.SaveChangesAsync(); return true; }
public dynamic Post([FromRoute] string enrollmentNumber, [FromBody] Form obj) { Enrollment enrollment = _enrollmentService.List().SingleOrDefault(x => x.ExternalId == enrollmentNumber); if (enrollment == null) { return(new BadRequestObjectResult(new { messages = new List <string> { onboarding.Resources.Messages.EnrollmentLinkIsNotValid } })); } if (!enrollment.IsDeadlineValid()) { return(new BadRequestObjectResult(new { messages = new List <string> { onboarding.Resources.Messages.OnboardingExpired } })); } Contract contract = _mapper.Map <Contract>(obj); if (enrollment.Contract != null) { enrollment.Contract.Signature = contract.Signature; enrollment.Contract.AcceptedAt = contract.AcceptedAt; contract = _contractService.Update(enrollment.Contract); } else { contract = _contractService.Add(contract); } ContractValidator validator = new ContractValidator(); Hashtable errors = FormatErrors(validator.Validate(contract)); ContractStatus contractStatus = new ContractStatus(validator, contract); if (contractStatus.GetStatus() == "valid") { _enrollmentStepService.Update(enrollmentNumber, "Contracts"); } return(new OkObjectResult(new { errors, data = _mapper.Map <Record>(contract) })); }
public ValidationService(IPrimaryContext context) { Context = context; _contactvalidator = new ContactValidator(); _customervalidator = new CustomerValidator(); _userValidator = new UserValidator(context); _customerSourceValidator = new CustomerSourceValidator(context); _serviceAreaValidator = new ServiceAreaValidator(context); _serviceDivisionValidator = new ServiceDivisionValidator(context); _unitTypeValidator = new UnitTypeValidator(context); _stateValidator = new StateValidator(context); _goodsValidator = new GoodsValidator(context); _customerLocationValidator = new CustomerLocationValidator(context); _contractValidator = new ContractValidator(context); _locationServiceValidator = new LocationServiceValidator(context); }
public void consecutive_initiate_change_gets_finalized_and_switch_validators(ConsecutiveInitiateChangeTestParameters test) { var currentValidators = GenerateValidators(1); SetupInitialValidators(currentValidators); IAuRaValidatorProcessor validator = new ContractValidator(_validator, new MemDb(), _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _receiptsStorage, _logManager, test.StartBlockNumber); validator.SetFinalizationManager(_blockFinalizationManager); test.TryDoReorganisations(test.StartBlockNumber, out _); for (int i = 0; i < test.Current.NumberOfSteps; i++) { var blockNumber = test.Current.BlockNumber + i; if (test.TryDoReorganisations(blockNumber, out var lastChain)) { ValidateFinalizationForChain(lastChain); i = 0; blockNumber = test.Current.BlockNumber + i; } _block.Number = blockNumber; _block.Beneficiary = currentValidators[blockNumber % currentValidators.Length]; _block.Header.AuRaStep = blockNumber; _block.Hash = Keccak.Compute(blockNumber.ToString()); var txReceipts = test.GetReceipts(_block, _contractAddress, _abiEncoder, SetupAbiAddresses); _block.Bloom = new Bloom(txReceipts.SelectMany(r => r.Logs).ToArray()); Action preProcess = () => validator.PreProcess(_block); preProcess.Should().NotThrow <InvalidOperationException>(test.TestName); validator.PostProcess(_block, txReceipts); var finalizedNumber = blockNumber - validator.MinSealersForFinalization + 1; _blockFinalizationManager.BlocksFinalized += Raise.EventWith( new FinalizeEventArgs(_block.Header, Build.A.BlockHeader.WithNumber(finalizedNumber) .WithHash(Keccak.Compute(finalizedNumber.ToString())).TestObject)); currentValidators = test.GetCurrentValidators(blockNumber); var nextValidators = test.GetNextValidators(blockNumber); currentValidators.Select((a, index) => validator.IsValidSealer(a, index)).Should().AllBeEquivalentTo(true, $"Validator address is not recognized in block {blockNumber}"); nextValidators?.Except(currentValidators).Select((a, index) => validator.IsValidSealer(a, index)).Should().AllBeEquivalentTo(false); } ValidateFinalizationForChain(test.Current); }
public void loads_initial_validators_from_contract_on_demand() { var validator = new ContractValidator(_validator, _db, _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _receiptsStorage, _logManager, 1); var initialValidator = TestItem.AddressA; SetupInitialValidators(initialValidator); _block.Number = 3; _blockTree.Head.Returns(_block.Header); validator.IsValidSealer(initialValidator, 10); // getValidators should have been called _transactionProcessor.Received(1) .Execute( Arg.Is <Transaction>(t => CheckTransaction(t, _getValidatorsData)), _block.Header, Arg.Is <ITxTracer>(t => t is CallOutputTracer)); }
public InstagramContract Save(InstagramContract entity) { if (entity.Id == 0) { entity.ContractNo = GenerateContractNo(); } var errorList = new List <ValidationFailure>(); entity.ContractContext = new SystemParameterRepository().GetEntity(SystemParameterCodes.InstagramContractContext)?.Value; SetLogInfo(entity); var errorEntity = ContractValidator.GetInstance().Validate(entity); errorList.AddRange(errorEntity.Errors); entity.InstagramContractPlans.ToList().ForEach(item => { var error = InstagramContractPlanValidator.GetInstance().Validate(item); InstagramContractPlanService.GetInstance().SetLogInfo(item); var dur = Convert.ToInt32(item.DurationTitle.Replace("ماه", "").Trim()); if (item.StartDate != null) { item.StartDate = Utility.ConvertToPersian(item.StartDate.ToString()); } //item.StartDate = DateTime.Now; item.EndDate = item.StartDate.AddMonths(dur); errorList.AddRange(error.Errors); }); if (errorList.Count != 0) { throw new SpadException(string.Join(",", errorList.Select(s => s.ErrorMessage))); } var result = _repository.Save(entity); return(entity); }
public void initializes_pendingValidators_from_db() { var blockNumber = 10; var validators = TestItem.Addresses.Take(10).ToArray(); var blockHash = Keccak.Compute("Test"); var pendingValidators = new ContractValidator.PendingValidators(blockNumber, blockHash, validators); var rlp = Rlp.Encode(pendingValidators); _db[ContractValidator.PendingValidatorsKey.Bytes].Returns(rlp.Bytes); IAuRaValidatorProcessor validator = new ContractValidator(_validator, _db, _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _receiptsStorage, _logManager, 1); validator.SetFinalizationManager(_blockFinalizationManager); _blockFinalizationManager.BlocksFinalized += Raise.EventWith(new FinalizeEventArgs(_block.Header, Build.A.BlockHeader.WithNumber(blockNumber).WithHash(blockHash).TestObject)); validators.Select((v, i) => validator.IsValidSealer(v, i)).Should().AllBeEquivalentTo(true); }
public async Task <IHttpActionResult> Post(TContract contract) { IEnumerable <string> validationErrors = new List <string>(); validationErrors = validationErrors.Concat(await ContractValidator.ValidateContract(contract)); if (validationErrors.Any()) { return(BadRequest(string.Join("\n", validationErrors))); } contract.CreatedByUserId = IdPrincipal.Id; contract.CreatedOn = DateTimeOffset.UtcNow; contract.LastUpdatedByUserId = null; contract.LastUpdatedOn = null; var createdTDto = await Dal.Create(Mapper.Map <TDto>(contract)); var createdT = Mapper.Map <TContract>(createdTDto); return(Created(Url.Link(CreatedRouteName, new { id = createdT.Id, controller = ControllerName }), createdT)); }
public Contract Save(Contract entity) { if (entity.Id == 0) { entity.ContractNo = GenerateContractNo(); } var errorList = new List <ValidationFailure>(); entity.ContractContext = new SystemParameterRepository().GetEntity(SystemParameterCodes.InstagramContractContext)?.Value; SetLogInfo(entity); var errorEntity = ContractValidator.GetInstance().Validate(entity); errorList.AddRange(errorEntity.Errors); //entity.instagramContractPlans.ToList().ForEach(item => //{ // var error = ContractPlanValidator.GetInstance().Validate(item); // ContractPlanService.GetInstance().SetLogInfo(item); // item.StartDate = DateTime.Now; // item.EndDate = DateTime.Now; // errorList.AddRange(error.Errors); //}); if (errorList.Count != 0) { throw new SpadException(string.Join(",", errorList.Select(s => s.ErrorMessage))); } var result = _repository.Save(entity); return(entity); }
public async Task <IHttpActionResult> Put(TContract contract) { IEnumerable <string> validationErrors = new List <string>(); validationErrors = validationErrors.Concat(await ContractValidator.ValidateContract(contract)); if (validationErrors.Any()) { return(BadRequest(string.Join("\n", validationErrors))); } try { contract.LastUpdatedByUserId = IdPrincipal.Id; contract.LastUpdatedOn = DateTimeOffset.UtcNow; var updatedTDto = await Dal.Update(Mapper.Map <TDto>(contract)); var updatedT = Mapper.Map <TContract>(updatedTDto); return(Ok(updatedT)); } catch (ObjectNotFoundException) { return(NotFound()); } }
public void consecutive_initiate_change_gets_finalized_and_switch_validators(ConsecutiveInitiateChangeTestParameters test) { var currentValidators = GenerateValidators(1); SetupInitialValidators(currentValidators); var validator = new ContractValidator(_validator, _stateProvider, _abiEncoder, _transactionProcessor, _logManager, test.StartBlockNumber); test.TryDoReorganisations(test.StartBlockNumber, out _); for (int i = 0; i < test.Current.NumberOfSteps; i++) { var blockNumber = test.Current.BlockNumber + i; if (test.TryDoReorganisations(blockNumber, out var lastChain)) { ValidateFinalizationForChain(lastChain); i = 0; blockNumber = test.Current.BlockNumber + i; } _block.Number = blockNumber; _block.Beneficiary = currentValidators[i % currentValidators.Length]; var txReceipts = test.GetReceipts(_block, _contractAddress, _abiEncoder, SetupAbiAddresses); _block.Bloom = new Bloom(txReceipts.SelectMany(r => r.Logs).ToArray()); validator.PreProcess(_block); validator.PostProcess(_block, txReceipts); currentValidators = test.GetCurrentValidators(blockNumber); var nextValidators = test.GetNextValidators(blockNumber); currentValidators.Select(a => validator.IsValidSealer(a)).Should().AllBeEquivalentTo(true, $"Validator address is not recognized in block {blockNumber}"); nextValidators?.Except(currentValidators).Select(a => validator.IsValidSealer(a)).Should().AllBeEquivalentTo(false); } ValidateFinalizationForChain(test.Current); }
/// <summary> /// Registers the contract. /// </summary> /// <param name="contractType">Type of the contract.</param> /// <param name="defaultImplementationType">Default type of the implementation.</param> public static void RegisterContract(Type contractType, Type defaultImplementationType) { DoInitializeCheck(); if (contractType == null) { ThrowHelper.ThrowArgumentNullException("contractType"); } ContractValidator.ValidateContractIntegrity(contractType); if (defaultImplementationType != null) { ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType); } lock (mContractDescriptors) { if (mContractDescriptors.ContainsKey(contractType)) { ThrowHelper.ThrowArgumentException("Contract type has already registered."); } mContractDescriptors.Add(contractType, new ContractServiceSideDescriptor(contractType, defaultImplementationType)); } }
/// <summary> /// Prevents a default instance of the <see cref="ServiceFactory<TContract>"/> class from being created. /// </summary> /// <param name="channelId">The channel id.</param> /// <param name="implementationType">Type of the implementation.</param> private ServiceFactory(String channelId, Type implementationType) { if (string.IsNullOrEmpty(channelId)) { ThrowHelper.ThrowArgumentNullException("channelId"); } if (implementationType == null) { ThrowHelper.ThrowArgumentNullException("implementationType"); } if (!ServiceContract.IsAssignableFrom(implementationType)) { throw new ArgumentException("Provided implementation does not implements the contract interface.", "implementationType"); } ContractValidator.ValidateContractIntegrity(ServiceContract); ImplementationValidator.ValidateImplementationIntegrity(implementationType); this.mChannel = ChannelServices.GetChannelById(channelId); if (this.mChannel == null) { throw new ChannelNotFoundException(channelId); } this.mImplementationType = implementationType; // adatstruktúra adminisztrációja // egy factory csak azt adhatja hozzá, ami nincs és csak azt veheti el, ami még nem volt. ContractServiceSideDescriptor descriptor = null; Dictionary <Type, ContractServiceSideDescriptor> contractDescriptors = ServiceBaseServices.ContractDescriptors; lock (contractDescriptors) { if (contractDescriptors.ContainsKey(ServiceContract)) { // ismert contract descriptor = contractDescriptors[ServiceContract]; } else { // ilyen contract még nincs mControlServiceContract = true; mControlChannel = true; } } if (descriptor != null) { lock (descriptor) { if (!descriptor.ImplementationPerChannel.ContainsKey(channelId)) { mControlChannel = true; } else { if (descriptor.ImplementationPerChannel.ContainsKey(channelId)) { // ehhez a csatornához és contracthoz már egy másik implementáció van rendelve Type currentImplType = descriptor.ImplementationPerChannel[channelId]; if (!currentImplType.Equals(implementationType)) { throw new ArgumentException(String.Format("Unable to register provided implementation type: '{0}'. An other implementation type '{1}' has already definied for channel '{2}' and contract '{3}'.", implementationType.FullName, currentImplType.FullName, channelId, ServiceContract.FullName)); } } } } } ChannelServices.UnregisterChannelEvent += new EventHandler <ChannelRegistrationEventArgs>(ChannelUnregisteredEventHandler); }
public void ContractIdIsEmptyString() { var result = ContractValidator.ContractId(""); Assert.AreEqual(0, result); }
public void ContractIdIsNotEmptyOrNull() { var result = ContractValidator.ContractId("002ddd"); Assert.AreEqual(0, result); }
public void ValidEndDate() { var result = ContractValidator.EndDate("2016-02-01"); Assert.AreEqual(new DateTime(2016, 02, 01), result); }
public void EndDateUnknownCharacters() { var result = ContractValidator.EndDate("hai*"); Assert.AreEqual(new DateTime(0001, 01, 01), result); }
public void ValidContractId() { var result = ContractValidator.ContractId("10"); Assert.AreEqual(10, result); }
/// <summary> /// Channels the receive message event handler. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="Forge.Net.Remoting.Channels.ReceiveMessageEventArgs"/> instance containing the event data.</param> protected override void ChannelReceiveMessageEventHandler(object sender, ReceiveMessageEventArgs e) { if (LOGGER.IsDebugEnabled) { LOGGER.Debug(string.Format("Executing service method. SessionId: '{0}', {1}", e.SessionId, e.Message.ToString())); } Channel channel = (Channel)sender; String sessionId = e.SessionId; IMessage message = e.Message; // Request és response message type jöhet // Request mode // Response mode // Datagram mode - nincs válasz if (message.MessageType == MessageTypeEnum.Acknowledge || message.MessageType == MessageTypeEnum.Response) { // HIBA: nem megfelelő üzenet típus (implementációs hiba?) String errorMsg = String.Format("Invalid message type received: {0}. This may be an implementation error in the client proxy.", message.MessageType); if (LOGGER.IsErrorEnabled) { LOGGER.Error(errorMsg); } } else { RequestMessage rm = (RequestMessage)message; if (MessageInvokeModeEnum.RequestCallback.Equals(rm.MessageInvokeMode)) { return; } String contractName = rm.ContractName; Type contractType = null; try { contractType = TypeHelper.GetTypeFromString(contractName); } catch (Exception ex) { // HIBA: ez a típus nem szerepel a ClassPath-ban try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to resolve this type of contract '{0}'. Type has not found.", rm.ContractName), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } ContractServiceSideDescriptor descriptor = null; lock (mContractDescriptors) { if (mContractDescriptors.ContainsKey(contractType)) { descriptor = mContractDescriptors[contractType]; } else { // HIBA: ez a contract nincs nyilvántartva try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("This type of contract '{0}' has not been registered.", contractType.FullName)), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } } Type implType = null; lock (descriptor) { if (descriptor.ImplementationPerChannel.ContainsKey(channel.ChannelId)) { implType = descriptor.ImplementationPerChannel[channel.ChannelId]; } else if (descriptor.DefaultImplementationType != null) { implType = descriptor.DefaultImplementationType; } else { // HIBA: a contract a megadott channel-hez nem definiált implementációs típust try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to find implementation for this type of contract '{0}' and channel id: '{1}'.", contractType.FullName, channel.ChannelId)), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } } Object instance = null; WellKnownObjectModeEnum objectMode = WellKnownObjectModeEnum.PerSession; ContractValidator.GetWellKnownObjectMode(contractType, out objectMode); if (objectMode == WellKnownObjectModeEnum.PerSession) { // constructor keresése a Channel és String paraméterlistával, ha még ehhez a session-hez nem létezik instance long proxyId = -1; try { proxyId = (long)rm.Context[ProxyBase.PROXY_ID]; } catch (Exception ex) { // HIBA: hiányzó vagy rossz formátumú ProxyId try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException("Unable to parse PROXY_ID from call context.", ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } lock (mContractAndInstancePerSessionAndChannel) { foreach (ContractAndInstanceStruct s in mContractAndInstancePerSessionAndChannel) { if (s.Channel.Equals(channel) && s.ContractType.Equals(contractType) && s.SessionId.Equals(sessionId) && s.ImplType.Equals(implType) && s.ProxyId == proxyId) { instance = s.Instance; break; } } if (instance == null) { // még nem létezik a proxy példány, létre kell hozni try { ConstructorInfo c = implType.GetConstructor(new Type[] { typeof(Channel), typeof(String) }); instance = c.Invoke(new object[] { channel, sessionId }); RegisterProxy(channel, contractType, implType, sessionId, proxyId, (ProxyBase)instance); } catch (Exception ex) { // HIBA: sikertelen az instance létrehozása try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to instantiate type '{0}'. Public constructor is not accessible/found with parameter types: '{1}' and '{2}'.", implType.FullName, typeof(Channel).FullName, typeof(String).FullName), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } } } } else if (objectMode == WellKnownObjectModeEnum.Singleton) { // üres constructor kell, ha még nem létezik az instance lock (mSingletonContainer) { if (mSingletonContainer.ContainsKey(implType)) { instance = mSingletonContainer[implType]; } else { try { // még nem volt létrehozva instance = implType.GetConstructor(new Type[] { }).Invoke(null); mSingletonContainer.Add(implType, instance); } catch (Exception ex) { // HIBA: sikertelen az instance létrehozása try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to instantiate type '{0}'. Public empty constructor is not accessible/found.", implType.FullName), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } } } } else { // üres constructor kell, példányosítás mindig megtörténik try { // még nem volt létrehozva instance = implType.GetConstructor(new Type[] { }).Invoke(null); } catch (Exception ex) { // HIBA: sikertelen az instance létrehozása try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to instantiate type '{0}'. Public empty constructor is not accessible/found.", implType.FullName), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } } // meg van az instance, lehet reflection-nel hívni a metódusára Type[] methodParamTypes = null; Object[] paramValues = null; if (rm.MethodParameters != null) { methodParamTypes = new Type[rm.MethodParameters.Length]; paramValues = new Object[rm.MethodParameters.Length]; for (int i = 0; i < rm.MethodParameters.Length; i++) { try { methodParamTypes[i] = TypeHelper.GetTypeFromString(rm.MethodParameters[i].ClassName); } catch (Exception ex) { // HIBA: a paraméter egy típusa nem szerepel a Domainben, így nem feloldható, ismeretlen try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to resolve parameter type '{0}'. Type has not found.", rm.MethodParameters[i].ClassName), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } paramValues[i] = rm.MethodParameters[i].Value; } } MethodInfo m = null; try { m = FindMethod(implType, rm.MethodName, methodParamTypes); } catch (Exception ex) { // HIBA: a metódus név és paraméterlista alapján nem található try { SendResponse(channel, sessionId, rm, typeof(void), null, new MethodInvocationException(String.Format("Unable to find method '{0}' with parameter list: '{1}'.", rm.MethodName, methodParamTypes), ex), channel.DefaultErrorResponseTimeout); } catch (Exception innerEx) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, innerEx.Message)); } } return; } long returnTimeout = OperationContractAttribute.DEFAULT_METHOD_TIMEOUT; if (rm.MessageType == MessageTypeEnum.Request) { MethodParameter[] mps = null; if (m.GetParameters().Length > 0) { mps = new MethodParameter[m.GetParameters().Length]; for (int i = 0; i < m.GetParameters().Length; i++) { ParameterInfo pi = m.GetParameters()[i]; mps[i] = new MethodParameter(i, string.Format("{0}, {1}", pi.ParameterType.FullName, new AssemblyName(pi.ParameterType.Assembly.FullName).Name), null); } } returnTimeout = ServiceBase.GetTimeoutByMethod(contractType, m.Name, mps, MethodTimeoutEnum.ReturnTimeout); lock (mCallContextForReply) { mCallContextForReply.Add(Thread.CurrentThread, new CallContextForReply(channel, sessionId, rm, m.ReturnType, returnTimeout)); } } // visszatérési értéket fogadni Exception methodException = null; Object result = null; try { result = m.Invoke(instance, paramValues); } catch (Exception ex) { if (LOGGER.IsDebugEnabled) { LOGGER.Debug(string.Format("Service method threw an exception. SessionId: '{0}', {1}", e.SessionId, e.Message.ToString()), ex); } methodException = ex; } // válaszüzenet küldése bool needToSendResponse = false; Type returnType = typeof(void); if (rm.MessageType == MessageTypeEnum.Request) { lock (mCallContextForReply) { if (mCallContextForReply.ContainsKey(Thread.CurrentThread)) { needToSendResponse = true; returnType = mCallContextForReply[Thread.CurrentThread].ReturnType; } } } if (needToSendResponse) { try { SendResponse(channel, sessionId, rm, returnType, result, methodException, returnTimeout); } catch (Exception ex) { // válaszüzenet küldése sikertelen if (LOGGER.IsErrorEnabled) { LOGGER.Error(String.Format(AUTO_SEND_REPLY_ERROR_MSG, ex.Message)); } } finally { lock (mCallContextForReply) { mCallContextForReply.Remove(Thread.CurrentThread); } } } // saját tulajdonú instance, ami implementálja az IDisposable interface-t és SingleCall, akkor ráhívok a Dispose() metódusra if (objectMode == WellKnownObjectModeEnum.SingleCall && instance is IDisposable) { ((IDisposable)instance).Dispose(); } } }
public static void Initialize() { if (!mInitialized) { Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.Before) }); ChannelServices.Initialize(); if (LOGGER.IsInfoEnabled) { LOGGER.Info("Initializing ServiceBase services."); } CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, "Services"); if (pi != null) { IEnumerator <CategoryPropertyItem> iterator = pi.GetEnumerator(); try { while (iterator.MoveNext()) { pi = iterator.Current; if (string.IsNullOrEmpty(pi.Id)) { throw new InvalidConfigurationException("Contract type not definied. Empty item found in configuration."); } Type contractType = null; Type defaultImplementationType = null; try { contractType = TypeHelper.GetTypeFromString(pi.Id); if (ContractDescriptors.ContainsKey(contractType)) { throw new InvalidConfigurationException(String.Format("Duplicated contract type configuration found in services. Contract: {0}", contractType.FullName)); } ContractValidator.ValidateContractIntegrity(contractType); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve contract type: {0}", pi.Id), ex); } if (!string.IsNullOrEmpty(pi.EntryValue)) { try { defaultImplementationType = TypeHelper.GetTypeFromString(pi.EntryValue); if (!contractType.IsAssignableFrom(defaultImplementationType)) { throw new InvalidProxyImplementationException(String.Format("Provided default implementation type '{0}' does not implement contract interface '{1}'.", defaultImplementationType.FullName, contractType.FullName)); } ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve implementation type: {0}", pi.EntryValue), ex); } } ContractServiceSideDescriptor descriptor = new ContractServiceSideDescriptor(contractType, defaultImplementationType); IEnumerator <CategoryPropertyItem> channelIterator = pi.GetEnumerator(); while (channelIterator.MoveNext()) { CategoryPropertyItem channelImplementationItem = channelIterator.Current; if (string.IsNullOrEmpty(channelImplementationItem.Id)) { throw new InvalidConfigurationValueException(String.Format("Channel identifier is missing from a configuration item of the contract '{0}'", pi.Id)); } if (string.IsNullOrEmpty(channelImplementationItem.EntryValue)) { throw new InvalidConfigurationValueException(String.Format("Implementation type is missing from a configuration item of the contract '{0}'", pi.Id)); } if (!ChannelServices.IsChannelRegistered(channelImplementationItem.Id)) { throw new InvalidConfigurationValueException(String.Format("Unregistered channel provided '{0}' in configuration section of the contract: {1}.", channelImplementationItem.Id, pi.Id)); } Type type = null; try { type = TypeHelper.GetTypeFromString(channelImplementationItem.EntryValue); if (!contractType.IsAssignableFrom(type)) { throw new InvalidProxyImplementationException(String.Format("Provided implementation type '{0}' does not implement contract interface '{1}'.", type.FullName, contractType.FullName)); } ImplementationValidator.ValidateImplementationIntegrity(type); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve non-default implementation type: {0} for contract: {1} for the channel: {2}", channelImplementationItem.EntryValue, pi.Id, channelImplementationItem.Id), ex); } if (descriptor.ImplementationPerChannel.ContainsKey(channelImplementationItem.Id)) { throw new InvalidConfigurationException(String.Format("Duplicated channel identifier at contract '{0}'.", pi.Id)); } descriptor.ImplementationPerChannel.Add(channelImplementationItem.Id, type); } ContractDescriptors.Add(contractType, descriptor); } ChannelServices.StartListeningChannels(); } catch (Exception ex) { ContractDescriptors.Clear(); throw ex; } } mInitialized = true; if (LOGGER.IsInfoEnabled) { LOGGER.Info("ServiceBase services successfully initialized."); } Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.After) }); } }