clue/reactphp-redis clue/reactphp-redis

  • Stars
    star
    245
  • Rank 165,304 (Top 4 %)
  • Language
    PHP
  • License
    MIT License
  • Created over 11 years ago
  • Updated over 1 year ago
Twitter logo Share LinkedIn logo Share Facebook logo Share
clue/reactphp-redis
github

clue

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Async Redis client implementation, built on top of ReactPHP.

clue/reactphp-redis

CI status code coverage PHPStan level installs on Packagist

Async Redis client implementation, built on top of ReactPHP.

Development version: This branch contains the code for the upcoming 3.0 release. For the code of the current stable 2.x release, check out the 2.x branch.

The upcoming 3.0 release will be the way forward for this package. However, we will still actively support 2.x for those not yet on the latest version. See also installation instructions for more details.

Redis is an open source, advanced, in-memory key-value database. It offers a set of simple, atomic operations in order to work with its primitive data types. Its lightweight design and fast operation makes it an ideal candidate for modern application stacks. This library provides you a simple API to work with your Redis database from within PHP. It enables you to set and query its data or use its PubSub topics to react to incoming events.

  • Async execution of Commands - Send any number of commands to Redis in parallel (automatic pipeline) and process their responses as soon as results come in. The Promise-based design provides a sane interface to working with async responses.
  • Event-driven core - Register your event handler callbacks to react to incoming events, such as an incoming PubSub message event.
  • Lightweight, SOLID design - Provides a thin abstraction that is just good enough and does not get in your way. Future or custom commands and events require no changes to be supported.
  • Good test coverage - Comes with an automated tests suite and is regularly tested against versions as old as Redis v2.6 and newer.

Table of Contents

Support us

We invest a lot of time developing, maintaining and updating our awesome open-source projects. You can help us sustain this high-quality of our work by becoming a sponsor on GitHub. Sponsors get numerous benefits in return, see our sponsoring page for details.

Let's take these projects to the next level together! 🚀

Quickstart example

Once installed, you can use the following code to connect to your local Redis server and send some requests:

<?php

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

$redis = new Clue\React\Redis\RedisClient('localhost:6379');

$redis->set('greeting', 'Hello world');
$redis->append('greeting', '!');

$redis->get('greeting')->then(function (string $greeting) {
    // Hello world!
    echo $greeting . PHP_EOL;
});

$redis->incr('invocation')->then(function (int $n) {
    echo 'This is invocation #' . $n . PHP_EOL;
});

See also the examples.

Usage

Commands

Most importantly, this project provides a RedisClient instance that can be used to invoke all Redis commands (such as GET, SET, etc.).

$redis = new Clue\React\Redis\RedisClient('localhost:6379');

$redis->get($key);
$redis->set($key, $value);
$redis->exists($key);
$redis->expire($key, $seconds);
$redis->mget($key1, $key2, $key3);

$redis->multi();
$redis->exec();

$redis->publish($channel, $payload);
$redis->subscribe($channel);

$redis->ping();
$redis->select($database);

// many more…

Each method call matches the respective Redis command. For example, the $redis->get() method will invoke the GET command.

All Redis commands are automatically available as public methods via the magic __call() method. Listing all available commands is out of scope here, please refer to the Redis command reference.

Any arguments passed to the method call will be forwarded as command arguments. For example, the $redis->set('name', 'Alice') call will perform the equivalent of a SET name Alice command. It's safe to pass integer arguments where applicable (for example $redis->expire($key, 60)), but internally Redis requires all arguments to always be coerced to string values.

Each of these commands supports async operation and returns a Promise that eventually fulfills with its results on success or rejects with an Exception on error. See also the following section about promises for more details.

Promises

Sending commands is async (non-blocking), so you can actually send multiple commands in parallel. Redis will respond to each command request with a response message, pending commands will be pipelined automatically.

Sending commands uses a Promise-based interface that makes it easy to react to when a command is completed (i.e. either successfully fulfilled or rejected with an error):

