This is a wrapper package for the official PHP SDK with Activity Registry and full-configurable worker and workflow client.
If your README is long, add a table of contents to make it easy for users to find what they need.
Use this command to install
composer require highcore/temporal-bundle
Create config/workflows.php
And register here your workflows, like a config/bundles.php for symfony
Example config/workflows.php:
<?phpdeclare(strict_types=1);
return [
// ...Temporal\Samples\FileProcessing\FileProcessingWorkflow::class,
// ...
];Create rr.yaml:
version: "3"server:
command: "php bin/console temporal:workflow:runtime"user: "backend"# Set up your user, or remove this valuegroup: "backend"# Set up your group, or remove this valuetemporal:
address: "localhost:7233"namespace: 'default'# Configure a temporal namespace (you must create a namespace manually or use the default namespace named "default")activities:
num_workers: 4# Set up your worker count# Set up your valueslogs:
mode: productionoutput: stdouterr_output: stderrencoding: jsonlevel: errorrpc:
listen: tcp://0.0.0.0:6001Example configuration:
# config/packages/temporal.yamltemporal:
# Default address be localhost:7233address: 'localhost:7233'worker:
# Set up custom worker factory if you want to use custom WorkerFactory, # accepts symfony service factory format ## Details - https://symfony.com/doc/current/service_container/factories.htmlfactory: Highcore\TemporalBundle\WorkerFactory# Set up your own consumption queue for your Temporal Worker, you can set ENV or use string valuequeue: '%env(TEMPORAL_WORKER_QUEUE)%'data-converter:
# Set up your custom Temporal\DataConverter\DataConverterInterface implementationclass: Temporal\DataConverter\DataConverter# Customize the data converters, DO NOT CHANGE if you do not know what it is# Details - https://legacy-documentation-sdks.temporal.io/typescript/data-converters## Sorting order from top to bottom is very, very importantconverters:
- Temporal\DataConverter\NullConverter
- Temporal\DataConverter\BinaryConverter
- Temporal\DataConverter\ProtoJsonConverter
- Highcore\TemporalBundle\DataConverter\ClassObjectConverter
- Temporal\DataConverter\JsonConverterworkflow-client:
options:
# Set up custom namespace, by default will be used 'default' namespacenamespace: monoplace# Set up custom workflow client factory# accepts any class which implements Highcore\TemporalBundle\WorkflowClientFactoryInterfacefactory: Highcore\TemporalBundle\WorkflowClientFactoryExample activity interface:
<?php/** * This file is part of Temporal package. * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespaceTemporal\Samples\FileProcessing;
useTemporal\Activity\ActivityInterface;
#[ActivityInterface(prefix:"FileProcessing.")]
interface StoreActivitiesInterface
{
/** * Upload file to remote location. * * @param string $localFileName file to upload * @param string $url remote location */publicfunctionupload(string$localFileName, string$url): void;
/** * Process file. * * @param string $inputFileName source file name @@return processed file name * @return string */publicfunctionprocess(string$inputFileName): string;
/** * Downloads file to local disk. * * @param string $url remote file location * @return TaskQueueFilenamePair local task queue and downloaded file name */publicfunctiondownload(string$url): TaskQueueFilenamePair;
}Example activity:
<?php# https://github.com/temporalio/samples-php/blob/master/app/src/FileProcessing/StoreActivity.php/** * This file is part of Temporal package. * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespaceTemporal\Samples\FileProcessing;
usePsr\Log\LoggerInterface;
useTemporal\SampleUtils\Logger;
class StoreActivity implements StoreActivitiesInterface
{
privatestaticstring$taskQueue;
privateLoggerInterface$logger;
publicfunction__construct(string$taskQueue = FileProcessingWorkflow::DEFAULT_TASK_QUEUE)
{
self::$taskQueue = $taskQueue;
$this->logger = newLogger();
}
publicfunctionupload(string$localFileName, string$url): void
{
if (!is_file($localFileName)) {
thrownew \InvalidArgumentException("Invalid file type: " . $localFileName);
}
// Faking upload to simplify sample implementation.$this->log('upload activity: uploaded from %s to %s', $localFileName, $url);
}
publicfunctionprocess(string$inputFileName): string
{
try {
$this->log('process activity: sourceFile=%s', $inputFileName);
$processedFile = $this->processFile($inputFileName);
$this->log('process activity: processed file=%s', $processedFile);
return$processedFile;
} catch (\Throwable$e) {
throw$e;
}
}
publicfunctiondownload(string$url): TaskQueueFilenamePair
{
try {
$this->log('download activity: downloading %s', $url);
$data = file_get_contents($url);
$file = tempnam(sys_get_temp_dir(), 'demo');
file_put_contents($file, $data);
$this->log('download activity: downloaded from %s to %s', $url, realpath($file));
returnnewTaskQueueFilenamePair(self::$taskQueue, $file);
} catch (\Throwable$e) {
throw$e;
}
}
privatefunctionprocessFile(string$filename): string
{
// faking processing for simplicityreturn$filename;
}
/** * @param string $message * @param mixed ...$arg */privatefunctionlog(string$message, ...$arg)
{
// by default all error logs are forwarded to the application server log and docker log$this->logger->debug(sprintf($message, ...$arg));
}
}Example workflow interface:
<?php/** * This file is part of Temporal package. * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespaceTemporal\Samples\FileProcessing;
useTemporal\Workflow\WorkflowInterface;
useTemporal\Workflow\WorkflowMethod;
#[WorkflowInterface]
interface FileProcessingWorkflowInterface
{
#[WorkflowMethod("FileProcessing")]
publicfunctionprocessFile(
string$sourceURL,
string$destinationURL
);
}Example workflow:
<?php# https://github.com/temporalio/samples-php/blob/master/app/src/FileProcessing/FileProcessingWorkflow.php/** * This file is part of Temporal package. * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespaceTemporal\Samples\FileProcessing;
useCarbon\CarbonInterval;
useTemporal\Activity\ActivityOptions;
useTemporal\Common\RetryOptions;
useTemporal\Internal\Workflow\ActivityProxy;
useTemporal\Workflow;
class FileProcessingWorkflow implements FileProcessingWorkflowInterface
{
publicconstDEFAULT_TASK_QUEUE = 'default';
/** @var ActivityProxy|StoreActivitiesInterface */private$defaultStoreActivities;
publicfunction__construct()
{
$this->defaultStoreActivities = Workflow::newActivityStub(
StoreActivitiesInterface::class,
ActivityOptions::new()
->withScheduleToCloseTimeout(CarbonInterval::minute(5))
->withTaskQueue(self::DEFAULT_TASK_QUEUE)
);
}
publicfunctionprocessFile(string$sourceURL, string$destinationURL)
{
/** @var TaskQueueFilenamePair $downloaded */$downloaded = yield$this->defaultStoreActivities->download($sourceURL);
$hostSpecificStore = Workflow::newActivityStub(
StoreActivitiesInterface::class,
ActivityOptions::new()
->withScheduleToCloseTimeout(CarbonInterval::minute(5))
->withTaskQueue($downloaded->hostTaskQueue)
);
// Call processFile activity to zip the file.// Call the activity to process the file using worker-specific task queue.$processed = yield$hostSpecificStore->process($downloaded->filename);
// Call upload activity to upload the zipped file.yield$hostSpecificStore->upload($processed, $destinationURL);
return'OK';
}
}Register with symfony service container:
<?phpreturnstaticfunction (ContainerConfigurator$configurator): void {
$services = $configurator->services();
$services->defaults()
->public()
->autowire(true)
->autoconfigure(true);
$services->set(Temporal\Samples\FileProcessing\StoreActivity::class)
// Setting a "label to your activity" will add the activity to the ActivityRegistry,// allowing your employee to use this activity in your Workflow
->tag('temporal.activity.registry');Now you can run:
rr serve rr.yamlAnd call workflow by:
<?phpdeclare(strict_types=1);
namespaceHighcore\TemporalBundle\Example;
useTemporal\Client\WorkflowClientInterface;
useTemporal\Workflow\WorkflowRunInterface;
useTemporal\Client\WorkflowOptions;
useTemporal\Common\RetryOptions;
finalclass ExampleWorkflowRunner {
publicfunction__construct(privatereadonlyWorkflowClientInterface$workflowClient)
{
}
publicfunctionrun(): void
{
/** @var \Temporal\Samples\FileProcessing\FileProcessingWorkflowInterface $workflow */$workflow = $this->workflowClient->newWorkflowStub(
\Temporal\Samples\FileProcessing\FileProcessingWorkflowInterface::class, WorkflowOptions::new()
->withRetryOptions(
RetryOptions::new()
->withMaximumAttempts(3)
->withNonRetryableExceptions(\LogicException::class)
)
);
// Start Workflow async, with no-wait result/** @var WorkflowRunInterface $result */$result = $this->workflowClient->start($workflow, 'https://example.com/example_file', 's3://s3.example.com');
echo'Run ID: ' . $result->getExecution()->getRunID();
// Or you can call workflow sync with wait result$result = $workflow->processingFile('https://example.com/example_file', 's3://s3.example.com');
echo$result; // OK
}
}More php examples you can find here
MIT License
Copyright (c) 2023 Highcore.org
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.