private Func<RogerEndpoint, IBasicProperties> CreatePropertiesFactory(IModel model,
IIdGenerator idGenerator,
IMessageTypeResolver messageTypeResolver,
IMessageSerializer serializer,
ISequenceGenerator sequenceGenerator)
{
var properties = model.CreateBasicProperties();
properties.MessageId = idGenerator.Next();
properties.Type = messageTypeResolver.Unresolve(messageType);
properties.ContentType = serializer.ContentType;
properties.Headers = new Hashtable
{
{Headers.Sequence, BitConverter.GetBytes(sequenceGenerator.Next(messageType))}
};
if (persistent)
properties.DeliveryMode = 2;
FillAdditionalProperties(properties, idGenerator);
return endpoint =>
{
properties.ReplyTo = endpoint;
return properties;
};
}
public IDelivery Create(IModel model,
IIdGenerator idGenerator,
IMessageTypeResolver messageTypeResolver,
IMessageSerializer serializer,
ISequenceGenerator sequenceGenerator)
{
return inner;
}
public ReceiverStmContext(ILink link, IChecksum cheksum, ISequenceGenerator sequenceGenerator,
int maxMessageDataSize)
{
_message = new Message(maxMessageDataSize);
_reply = new Message(0);
_link = link;
_sequence = sequenceGenerator;
_checksum = cheksum;
SetState(new MissingSync());
}
public SenderStmContext(ILink link, IChecksum checksum, ISequenceGenerator sequenceGenerator, int maxMessageDataSize, int timeoutModifier)
{
_checksum = checksum;
_timeout = link.Timeout * timeoutModifier;
_timer = new Timer(MessageTimeout);
_link = link;
_maxMessageDataSize = maxMessageDataSize;
_message = new Message(_maxMessageDataSize);
_reply = new Message(0);
_sequence = sequenceGenerator;
SetState(new Sending());
}
private SequenceGenerator()
{
try
{
if (AppRuntime.Instance.CurrentApp == null)
{
throw new EagleAppException("The application has not been initialized and started yet.");
}
if (AppRuntime.Instance.CurrentApp.ConfigSource == null ||
AppRuntime.Instance.CurrentApp.ConfigSource.Config == null ||
AppRuntime.Instance.CurrentApp.ConfigSource.Config.Generators == null ||
AppRuntime.Instance.CurrentApp.ConfigSource.Config.Generators.SequenceGenerator == null ||
string.IsNullOrEmpty(AppRuntime.Instance.CurrentApp.ConfigSource.Config.Generators.SequenceGenerator.Provider))
{
generator = new SequentialIdentityGenerator();
}
else
{
Type type = Type.GetType(AppRuntime.Instance.CurrentApp.ConfigSource.Config.Generators.SequenceGenerator.Provider);
if (type == null)
{
throw new ConfigException(string.Format("Unable to create the type from the name {0}.", AppRuntime.Instance.CurrentApp.ConfigSource.Config.Generators.SequenceGenerator.Provider));
}
if (type.Equals(this.GetType()))
{
throw new EagleAppException("Type {0} cannot be used as sequence generator, it is maintained by the Eagle framework internally.", this.GetType().AssemblyQualifiedName);
}
generator = (ISequenceGenerator)Activator.CreateInstance(type);
}
}
catch (ConfigurationErrorsException)
{
throw;
}
catch (Exception ex)
{
throw new EagleAppException();
}
}
public SecureClient(ILoggerFactory loggerFactory, ISerializer serializer, IOrderingService orderingService,
CancellationToken cancellationToken, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, ServerCertificateValidationCallback serverCertificateValidationCallback, SslProtocols sslProtocols,
X509CertificateCollection clientCertificateCollection, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
this.serverCertificateValidationCallback = serverCertificateValidationCallback;
this.sslProtocols = sslProtocols;
this.clientCertificateCollection = clientCertificateCollection;
Init(loggerFactory, serializer, orderingService, cancellationToken,
sendIdempotencyService, receiveIdempotencyService, delaySequenceGenerator,
millisecondsIntervalForPacketResend, keepAliveTimeOut, maximumNumberOfKeepAliveMisses, keepAliveResponseTimeOut);
}
public void Setup()
{
_sequenceGenerator = Substitute.For <ISequenceGenerator>();
_sequenceCalculatorService = new SequenceCalculatorService(_sequenceGenerator);
}
public EmailService(MerlinWriteContext writeContext, ISequenceGenerator sequenceGenerator)
{
this.writeContext = writeContext;
this.sequenceGenerator = sequenceGenerator;
}
public RandomizeForce(ISequenceGenerator generator)
{
Generator = generator;
}
public AccountRepository(PeopleDbContext dbContext, IMediator mediator, ISequenceGenerator generator)
{
_dbContext = dbContext;
_mediator = mediator;
_generator = generator;
}
public StatsDataGenerator(ISequenceGenerator generator)
{
Generator = generator;
}
/// <summary>
/// IOC injection by constructor
/// </summary>
/// <param name="sequenceGenerator"></param>
public SequenceController(ISequenceGenerator sequenceGenerator)
{
SequenceGenerator = sequenceGenerator;
}
public SecureServer(ILoggerFactory loggerFactory, ISerializer serializer, IOrderingService orderingService,
CancellationToken cancellationToken, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, X509Certificate serverCertificate, bool clientCertificateRequired,
SslProtocols sslProtocols, ClientCertificateValidationCallback clientCertificateValidationCallback, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
Init(loggerFactory, serializer, orderingService,
sendIdempotencyService, receiveIdempotencyService,
delaySequenceGenerator, millisecondsIntervalForPacketResend, cancellationToken, keepAliveTimeOut,
maximumNumberOfKeepAliveMisses, keepAliveResponseTimeOut);
this.serverCertificate = serverCertificate;
this.clientCertificateRequired = clientCertificateRequired;
this.sslProtocols = sslProtocols;
this.clientCertificateValidationCallback = clientCertificateValidationCallback;
if (this.loggerFactory != null)
{
logger = this.loggerFactory.CreateLogger <SecureServer>();
}
}
public DefaultColumn(string attributeName, string columnName, bool key, bool nullable, ColumnType type,
int size, bool readFromSequence, ISequenceGenerator generator)
: base(attributeName, columnName, key, nullable, type, size, readFromSequence, generator)
{
}
public QuestionService(MerlinWriteContext writeContext, IConfiguration config, ISequenceGenerator sequenceGenerator)
{
this.writeContext = writeContext;
this.config = config;
this.sequenceGenerator = sequenceGenerator;
}
public IDelivery Create(IModel model, IIdGenerator idGenerator, IMessageTypeResolver messageTypeResolver, IMessageSerializer serializer, ISequenceGenerator sequenceGenerator)
{
var createProperties = CreatePropertiesFactory(model, idGenerator, messageTypeResolver, serializer, sequenceGenerator);
return(CreateCore(createProperties));
}
public InsecureServerBuilder WithSequenceGenerator(ISequenceGenerator delaySequenceGenerator)
{
this.delaySequenceGenerator = delaySequenceGenerator;
return(this);
}
public StatisticsCreator(ISequenceGenerator sequenceGenerator)
{
_sequenceGenerator = sequenceGenerator;
}
public PhysicsDataGenerator(ISequenceGenerator generator)
{
Generator = generator;
}
protected AbstractColumn(String attributeName, string columnName, bool key, ColumnType type,
bool readFromSequence, ISequenceGenerator generator)
: this(attributeName, columnName, key, false, type, 20, readFromSequence, generator)
{
}
private SequenceGenerator()
{
this.generator = new SequentialIdentityGenerator();
}
public InsecureServer(ILoggerFactory loggerFactory, ISerializer serializer, IOrderingService orderingService,
CancellationToken cancellationToken, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
Init(loggerFactory, serializer, orderingService,
sendIdempotencyService, receiveIdempotencyService,
delaySequenceGenerator, millisecondsIntervalForPacketResend, cancellationToken, keepAliveTimeOut,
maximumNumberOfKeepAliveMisses, keepAliveResponseTimeOut);
if (this.loggerFactory != null)
{
logger = this.loggerFactory.CreateLogger <InsecureServer>();
}
}
protected void Init(ILoggerFactory loggerFactory, ISerializer serializer, IOrderingService orderingService,
CancellationToken cancellationToken, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
id = Guid.NewGuid().ToString();
LoggerFactory = loggerFactory;
this.sendIdempotencyService = sendIdempotencyService;
this.receiveIdempotencyService = receiveIdempotencyService;
CancellationToken = cancellationToken;
this.millisecondsIntervalForPacketResend = millisecondsIntervalForPacketResend;
this.serializer = serializer;
this.orderingService = orderingService;
this.delaySequenceGenerator = delaySequenceGenerator;
this.keepAliveResponseTimeOut = keepAliveResponseTimeOut;
this.keepAliveTimeOut = keepAliveTimeOut;
this.maximumNumberOfKeepAliveMisses = maximumNumberOfKeepAliveMisses;
CancellationToken.Register(() => Cancel());
if (LoggerFactory != null)
{
logger = loggerFactory.CreateLogger(GetType());
}
}
public ChangeTracking(ISequenceGenerator sequenceGenerator = null)
{
this.SequenceGenerator = sequenceGenerator ?? new DefaultSequenceGenerator();
}
public static void Parse(
string[] args,
out ISequenceGenerator sequenceGenerator,
out int boundaryValue,
out int?startValue)
{
if (args.Length < (int)ArgumentsCount.Minimum)
{
throw new ArgumentException("You do not have enough arguments! "
+ "Please, enter the correct number of arguments!");
}
if (args.Length > (int)ArgumentsCount.Maximum)
{
throw new ArgumentException("You have too many arguments! "
+ "Please, enter the correct number of arguments!");
}
string sequenceGeneratorType = args[0].ToLower();
switch (sequenceGeneratorType)
{
case "fibonacci":
sequenceGenerator = new FibonacciSequenceGenerator();
break;
case "squarelessn":
sequenceGenerator = new SquareLessNSequenceGenerator();
break;
default:
throw new ArgumentException("Please, enter correct algorithm "
+ "for searching the sequence");
}
if (!int.TryParse(args[1], out boundaryValue))
{
throw new ArgumentException("The second argument is not a number or is a too big number!");
}
startValue = null;
if (args.Length == (int)ArgumentsCount.Maximum)
{
int thirdArgument;
if (!int.TryParse(args[2], out thirdArgument))
{
throw new ArgumentException("The third argument is not a number!");
}
else
{
startValue = thirdArgument;
if (startValue - boundaryValue > 0)
{
throw new ArgumentException("The third argument (boundary value) can not be "
+ "bigger than second (start value)! Please, check your arguments!");
}
if (startValue < 0 || boundaryValue < 0)
{
throw new ArgumentException("Arguments can not be negative!");
}
}
}
}
internal TrackedEntity(Type entityType, ISequenceGenerator sequenceGenerator, string keyName)
{
this.EntityType = entityType;
this.sequenceGenerator = sequenceGenerator;
this.KeyName = keyName;
}
public ClassUnderTest(ISomeInterface dep, ISequenceGenerator generator)
{
_dep = dep;
_generator = generator;
}
private SequenceGenerator()
{
this.generator = new SequentialIdentityGenerator();
}
public SequenceCalculatorService(ISequenceGenerator sequenceGenerator)
{
_sequenceGenerator = sequenceGenerator;
}
public IDelivery Create(IModel model, IIdGenerator idGenerator, IMessageTypeResolver messageTypeResolver, IMessageSerializer serializer, ISequenceGenerator sequenceGenerator)
{
var createProperties = CreatePropertiesFactory(model, idGenerator, messageTypeResolver, serializer, sequenceGenerator);
return CreateCore(createProperties);
}
public AccountRepository(IDbContextProvider <AccountManageDbContext> dbContextProvider, ISequenceGenerator sequenceGenerator)
: base(dbContextProvider)
{
_sequenceGenerator = sequenceGenerator;
}
public SecureClientBuilder WithSequenceGenerator(ISequenceGenerator delaySequenceGenerator)
{
this.delaySequenceGenerator = delaySequenceGenerator;
return(this);
}
internal SecureClient(TlsNetworkTransport tlsNetworkTransport, ILoggerFactory loggerFactory, ISerializer serializer, IOrderingService orderingService,
CancellationToken cancellationToken, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
Init(loggerFactory, serializer, orderingService, cancellationToken,
sendIdempotencyService, receiveIdempotencyService, delaySequenceGenerator,
millisecondsIntervalForPacketResend, tlsNetworkTransport, keepAliveTimeOut,
maximumNumberOfKeepAliveMisses, keepAliveResponseTimeOut);
}
protected void Init(ILoggerFactory loggerFactory, ISerializer serializer,
IOrderingService orderingService, ISendIdempotencyService <Guid, Packet> sendIdempotencyService,
IReceiveIdempotencyService <string> receiveIdempotencyService, ISequenceGenerator delaySequenceGenerator,
int millisecondsIntervalForPacketResend, CancellationToken cancellationToken, int keepAliveTimeOut,
int maximumNumberOfKeepAliveMisses, int keepAliveResponseTimeOut)
{
Id = Guid.NewGuid().ToString();
this.loggerFactory = loggerFactory;
this.serializer = serializer;
this.orderingService = orderingService;
this.cancellationToken = cancellationToken;
this.sendIdempotencyService = sendIdempotencyService;
this.receiveIdempotencyService = receiveIdempotencyService;
this.delaySequenceGenerator = delaySequenceGenerator;
this.millisecondsIntervalForPacketResend = millisecondsIntervalForPacketResend;
this.keepAliveTimeOut = keepAliveTimeOut;
this.maximumNumberOfKeepAliveMisses = maximumNumberOfKeepAliveMisses;
this.keepAliveResponseTimeOut = keepAliveResponseTimeOut;
clients = new ConcurrentDictionary <string, IClient>();
}
public ConsecutiveSequenceController(ParentTypeFetcher <TObjType> fetchParent,
ISequenceGenerator <TSeqType> generator)
{
_fetchParent = fetchParent;
_generator = generator;
}
public SequenceController(ISequenceGenerator[] generator)
{
_generator = generator;
}