$redis->get($key)->then(function (?string $value) {
    var_dump($value);
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

PubSub

This library is commonly used to efficiently transport messages using Redis' Pub/Sub (Publish/Subscribe) channels. For instance, this can be used to distribute single messages to a larger number of subscribers (think horizontal scaling for chat-like applications) or as an efficient message transport in distributed systems (microservice architecture).

The PUBLISH command can be used to send a message to all clients currently subscribed to a given channel:

$channel = 'user';
$message = json_encode(['id' => 10]);
$redis->publish($channel, $message);

The SUBSCRIBE command can be used to subscribe to a channel and then receive incoming PubSub message events:

$channel = 'user';
$redis->subscribe($channel);

$redis->on('message', function (string $channel, string $payload) {
    // pubsub message received on given $channel
    var_dump($channel, json_decode($payload));
});

Likewise, you can use the same client connection to subscribe to multiple channels by simply executing this command multiple times:

$redis->subscribe('user.register');
$redis->subscribe('user.join');
$redis->subscribe('user.leave');

Similarly, the PSUBSCRIBE command can be used to subscribe to all channels matching a given pattern and then receive all incoming PubSub messages with the pmessage event:

$pattern = 'user.*';
$redis->psubscribe($pattern);

$redis->on('pmessage', function (string $pattern, string $channel, string $payload) {
    // pubsub message received matching given $pattern
    var_dump($channel, json_decode($payload));
});

Once you're in a subscribed state, Redis no longer allows executing any other commands on the same client connection. This is commonly worked around by simply creating a second client connection and dedicating one client connection solely for PubSub subscriptions and the other for all other commands.

The UNSUBSCRIBE command and PUNSUBSCRIBE command can be used to unsubscribe from active subscriptions if you're no longer interested in receiving any further events for the given channel and pattern subscriptions respectively:

$redis->subscribe('user');

Loop::addTimer(60.0, function () use ($redis) {
    $redis->unsubscribe('user');
});

Likewise, once you've unsubscribed the last channel and pattern, the client connection is no longer in a subscribed state and you can issue any other command over this client connection again.

Each of the above methods follows normal request-response semantics and return a Promise to await successful subscriptions. Note that while Redis allows a variable number of arguments for each of these commands, this library is currently limited to single arguments for each of these methods in order to match exactly one response to each command request. As an alternative, the methods can simply be invoked multiple times with one argument each.

Additionally, can listen for the following PubSub events to get notifications about subscribed/unsubscribed channels and patterns:

$redis->on('subscribe', function (string $channel, int $total) {
    // subscribed to given $channel
});
$redis->on('psubscribe', function (string $pattern, int $total) {
    // subscribed to matching given $pattern
});
$redis->on('unsubscribe', function (string $channel, int $total) {
    // unsubscribed from given $channel
});
$redis->on('punsubscribe', function (string $pattern, int $total) {
    // unsubscribed from matching given $pattern
});

When the underlying connection is lost, the unsubscribe and punsubscribe events will be invoked automatically. This gives you control over re-subscribing to the channels and patterns as appropriate.

API

RedisClient

The RedisClient is responsible for exchanging messages with your Redis server and keeps track of pending commands.

$redis = new Clue\React\Redis\RedisClient('localhost:6379');

$redis->incr('hello');

Besides defining a few methods, this interface also implements the EventEmitterInterface which allows you to react to certain events as documented below.

Internally, this class creates the underlying connection to Redis only on demand once the first request is invoked on this instance and will queue all outstanding requests until the underlying connection is ready. This underlying connection will be reused for all requests until it is closed. By default, idle connections will be held open for 1ms (0.001s) when not used. The next request will either reuse the existing connection or will automatically create a new underlying connection if this idle time is expired.

From a consumer side this means that you can start sending commands to the database right away while the underlying connection may still be outstanding. Because creating this underlying connection may take some time, it will enqueue all oustanding commands and will ensure that all commands will be executed in correct order once the connection is ready.

If the underlying database connection fails, it will reject all outstanding commands and will return to the initial "idle" state. This means that you can keep sending additional commands at a later time which will again try to open a new underlying connection. Note that this may require special care if you're using transactions (MULTI/EXEC) that are kept open for longer than the idle period.

While using PubSub channels (see SUBSCRIBE and PSUBSCRIBE commands), this client will never reach an "idle" state and will keep pending forever (or until the underlying database connection is lost). Additionally, if the underlying database connection drops, it will automatically send the appropriate unsubscribe and punsubscribe events for all currently active channel and pattern subscriptions. This allows you to react to these events and restore your subscriptions by creating a new underlying connection repeating the above commands again.

Note that creating the underlying connection will be deferred until the first request is invoked. Accordingly, any eventual connection issues will be detected once this instance is first used. You can use the end() method to ensure that the connection will be soft-closed and no further commands can be enqueued. Similarly, calling end() on this instance when not currently connected will succeed immediately and will not have to wait for an actual underlying connection.

__construct()

The new RedisClient(string $url, ConnectorInterface $connector = null, LoopInterface $loop = null) constructor can be used to create a new RedisClient instance.

The $url can be given in the standard form [redis[s]://][:auth@]host[:port][/db]. You can omit the URI scheme and port if you're connecting to the default port 6379:

// both are equivalent due to defaults being applied
$redis = new Clue\React\Redis\RedisClient('localhost');
$redis = new Clue\React\Redis\RedisClient('redis://localhost:6379');

Redis supports password-based authentication (AUTH command). Note that Redis' authentication mechanism does not employ a username, so you can pass the password h@llo URL-encoded (percent-encoded) as part of the URI like this:

// all forms are equivalent
$redis = new Clue\React\Redis\RedisClient('redis://:h%40llo@localhost');
$redis = new Clue\React\Redis\RedisClient('redis://ignored:h%40llo@localhost');
$redis = new Clue\React\Redis\RedisClient('redis://localhost?password=h%40llo');

You can optionally include a path that will be used to select (SELECT command) the right database:

// both forms are equivalent
$redis = new Clue\React\Redis\RedisClient('redis://localhost/2');
$redis = new Clue\React\Redis\RedisClient('redis://localhost?db=2');

You can use the standard rediss:// URI scheme if you're using a secure TLS proxy in front of Redis:

$redis = new Clue\React\Redis\RedisClient('rediss://redis.example.com:6340');

You can use the redis+unix:// URI scheme if your Redis instance is listening on a Unix domain socket (UDS) path:

$redis = new Clue\React\Redis\RedisClient('redis+unix:///tmp/redis.sock');

// the URI MAY contain `password` and `db` query parameters as seen above
$redis = new Clue\React\Redis\RedisClient('redis+unix:///tmp/redis.sock?password=secret&db=2');

// the URI MAY contain authentication details as userinfo as seen above
// should be used with care, also note that database can not be passed as path
$redis = new Clue\React\Redis\RedisClient('redis+unix://:secret@/tmp/redis.sock');

This method respects PHP's default_socket_timeout setting (default 60s) as a timeout for establishing the underlying connection and waiting for successful authentication. You can explicitly pass a custom timeout value in seconds (or use a negative number to not apply a timeout) like this:

$redis = new Clue\React\Redis\RedisClient('localhost?timeout=0.5');

By default, idle connections will be held open for 1ms (0.001s) when not used. The next request will either reuse the existing connection or will automatically create a new underlying connection if this idle time is expired. This ensures you always get a "fresh" connection and as such should not be confused with a "keepalive" or "heartbeat" mechanism, as this will not actively try to probe the connection. You can explicitly pass a custom idle timeout value in seconds (or use a negative number to not apply a timeout) like this:

$redis = new Clue\React\Redis\RedisClient('localhost?idle=10.0');

If you need custom DNS, proxy or TLS settings, you can explicitly pass a custom instance of the ConnectorInterface:

$connector = new React\Socket\Connector([
    'dns' => '127.0.0.1',
    'tcp' => [
        'bindto' => '192.168.10.1:0'
    ],
    'tls' => [
        'verify_peer' => false,
        'verify_peer_name' => false
    ]
]);

$redis = new Clue\React\Redis\RedisClient('localhost', $connector);

This class takes an optional LoopInterface|null $loop parameter that can be used to pass the event loop instance to use for this object. You can use a null value here in order to use the default loop. This value SHOULD NOT be given unless you're sure you want to explicitly use a given event loop instance.

__call()

The __call(string $name, string[] $args): PromiseInterface<mixed> method can be used to invoke the given command.

This is a magic method that will be invoked when calling any Redis command on this instance. Each method call matches the respective Redis command. For example, the $redis->get() method will invoke the GET command.

$redis->get($key)->then(function (?string $value) {
    var_dump($value);
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

All Redis commands are automatically available as public methods via this magic __call() method. Listing all available commands is out of scope here, please refer to the Redis command reference.

Any arguments passed to the method call will be forwarded as command arguments. For example, the $redis->set('name', 'Alice') call will perform the equivalent of a SET name Alice command. It's safe to pass integer arguments where applicable (for example $redis->expire($key, 60)), but internally Redis requires all arguments to always be coerced to string values.

Each of these commands supports async operation and returns a Promise that eventually fulfills with its results on success or rejects with an Exception on error. See also promises for more details.

end()

The end():void method can be used to soft-close the Redis connection once all pending commands are completed.

close()

The close():void method can be used to force-close the Redis connection and reject all pending commands.

error event

The error event will be emitted once a fatal error occurs, such as when the client connection is lost or is invalid. The event receives a single Exception argument for the error instance.

$redis->on('error', function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

This event will only be triggered for fatal errors and will be followed by closing the client connection. It is not to be confused with "soft" errors caused by invalid commands.

close event

The close event will be emitted once the client connection closes (terminates).

$redis->on('close', function () {
    echo 'Connection closed' . PHP_EOL;
});

See also the close() method.

Install

The recommended way to install this library is through Composer. New to Composer?

Once released, this project will follow SemVer. At the moment, this will install the latest development version:

composer require clue/redis-react:^3@dev

See also the CHANGELOG for details about version upgrades.

This project aims to run on any platform and thus does not require any PHP extensions and supports running on PHP 7.1 through current PHP 8+. It's highly recommended to use the latest supported PHP version for this project.

We're committed to providing long-term support (LTS) options and to provide a smooth upgrade path. You may target multiple versions at the same time to support a wider range of PHP versions like this:

composer require "clue/redis-react:^3@dev || ^2"

Tests

To run the test suite, you first need to clone this repo and then install all dependencies through Composer:

composer install

To run the test suite, go to the project root and run:

vendor/bin/phpunit

The test suite is set up to always ensure 100% code coverage across all supported environments. If you have the Xdebug extension installed, you can also generate a code coverage report locally like this:

XDEBUG_MODE=coverage vendor/bin/phpunit --coverage-text

The test suite contains both unit tests and functional integration tests. The functional tests require access to a running Redis server instance and will be skipped by default.

If you don't have access to a running Redis server, you can also use a temporary Redis Docker image:

docker run --net=host redis

To now run the functional tests, you need to supply your login details in an environment variable like this:

REDIS_URI=localhost:6379 vendor/bin/phpunit

On top of this, we use PHPStan on max level to ensure type safety across the project:

vendor/bin/phpstan

License

This project is released under the permissive MIT license.

Did you know that I offer custom development services and issuing invoices for sponsorships of releases and for contributions? Contact me (@clue) for details.

More Repositories

1

stream-filter

A simple and modern approach to stream filtering in PHP
PHP
1,608
star
2

phar-composer

Simple phar creation for every PHP project managed via Composer
PHP
858
star
3

graph-composer

Dependency graph visualization for composer.json (PHP + Composer)
PHP
852
star
4

framework-x

Framework X – the simple and fast micro framework for building reactive web applications that run anywhere.
PHP
718
star
5

reactphp-buzz

[Deprecated] Simple, async PSR-7 HTTP client for concurrently processing any number of HTTP requests, built on top of ReactPHP.
PHP
356
star
6

socket-raw

Simple and lightweight OOP wrapper for PHP's low-level sockets extension (ext-sockets)
PHP
325
star
7

docker-json-server

JSON Server docker image, REST API mocking based on plain JSON
Shell
297
star
8

docker-ttrss

Tiny Tiny RSS feed reader as a docker image.
PHP
200
star
9

reactphp-stdio

Async, event-driven and UTF-8 aware console input & output (STDIN, STDOUT) for truly interactive CLI applications, built on top of ReactPHP.
PHP
193
star
10

php-redis-server

A Redis server implementation in pure PHP
PHP
181
star
11

commander

Finally a sane way to register available commands and arguments and match your command line in PHP
PHP
171
star
12

reactphp-block

Lightweight library that eases using components built for ReactPHP in a traditional, blocking environment.
PHP
152
star
13

reactphp-mq

Mini Queue, the lightweight in-memory message queue to concurrently do many (but not too many) things at once, built on top of ReactPHP.
PHP
127
star
14

reactphp-zenity

Zenity allows you to build graphical desktop (GUI) applications in PHP, built on top of ReactPHP.
PHP
120
star
15

reactphp-socks

Async SOCKS proxy connector client and server implementation, tunnel any TCP/IP-based protocol through a SOCKS5 or SOCKS4(a) proxy server, built on top of ReactPHP.
PHP
116
star
16

reactphp-term

Streaming terminal emulator, built on top of ReactPHP
PHP
103
star
17

reactphp-docker

Async, event-driven access to the Docker Engine API, built on top of ReactPHP.
PHP
100
star
18

reactphp-ami

Streaming, event-driven access to the Asterisk Manager Interface (AMI), built on top of ReactPHP.
PHP
71
star
19

framework-x-placeholder

Framework X – the simple and fast micro framework for building reactive web applications that run anywhere.
67
star
20

docker-adminer

Adminer docker image, a full-featured database management tool for the web
66
star
21

reactphp-utf8

Streaming UTF-8 parser, built on top of ReactPHP
PHP
66
star
22

reactphp-soap

Simple, async SOAP webservice client, built on top of ReactPHP.
PHP
62
star
23

php-socks

[maintenance] look at clue/socks-react instead
PHP
62
star
24

reactphp-ndjson

Streaming newline-delimited JSON (NDJSON) parser and encoder for ReactPHP.
PHP
62
star
25

reactphp-flux

Flux, the lightweight stream processor to concurrently do many (but not too many) things at once, built on top of ReactPHP.
PHP
58
star
26

php-sse-react

Streaming, async HTML5 Server-Sent Events server (aka. SSE or EventSource), built on top of ReactPHP
PHP
54
star
27

psocksd

The SOCKS tunnel / proxy server daemon written in PHP
PHP
53
star
28

reactphp-csv

Streaming CSV (Comma-Separated Values or Character-Separated Values) parser and encoder for ReactPHP.
PHP
51
star
29

reactphp-eventsource

Instant real-time updates. Lightweight EventSource client receiving live messages via HTML5 Server-Sent Events (SSE). Fast stream processing built on top of ReactPHP's event-driven architecture.
PHP
48
star
30

reactphp-sqlite

Async SQLite database, lightweight non-blocking process wrapper around file-based database extension (ext-sqlite3), built on top of ReactPHP.
PHP
46
star
31

reactphp-http-proxy

Async HTTP proxy connector, tunnel any TCP/IP-based protocol through an HTTP CONNECT proxy server, built on top of ReactPHP.
PHP
45
star
32

docker-phpvirtualbox

phpVirtualBox docker image, a modern webinterface mirroring the VirtualBox GUI to administer VirtualBox VMs in a headless environment
PHP
42
star
33

php-redis-protocol

A Redis protocol parser / serializer written in PHP
PHP
38
star
34

docker-h5ai

h5ai docker image, the modern web server index
34
star
35

reactphp-shell

Run async commands within any interactive shell command, built on top of ReactPHP.
PHP
32
star
36

arguments

The simple way to split your command line string into an array of command arguments in PHP.
PHP
31
star
37

php-json-query

The JSON query language implemented in PHP
PHP
30
star
38

reactphp-zlib

Streaming zlib compressor and decompressor for ReactPHP, supporting compression and decompression of GZIP, ZLIB and raw DEFLATE formats.
PHP
28
star
39

json-stream

Simple, lightweight, incremental parser for JSON streaming (concatenated JSON and newline-delimited JSON), in PHP
PHP
24
star
40

json-query-language

A structured query language for querying / filtering JSON documents, expressed in JSON
24
star
41

graph-uml

UML class diagrams in PHP
PHP
24
star
42

reactphp-ssh-proxy

Async SSH proxy connector and forwarder, tunnel any TCP/IP-based protocol through an SSH server, built on top of ReactPHP.
PHP
23
star
43

docker-streamripper

Streamripper docker image, an application that lets you record streaming mp3 to your hard drive
Shell
22
star
44

reactphp-multicast

Simple, event-driven multicast UDP message client and server for ReactPHP.
PHP
21
star
45

reactphp-pq

PQ ("peak"), automatically wrap blocking functions in an async child process and turn blocking functions into non-blocking promises, built on top of ReactPHP
20
star
46

php-socket-react

Binding for raw sockets (ext-sockets) in React PHP
PHP
20
star
47

reactphp-connection-manager-extra

Provides extra (in terms of "additional", "extraordinary", "special" and "unusual") decorators, built on top of ReactPHP's Socket
PHP
20
star
48

docker-frontroute

A docker image to automatically set up a front router (reverse proxy) for linked web containers
PHP
19
star
49

reactphp-ssdp

Async Simple Service Discovery Protocol (SSDP), built on top of ReactPHP.
PHP
19
star
50

reactphp-quassel

Streaming, event-driven access to your Quassel IRC core, built on top of ReactPHP
PHP
18
star
51

docker-webgrind

Webgrind docker image, a Xdebug profiling web frontend
Shell
18
star
52

php-wake-on-lan-react

Turn on your PC with Wake-On-LAN (WOL) requests via React PHP
PHP
18
star
53

docker-httpie

HTTpie docker image, a cURL-like tool for humans
Shell
17
star
54

make.php

A GNU Make clone written in pure PHP. Run your Makefiles no matter whether GNU make is available.
17
star
55

reactphp-packagist-api

Simple async access to packagist.org's API, like listing project details, number of downloads etc., built on top of ReactPHP.
PHP
16
star
56

reactphp-mdns

Simple, async multicast DNS (mDNS) resolver for zeroconf networking, built on top of ReactPHP.
PHP
14
star
57

reactphp-memoize

Automatically memoize async function calls by caching function results, built on top of ReactPHP.
13
star
58

docker-polipo

Docker image for Polipo, a caching web/http proxy
13
star
59

php-icmp-react

Simple async lowlevel ICMP (ping) messaging library built on top of React PHP
PHP
13
star
60

docker-apt-cacher

Dockerized apt-cacher container
Shell
13
star
61

php-hexdump

View any (binary) string as a hexdump in php
PHP
12
star
62

reactphp-tar

Streaming parser to extract tarballs with ReactPHP.
PHP
12
star
63

reactphp-s3

Async S3 filesystem API (supporting Amazon S3, Ceph, MiniIO, DigitalOcean Spaces and others), built on top of ReactPHP.
11
star
64

confgen

Configuration file generator (confgen) – an easy way to generate structured (configuration) files on the fly by processing a Twig template and an arbitrary input data structure.
PHP
10
star
65

reactphp-mailer

Async mailer using SMTP to send large number of emails concurrently, built on top of ReactPHP.
9
star
66

reactphp-clickhouse

Blazing fast access to your ClickHouse database, built on top of @ReactPHP.
8
star
67

docker-vboxwebsrv

Tunneled VirtualBox SOAP webserver docker image
Shell
8
star
68

php-solusvm-api-react

Simple async access to your VPS box through the SolusVM API, built on top of React PHP
PHP
7
star
69

php-readline-react

Experimental reactive binding for ext-readline, built on top of React PHP
PHP
6
star
70

php-json-merge-patch

JSON merge patch (RFC 7396) is a simple alternative to JSON patch (RFC 6902) – dead-simple PHP library
PHP
6
star
71

qdatastream

Lightweight PHP library that allows exchanging binary data with Qt programs (QDataStream)
PHP
5
star
72

reactphp-tsv

Streaming TSV (Tab-Separated Values) parser and encoder for ReactPHP.
5
star
73

docker-textract

textract docker image, allows you to extract text from any document. no muss. no fuss.
Shell
5
star
74

quasselio

Quassel I/O, the lightweight web interface for Quassel IRC in a single PHP file
5
star
75

fd

Access to low-level file desciptors (FDs) with PHP, provides close(), dup(), open() and family
5
star
76

docker-quassel-core

Quassel Core docker image, a modern, cross-platform, distributed IRC program
4
star
77

reactphp-ltsv

Streaming LTSV (Labeled Tab-Separated Values) parser and encoder for ReactPHP.
4
star
78

docker-archeologit

ArcheoloGit docker image, visualize the age and dev activity for git repositories
Shell
4
star
79

reactphp-dns-sd

Async DNS Service Discovery (DNS-SD) implementation for ReactPHP
4
star
80

clue.engineering

Source code for the https://clue.engineering/ website.
HTML
4
star
81

quassel-cli

A CLI Quassel client
4
star
82

reactphp-ftp

Streaming client for FTP servers (File Transfer Protocol), built on top of ReactPHP.
4
star
83

reactphp-rediscovered

A Redis server framework written in pure PHP. Create your own Redis server and your own custom commands without hassle.
3
star
84

docker-redis-benchmark

A minimal docker image to ease running the redis-benchmark
Shell
3
star
85

docker-sculpin

Sculpin Docker image, a static site generator
3
star
86

docker-php-redis-server

A docker image to easily test-drive the php-redis-server
Shell
2
star
87

phpmdoc

PHP + MarkDown + phpdoc = phpmdoc, because writing documentation for PHP projects shouldn't be hard. Parses your class files to create a simple and fully automated markdown document (such as a README.md).
2
star
88

framework-x-website

Source code for the Framework X website.
HTML
2
star
89

docker-kpcli

Minimal kpcli docker image, a command line interface for KeePass
Shell
2
star
90

clue

2
star
91

bitbake-react

Programatically control your bitbake build shell, built on top of React PHP
PHP
2
star
92

php-viewvc-api-react

Simple, async access to your ViewVC web interface, built on top of React PHP
PHP
2
star
93

reactphp-ping

Async, event-driven ping requests to check network connectivity, built on top of ReactPHP.
2
star
94

php-caret-notation

^B A dead-simple PHP library to add caret notation in order to safely show strings that contain ASCII control characters (unprintable characters)
PHP
2
star
95

reactphp-bencode

Streaming Bencode (B-encode) protocol parser and encoder for ReactPHP
1
star
96

docker-psocksd

A docker image for psocksd, the fast, extensible SOCKS tunnel / proxy server daemon written in PHP
Shell
1
star
97

docker-disco

Disco Docker image, a simple visual GitHub browser with pull request support
Shell
1
star
98

mdtoc

Automatic table of contents (TOC) for your markdown documents, with opinionated defaults to keep your README.md up to date without the fuss.
1
star
99

reactphp-netstring

Streaming netstring protocol parser and encoder for ReactPHP
1
star
100

reactphp-imap

Streaming client for IMAP mail servers using IMAP IDLE for instant email notifications, built on top of ReactPHP.
1
star