public function install()
{
$createQueues = $this->settings->tryGet(KnownSettingsEnum::CREATE_QUEUES);
if ($createQueues || $createQueues === null) {
$this->queueCreator->createIfNecessary($this->settings->get(QueueBindings::class));
}
}
/**
* @return AMQPConnection
*/
public function createConnection()
{
/** @var AMQPConnection $connection */
$connection = $this->settings->tryGet(RabbitMqKnownSettingsEnum::CONNECTION);
if (!$connection) {
$connectionCredentials = $this->settings->tryGet(RabbitMqKnownSettingsEnum::CONNECTION_CREDENTIALS) ?: [];
$connectionCredentials = array_replace($this->defaultCredentials, $connectionCredentials);
$connection = new AMQPConnection($connectionCredentials);
}
return $connection;
}
/**
* @return Connection
* @throws DBALException
*/
public function __invoke()
{
$connection = $this->settings->tryGet(Doctrine2KnownSettingsEnum::CONNECTION);
if ($connection) {
return $connection;
}
$connectionParameters = $this->settings->tryGet(Doctrine2KnownSettingsEnum::CONNECTION_PARAMETERS);
if (!$connectionParameters) {
throw new UnexpectedValueException("The Doctrine 2 persistence requires either a connection instance or connection parameters. " . "You can provide them through the persistence configurator.");
}
return DriverManager::getConnection($connectionParameters);
}
public function apply(Settings $settings)
{
/** @var EnabledPersistence[]|null $enabledPersistences */
$enabledPersistences = $settings->tryGet(KnownSettingsEnum::ENABLED_PERSISTENCES);
if (!$enabledPersistences) {
// TODO tweak the error message (vezi interfetele de care vb in NServicebus)
// TODO vezi si de SendOnly endpoint cand lamuresti cu sending messages din afara unui handler (fara tranzactie explicita)
throw new UnexpectedValueException("No persistence has been selected, please select your persistence by calling endpointConfigurator.usePersistence.");
}
$enabledPersistences = array_reverse($enabledPersistences);
$availableStorageTypeValues = array_flip(StorageType::getConstants());
$supportedStorageTypeValues = [];
foreach ($enabledPersistences as $enabledPersistence) {
$currentDefinition = $enabledPersistence->getDefinition();
$currentDefinition->formalize();
$selectedStorageType = $enabledPersistence->getSelectedStorageType();
if ($selectedStorageType && !$currentDefinition->hasSupportFor($selectedStorageType)) {
$definitionFqcn = get_class($currentDefinition);
throw new RuntimeException("Definition '{$definitionFqcn}' does not support storage type {$selectedStorageType->getValue()}.");
}
$currentSupportedStorageTypeValues = $currentDefinition->getSupportedStorages($selectedStorageType);
foreach ($currentSupportedStorageTypeValues as $supportedStorageValue) {
if (isset($availableStorageTypeValues[$supportedStorageValue])) {
unset($availableStorageTypeValues[$supportedStorageValue]);
$supportedStorageTypeValues[$supportedStorageValue] = $supportedStorageValue;
$currentDefinition->applyFor(new StorageType($supportedStorageValue), $settings);
}
}
}
$settings->set(KnownSettingsEnum::SUPPORTED_STORAGE_TYPE_VALUES, $supportedStorageTypeValues);
}
/**
* @param Settings $settings
*
* @return bool
*/
private function isDurableMessagingEnabled(Settings $settings)
{
$enabled = $settings->tryGet(KnownSettingsEnum::DURABLE_MESSAGING_ENABLED);
if ($enabled === null) {
$enabled = true;
}
return $enabled;
}
/**
* @return LogicalConnection
*/
public function __invoke()
{
$logicalConnection = $this->settings->tryGet(Doctrine1KnownSettingsEnum::LOGICAL_CONNECTION);
if ($logicalConnection) {
return $logicalConnection;
}
$dsn = $this->settings->tryGet(Doctrine1KnownSettingsEnum::DSN);
if (!$dsn) {
throw new UnexpectedValueException("The Doctrine 1 persistence requires a DSN. You can provide it through the persistence configurator.");
}
$manager = $this->settings->tryGet(Doctrine1KnownSettingsEnum::MANAGER);
if (!$manager) {
$manager = \Doctrine_Manager::getInstance();
}
$connectionName = $this->settings->tryGet(Doctrine1KnownSettingsEnum::CONNECTION_NAME);
return new LogicalConnection($connectionName, $dsn, $manager);
}
/**
* @param BuilderInterface $builder
* @param Settings $settings
*/
public function installFeatures(BuilderInterface $builder, Settings $settings)
{
if (!$settings->tryGet(KnownSettingsEnum::INSTALLERS_ENABLED)) {
return;
}
foreach ($this->features as $feature) {
if ($feature->isActive()) {
$feature->install($builder);
}
}
}
/**
* @return EndpointInstance
*/
public function start()
{
if (!$this->isPrepared) {
$this->prepare();
}
if (!$this->settings->tryGet(KnownSettingsEnum::SEND_ONLY)) {
/** @var TransportReceiver $transportReceiver */
$transportReceiver = $this->builder->build(TransportReceiver::class);
$transportReceiver->start();
}
return new EndpointInstance($this->busContext);
}
private function registerBaseContainerServices(Container $c)
{
$c[Settings::class] = $this->settings;
$c[MessageHandlerRegistry::class] = $this->messageHandlerRegistry;
$c[MessageMutatorRegistry::class] = $this->messageMutatorRegistry;
$c[UnicastRoutingTable::class] = $this->unicastRoutingTable;
$c[PipelineModifications::class] = $this->pipelineModifications;
/** @var UuidGenerationDefinition $uuidDefinition */
$uuidDefinition = $this->settings->get(UuidGenerationDefinition::class);
$c[UuidGeneratorInterface::class] = $uuidDefinition->formalize($this->settings);
$c[PipelineFactory::class] = new PipelineFactory($c[BuilderInterface::class], new StepChainBuilderFactory());
$c[BusOperationsContextFactory::class] = new BusOperationsContextFactory();
$c[BusOperations::class] = new BusOperations($c[PipelineFactory::class], $c[BusOperationsContextFactory::class], $c[PipelineModifications::class], $c[UuidGeneratorInterface::class]);
$c[OutgoingOptionsFactory::class] = new OutgoingOptionsFactory();
$c[BusContext::class] = new BusContext(new PipelineRootStageContext($c[BuilderInterface::class]), $c[BusOperations::class], $c[OutgoingOptionsFactory::class]);
$c[IncomingContextFactory::class] = function ($c) {
return new IncomingContextFactory($c[BusOperations::class], $c[OutgoingOptionsFactory::class]);
};
$c[OutgoingContextFactory::class] = function () {
return new OutgoingContextFactory();
};
$c[ClockInterface::class] = function () {
return new SystemClock();
};
$c[DateTimeConverter::class] = function () {
return new DateTimeConverter();
};
$c[PushPipe::class] = function ($c) {
/** @var PipelineFactory $pipelineFactory */
$pipelineFactory = $c[PipelineFactory::class];
return new PushPipe(new TransportReceiveContextFactory($c[BuilderInterface::class]), $pipelineFactory->createStartingWith(TransportReceiveContext::class, $c[PipelineModifications::class]));
};
$c[PushSettings::class] = function () {
$errorQueue = $this->settings->tryGet(KnownSettingsEnum::ERROR_QUEUE);
if (!$errorQueue) {
throw new UnexpectedValueException("The error queue needs to be set. You can do it using endpointConfigurator.sendFailedMessagesTo.");
}
return new PushSettings($this->settings->get(KnownSettingsEnum::LOCAL_ADDRESS), $this->settings->get(KnownSettingsEnum::ERROR_QUEUE), $this->settings->tryGet(KnownSettingsEnum::PURGE_ON_STARTUP) ?: false);
};
$c[TransportReceiver::class] = function ($c) {
return new TransportReceiver($c[MessagePusherInterface::class], $c[PushSettings::class], $c[PushPipe::class]);
};
}
/**
* Method is called if all defined conditions are met and the feature is marked as enabled.
* Use this method to configure and initialize all required components for the feature like
* the steps in the pipeline or the instances/factories in the container.
*
* @param Settings $settings
* @param BuilderInterface $builder
* @param PipelineModifications $pipelineModifications
*/
public function setup(Settings $settings, BuilderInterface $builder, PipelineModifications $pipelineModifications)
{
$builder->defineSingleton(LogicalConnection::class, new LogicalConnectionFactory($settings));
$builder->defineSingleton(OutboxPersister::class, function () use($builder, $settings) {
return new OutboxPersister($builder->build(LogicalConnection::class), $settings->get(Doctrine1KnownSettingsEnum::OUTBOX_MESSAGES_TABLE_NAME), $settings->get(Doctrine1KnownSettingsEnum::OUTBOX_ENDPOINTS_TABLE_NAME));
});
$builder->defineSingleton(OutboxStorageInterface::class, function () use($builder, $settings) {
return new Doctrine1OutboxStorage($builder->build(OutboxPersister::class), new OutboxMessageConverter(), $settings->get(Doctrine1KnownSettingsEnum::OUTBOX_ENDPOINT_ID));
});
$this->registerStartupTask(function () use($builder, $settings) {
return new EndpointIdLoaderFeatureStartupTask($builder->build(OutboxPersister::class), $settings, $settings->get(KnownSettingsEnum::ENDPOINT_NAME));
});
$this->registerStartupTask(function () use($builder, $settings) {
return new OutboxCleanerFeatureStartupTask($builder->build(OutboxPersister::class), new \DateTime('now', new \DateTimeZone('UTC')), $settings->tryGet(KnownSettingsEnum::DAYS_TO_KEEP_DEDUPLICATION_DATA));
});
$this->registerInstallTask(function () use($builder, $settings) {
return new OutboxTablesCreatorFeatureInstallTask($builder->build(LogicalConnection::class), new OutboxEndpointSchemaProvider(), new OutboxMessageSchemaProvider(), $settings->get(Doctrine1KnownSettingsEnum::OUTBOX_ENDPOINTS_TABLE_NAME), $settings->get(Doctrine1KnownSettingsEnum::OUTBOX_MESSAGES_TABLE_NAME));
});
}
public static function isFeatureActive($featureFqcn, Settings $settings)
{
return $settings->tryGet($featureFqcn) == FeatureStateEnum::ACTIVE;
}
/**
* @param Settings $settings
*
* @return int
*/
private function getMaxRetries(Settings $settings)
{
$maxRetries = $settings->tryGet(KnownSettingsEnum::MAX_FLR_RETRIES);
$maxRetries = $maxRetries === null ? self::DEFAULT_MAX_RETRIES : $maxRetries;
return $maxRetries;
}
