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) });
}
}
