Giter Club home page Giter Club logo

pheanstalk's Introduction

Pheanstalk

Latest Stable Version Total Downloads Scrutinizer Code Quality Code Coverage Build Status

Pheanstalk 5 is a pure PHP8.1+ client for use with beanstalkd workqueue versions 1.12 and later. In 2021 / 2022 / 2023 it was almost completely rewritten from scratch with the following goals in mind:

  • Fully typed
  • Passing the strict rule set for static analysis using PHPStan and Psalm
  • Splitting the different roles into separate parts

Usage Example

Producer

<?php
require __DIR__ . '/vendor/autoload.php';

use Pheanstalk\Pheanstalk;
use Pheanstalk\Values\TubeName;

$pheanstalk = Pheanstalk::create('127.0.0.1');
$tube       = new TubeName('testtube');

// Queue a Job
$pheanstalk->useTube($tube);
$pheanstalk>put("job payload goes here\n");

$pheanstalk->useTube($tube);
$pheanstalk->put(
    data: json_encode(['test' => 'data']),
    priority: Pheanstalk::DEFAULT_PRIORITY,
    delay: 30,
    timeToRelease: 60
);

Consumer / Worker

<?php
require __DIR__ . '/vendor/autoload.php';
use Pheanstalk\Pheanstalk;
use Pheanstalk\Values\TubeName;

$pheanstalk = Pheanstalk::create('127.0.0.1');
$tube       = new TubeName('testtube');

// we want jobs from 'testtube' only.
$pheanstalk->watch($tube);

// this hangs until a Job is produced.
$job = $pheanstalk->reserve();

try {
    $jobPayload = $job->getData();
    // do work.

    sleep(2);
    // If it's going to take a long time, periodically
    // tell beanstalk we're alive to stop it rescheduling the job.
    $pheanstalk->touch($job);
    sleep(2);

    // eventually we're done, delete job.
    $pheanstalk->delete($job);
}
catch(\Exception $e) {
    // handle exception.
    // and let some other worker retry.
    $pheanstalk->release($job); 
}

Running the tests

Make sure you have docker-compose installed.

> composer test

History

Pheanstalk 4

In 2018 Sam Mousa took on the responsibility of maintaining Pheanstalk.

Pheanstalk 4.0 drops support for older PHP versions. It contains the following changes (among other things):

  • Strict PHP type hinting
  • Value objects for Job IDs
  • Functions without side effects
  • Dropped support for persistent connections
  • Add support for multiple socket implementations (streams extension, socket extension, fsockopen)

Dropping support persistent connections

Persistent connections are a feature where a TCP connection is kept alive between different requests to reduce overhead from TCP connection set up. When reusing TCP connections we must always guarantee that the application protocol, in this case beanstalks' protocol is in a proper state. This is hard, and in some cases impossible; at the very least this means we must do some tests which cause roundtrips. Consider for example a connection that has just sent the command PUT 0 4000. The beanstalk server is now going to read 4000 bytes, but if the PHP script crashes during this write the next request get assigned this TCP socket. Now to reset the connection to a known state it used to subscribe to the default tube: use default. Since the beanstalk server is expecting 4000 bytes, it will just write this command to the job and wait for more bytes..

To prevent these kinds of issues the simplest solution is to not use persistent connections.

Dropped connection handling

Depending on the socket implementation used we might not be able to enable TCP keepalive. If we do not have TCP keepalive there is no way for us to detect dropped connections, the underlying OS may wait up to 15 minutes to decide that a TCP connection where no packets are being sent is disconnected. When using a socket implementation that supports read timeouts, like SocketSocket which uses the socket extension we use read and write timeouts to detect broken connections; the issue with the beanstalk protocol is that it allows for no packets to be sent for extended periods of time. Solutions are to either catch these connection exceptions and reconnect or use reserveWithTimeout() with a timeout that is less than the read / write timeouts.

Example code for a job runner could look like this (this is real production code):

while(true) {
    $job = $beanstalk->reserveWithTimeout(50);
    $this->stdout('.', Console::FG_CYAN);
    if (isset($job)) {
        $this->ensureDatabase($db);
        try {
            /** @var HookTask $task */
            $task = $taskFactory->createFromJson($job->getData());

            $commandBus->handle($task);
            $this->stdout("Deleting job: {$job->getId()}\n", Console::FG_GREEN);
            $beanstalk->delete($job);
        } catch (\Throwable $t) {
            \Yii::error($t);
            $this->stderr("\n{$t->getMessage()}\n", Console::FG_RED);
            $this->stderr("{$t->getTraceAsString()}\n", Console::FG_RED);

            $this->stdout("Burying job: {$job->getId()}\n", Console::FG_YELLOW);
            $beanstalk->bury($job);
        }
    }
}

Here connection errors will cause the process to exit (and be restarted by a task manager).

Functions with side effects

In version 4 functions with side effects have been removed, functions like putInTube internally did several things:

  1. Switch to the tube
  2. Put the job in the new tube

In this example, the tube changes meaning that the connection is now in a different state. This is not intuitive and forces any user of the connection to always switch / check the current tube. Another issue with this approach is that it is harder to deal with errors. If an exception occurs it is unclear whether we did or did not switch tube.

Migration to v4

A migration should in most cases be relatively simple:

  • Change the constructor, either use the static constructor, use a DI container to construct the dependencies, or manually instantiate them.
  • Change instances of reserve() with a timeout to reserveWithTimeout(int $timeout) since reserve() no longer accepts a timeout parameter.
  • Run your tests, or use a static analyzer to test for calls to functions that no longer exist.
  • Make sure that you handle connection exceptions (this is not new to V4, only in V4 you will get more of them due to the default usage of a socket implementation that has read / write timeouts).

Pheanstalk 3

Pheanstalk is a pure PHP 7.1+ client for the beanstalkd workqueue. It has been actively developed, and used in production by many, since late 2008.

Created by Paul Annesley, Pheanstalk is rigorously unit tested and written using encapsulated, maintainable object oriented design. Community feedback, bug reports and patches has led to a stable 1.0 release in 2010, a 2.0 release in 2013, and a 3.0 release in 2014.

Pheanstalk 3.0 introduces PHP namespaces, PSR-1 and PSR-2 coding standards, and PSR-4 autoloader standard.

beanstalkd up to the latest version 1.10 is supported. All commands and responses specified in the protocol documentation for beanstalkd 1.3 are implemented.

pheanstalk's People

Contributors

pda avatar sammousa avatar davidgoodwin avatar phansys avatar grahamcampbell avatar armetiz avatar mnapoli avatar gcatlin avatar leprechaun avatar jimbojsb avatar jbboehr avatar thewunder avatar noisebynorthwest avatar panicoschr avatar samnela avatar scrutinizer-auto-fixer avatar slnpacifist avatar splotycode avatar henrycatalinismith avatar le-oliver avatar mrjameshamilton avatar olafkarsten avatar pascalheidmann-check24 avatar sraka1 avatar srjlewis avatar taomin597715379 avatar mhor avatar tuupke avatar markuszeller avatar larsyencken avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.