public StoringEventSenderProxy(
IEventSender eventSender,
IStorage <IList <Event> > storage)
{
_eventSender = eventSender;
_storage = storage;
}
public void Work()
{
var flow = FakeService.GetFlow();
this.EventSender.SendEvent(flow);
this.EventSender = this.EventSender.Open();
}
public ObjectEventsProcessingJob(
ILogger <ObjectEventsProcessingJob> logger,
IObjectsStorageReader objectsStorageReaderForVersions,
IObjectsStorageReader objectsStorageReaderForBinaries,
KafkaOptions kafkaOptions,
IEventSender eventSender)
{
_objectVersionsTopic = kafkaOptions.ObjectVersionsTopic;
_binariesUsingsTopic = kafkaOptions.BinariesReferencesTopic;
_logger = logger;
_objectsStorageReaderForVersions = objectsStorageReaderForVersions;
_objectsStorageReaderForBinaries = objectsStorageReaderForBinaries;
_eventSender = eventSender;
_versionEventReceiver = new EventReceiver(
logger,
kafkaOptions,
$"{VersionsGroupId}-{kafkaOptions.ConsumerGroupToken}",
new[] { kafkaOptions.ObjectEventsTopic });
_binariesEventReceiver = new EventReceiver(
logger,
kafkaOptions,
$"{BinariesGroupId}-{kafkaOptions.ConsumerGroupToken}",
new[] { kafkaOptions.ObjectEventsTopic });
}
// Token: 0x060000FA RID: 250 RVA: 0x00004D7A File Offset: 0x00002F7A
internal Thread(Process process, long id, IEventSender eventSender)
{
this.Process = process;
this.ID = id;
this.IsAlive = true;
this.eventSender = eventSender;
}
public async Task <Book> AddBook(AddBookInput book, [Service] IEventSender eventSender)
{
var newBook = _bookService.Add(book);
await eventSender.SendAsync(new OnBookAddedMessage(newBook));
return(newBook);
}
/// <summary>Parameterized constructor.
/// </summary>
/// <param name="processingCommandCache"></param>
/// <param name="commandAsyncResultManager"></param>
/// <param name="commandHandlerProvider"></param>
/// <param name="aggregateRootTypeProvider"></param>
/// <param name="eventSender"></param>
/// <param name="retryService"></param>
/// <param name="commandContext"></param>
/// <param name="loggerFactory"></param>
/// <exception cref="Exception"></exception>
public DefaultCommandExecutor(
IProcessingCommandCache processingCommandCache,
ICommandAsyncResultManager commandAsyncResultManager,
ICommandHandlerProvider commandHandlerProvider,
IAggregateRootTypeProvider aggregateRootTypeProvider,
IEventSender eventSender,
IRetryService retryService,
ICommandContext commandContext,
ILoggerFactory loggerFactory)
{
_processingCommandCache = processingCommandCache;
_commandAsyncResultManager = commandAsyncResultManager;
_commandHandlerProvider = commandHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_eventSender = eventSender;
_retryService = retryService;
_commandContext = commandContext;
_trackingContext = commandContext as ITrackingContext;
_logger = loggerFactory.Create(GetType().Name);
if (_trackingContext == null)
{
throw new Exception("Command context must also implement ITrackingContext interface.");
}
}
public EventSource(IEventSender eventSender, IEventStore eventStore, ISnapshotManager snapshotManager, IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
this.eventSender = eventSender;
this.eventStore = eventStore;
this.snapshotManager = snapshotManager;
}
public async Task <bool> UploadData(
[GraphQLNonNullType] UploadDataInput input,
[Service] IUploadDataRepository repo,
[Service] IEventSender eventSender
)
{
try
{
var dataobj = repo.UploadData(input.encodedData, input.encodedConfig);
foreach (var sensorId in dataobj.sensorIds)
{
await eventSender.SendAsync(new OnDataInsert(
sensorId,
new CreatedDataValues()
{
sensorId = sensorId,
fromDate = dataobj.fromDate,
toDate = dataobj.toDate
}
)).ConfigureAwait(true);
}
return(true);
} catch
{
throw new QueryException(ErrorBuilder.New().SetMessage("There occured an error with either with encoded file string or the parser type given.").Build());
}
}
public async Task <Recipe> InsertRecipe(
[Service] IMutationService mutationService,
[Service] IEventSender eventSender,
InsertRecipeInput recipeInput)
{
return(await mutationService.InsertRecipe(recipeInput, eventSender));
}
public RedisIntegrationTests(RedisResource redisResource)
{
_connection = redisResource.GetConnection();
_sender = new RedisEventRegistry(
_connection,
new JsonPayloadSerializer());
}
public async Task <Review> CreateReview(Episode episode, Review review, [Service] IEventSender eventSender)
{
_repository.AddReview(episode, review);
await eventSender.SendAsync(new OnReviewMessage(episode, review));
return(review);
}
public RedisTests()
{
string endpoint =
Environment.GetEnvironmentVariable("REDIS_ENDPOINT")
?? "localhost:6379";
string password =
Environment.GetEnvironmentVariable("REDIS_PASSWORD");
var configuration = new ConfigurationOptions
{
Ssl = true,
AbortOnConnectFail = false,
Password = password
};
configuration.EndPoints.Add(endpoint);
var redisEventRegistry = new RedisEventRegistry(
ConnectionMultiplexer.Connect(configuration),
new JsonPayloadSerializer());
_sender = redisEventRegistry;
_registry = redisEventRegistry;
}
public Heartbeat(HeartbeatIntervalSetting heartbeatInterval, IClock clock, IEventSender eventSender, ILogger logger)
{
_heartbeatInterval = heartbeatInterval;
_eventSender = eventSender;
_logger = logger;
_clock = clock;
}
public void Invoke(IEventSender sender, XEvent ev)
{
foreach (IEventListener listener in listeners)
{
method.Invoke(listener, new object[] { sender, ev });
}
}
public void OnEnemyShipDeath(IEventSender sender, EnemyShipDeathEvent ev)
{
if (ev.ship == finalShip)
{
this.Send(new GameWonEvent());
}
}
private void SetupLoop(IEventSender eventSender)
{
var renderLoopDispatcher = di.Get <IRenderLoopDispatcher>();
var inputProviders = di.GetMulti <IUcInputProvider>();
eventSender.OnGUIEvent += () =>
{
foreach (var inputProvider in inputProviders)
{
inputProvider.OnGui();
}
};
eventSender.UpdateEvent += () =>
{
renderControl.OnUpdate();
foreach (var inputProvider in inputProviders)
{
inputProvider.OnUpdate();
}
var frameTime = new FrameTime(Time.realtimeSinceStartup, Time.deltaTime);
eventRoutingService.FireEvent <INewFrameEvent>(new NewFrameEvent(frameTime));
// todo: remove this
renderLoopDispatcher.OnLoop(frameTime);
};
eventSender.LateUpdateEvent += () =>
{
var frameTime = new FrameTime(Time.realtimeSinceStartup, Time.deltaTime);
eventRoutingService.FireEvent <ILateUpdateEvent>(new LateUpdateEvent(frameTime));
};
eventSender.FixedUpdateEvent += () =>
{
eventRoutingService.FireEvent <IFixedUpdateEvent>(new FixedUpdateEvent());
};
}
public LoansProvider(IEventSender eventSender)
{
var firstCustomerId = "2516e61e-8da9-4a22-9a70-f8b9c01bacca";
var firstLoan = new Loan()
{
CustomerId = firstCustomerId,
DailyRate = 5,
ProductId = "Home Solar System Energy Plus",
ShopId = "4 Privet Drive",
TotalLoanAmount = 200,
TotalLoanPayed = 100,
CreationDate = DateTime.UtcNow.AddDays(-3),
};
var secondCustomerId = "00999b75-6924-47d4-b9e9-a8a0b25ae8d6";
var secondLoan = new Loan()
{
CustomerId = secondCustomerId,
DailyRate = 70,
ProductId = "Home Solar System 2000+",
ShopId = "Diagon Alley",
TotalLoanAmount = 7000,
TotalLoanPayed = 7000,
CreationDate = DateTime.UtcNow.AddDays(-10),
};
_loans = new Dictionary <string, Loan>
{
{ firstLoan.CustomerId, firstLoan },
{ secondLoan.CustomerId, secondLoan }
};
_eventSender = eventSender;
}
public SearchController(ISearch search, ISecurityContext securityContext, IEventSender eventSender)
: base(securityContext)
{
this.Search = search;
this.SecurityContext = securityContext;
this.EventSender = eventSender;
}
internal EventProcessorInternal(
EventsConfiguration config,
BlockingCollection <IEventMessage> messageQueue,
IEventSender eventSender,
IUserDeduplicator userDeduplicator,
IDiagnosticStore diagnosticStore,
Logger logger,
Action testActionOnDiagnosticSend
)
{
_config = config;
_diagnosticStore = diagnosticStore;
_userDeduplicator = userDeduplicator;
_testActionOnDiagnosticSend = testActionOnDiagnosticSend;
_flushWorkersCounter = new CountdownEvent(1);
_eventSender = eventSender;
_logger = logger;
_random = new Random();
EventBuffer buffer = new EventBuffer(config.EventCapacity > 0 ? config.EventCapacity : 1, _diagnosticStore, _logger);
// Here we use TaskFactory.StartNew instead of Task.Run() because that allows us to specify the
// LongRunning option. This option tells the task scheduler that the task is likely to hang on
// to a thread for a long time, so it should consider growing the thread pool.
Task.Factory.StartNew(
() => RunMainLoop(messageQueue, buffer),
TaskCreationOptions.LongRunning
);
}
public ServiceMaintenanceController(
IMaintenanceModeService maintenanceModeService,
IEventSender eventSender)
{
_maintenanceModeService = maintenanceModeService;
_eventSender = eventSender;
}
public IndexModule(IEventSender eventSender)
{
Get("/", args =>
{
eventSender.SendEvent(DateTime.UtcNow.ToString(CultureInfo.InvariantCulture));
return("Hello World, it's Event Producer service. Every request here will produce event with messege contains current date time.");
});
}
public BindingController(IEventSender eventSender, ISwitchToSensorBindingsRepository bindingsRepository)
{
Guard.DebugAssertArgumentNotNull(eventSender, nameof(eventSender));
Guard.DebugAssertArgumentNotNull(bindingsRepository, nameof(bindingsRepository));
_eventSender = eventSender;
_bindingsRepository = bindingsRepository;
}
public async Task <Customer> AddCustomer([Service] Store store, [Service] IEventSender eventSender, Customer customer)
{
store.AddCustomer(customer);
await eventSender.SendAsync(new OnAddCustomerMessage(customer));
return(customer);
}
public static void RaiseEventEx(this EventHandler @event, IEventSender sender)
{
if (sender.EventRaisingDisabled)
{
return;
}
@event.RaiseEvent(sender, null);
}
public SagasCompensateRetryBackgroundService(IOptions <PoleSagasOption> options, SagaClient sagaClient, IServiceProvider serviceProvider, IEventSender eventSender, ILogger <SagasCompensateRetryBackgroundService> logger)
{
this.options = options.Value;
this.sagaClient = sagaClient;
sagaRestorer = new SagaRestorer(serviceProvider.GetRequiredService <ISnowflakeIdGenerator>(), serviceProvider, serviceProvider.GetRequiredService <IEventSender>(), this.options, serviceProvider.GetRequiredService <ISerializer>(), serviceProvider.GetRequiredService <IActivityFinder>());
this.eventSender = eventSender;
this.logger = logger;
}
public SagaRestorer(ISnowflakeIdGenerator snowflakeIdGenerator, IServiceProvider serviceProvider, IEventSender eventSender, PoleSagasOption poleSagasOption, ISerializer serializer, IActivityFinder activityFinder)
{
this.snowflakeIdGenerator = snowflakeIdGenerator;
this.serviceProvider = serviceProvider;
this.eventSender = eventSender;
this.poleSagasOption = poleSagasOption;
this.serializer = serializer;
this.activityFinder = activityFinder;
}
// Token: 0x06000113 RID: 275 RVA: 0x00005184 File Offset: 0x00003384
public BreakpointsAdapter(Process process, IEventSender eventSender, SoftDebuggerSession session)
{
this.eventSender = eventSender;
this.threading = process;
this.process = process;
this.session = session;
session.TargetHitBreakpoint += this.OnTargetHitBreakpoint;
session.Breakpoints.BreakpointStatusChanged += this.OnBreakpointStatusChanged;
}
public SagaFactory(ISnowflakeIdGenerator snowflakeIdGenerator, IServiceProvider serviceProvider, IEventSender eventSender, IOptions <PoleSagasOption> poleSagasOption, ISerializer serializer, IActivityFinder activityFinder)
{
this.snowflakeIdGenerator = snowflakeIdGenerator;
this.serviceProvider = serviceProvider;
this.eventSender = eventSender;
this.poleSagasOption = poleSagasOption.Value;
this.serializer = serializer;
this.activityFinder = activityFinder;
}
// Token: 0x060000CD RID: 205 RVA: 0x000040C7 File Offset: 0x000022C7
internal PendingBreakpoint(IBreakpointsAdapter engine, IEventSender sender, Process process, PendingBreakpointRequest request)
{
this.Engine = engine;
this.Request = request;
this.eventSender = sender;
this.process = process;
this.BoundBreakpoints = new List <AD7BoundBreakpoint>();
this.is_enabled = false;
}
public AssetsController(
IAssetsRepository assetsRepository,
IConvertService convertService,
IEventSender eventSender)
{
_assetsRepository = assetsRepository;
_convertService = convertService;
_eventSender = eventSender;
}
public Heartbeat(HeartbeatIntervalSetting heartbeatInterval, IClock clock, IEventSender eventSender, ILogger logger)
{
_heartbeatInterval = heartbeatInterval;
_eventSender = eventSender;
_logger = logger;
_clock = clock;
}
public Heartbeat(ApplicationNameSetting applicationName,
HeartbeatIntervalSetting heartbeatInterval,
InstanceNameSetting instanceName,
IClock clock,
IEventSender eventSender,
ILogger logger)
{
_applicationName = applicationName;
_heartbeatInterval = heartbeatInterval;
_instanceName = instanceName;
_eventSender = eventSender;
_logger = logger;
_clock = clock;
}
internal EventSenderListener(IEventSender sender)
{
_sender = sender;
}
public EventsController(IEventSender sender)
{
_log = this.GetLogger();
_sender = sender;
}
