multiple services on same event loop

[ClosetGeek-Git]

Hi, I'm considering swoole for multiple reasons but I would need to run multiple services on the same event loop, such as an Websocket server and redis server on the same loop, or an HTTP server and ZMQ server/router on same loop. How is this possible?

@matyhtf

how to run http, ws and redis on the same port / loop? I would like to do this, too... 😕

@ClosetMonkey have you an solution?

[ClosetGeek-Git]

@flddr not same port, just in the same event loop as you can with reactphp and workerman. No solution yet, but if I don't get a response as to how (if?) it is done properly I will likely start each individually using swoole\proccess and communicate between them using the chan or table classes.

I am actually confused. I want to run http on Port 80 and upgrade to ws even on the same port. ws and wss are upgrades on 80 and 443 ?

And i do not want to run nginx in front of... :|

@ClosetMonkey redis works for me in http_server this way, but maybe it's not safe

<?php

$redis = new swoole_redis;
$http = new swoole_http_server('0.0.0.0', 9501);

$http->on('request', function ($request, $response) use ($redis) {
    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis, $rdata) use ($response) {
      $redis->set('key', 'swoole', function (swoole_redis $redis, $rdata) use ($response) {
          $redis->get('key', function (swoole_redis $redis, $rdata) use ($response) {
              $response->header('Content-Type', 'text/html; charset=utf-8');
              $response->end($rdata);
              $redis->close();
          });
      });
    });
});

$http->start();

... just a test ...

EDIT: while benching i got PHP Warning: Swoole\Redis::connect(): failed to connect to the redis-server[127.0.0.1:6379], Erorr: setsockopt(TCP_NODELAY): Invalid argument[1].

So, code above does not really work in async?!

I can actually not understand if https on Port 443 and wss on Port 1234 becomes CORS/SOP error? Like PWAs, which needs https? Or in mobile apps? ... confused ...

This way one can simply run separate files, like php http.php and php websocket.php - and those would be two swoole side by side? Principially this way it works - but good? Don't know...

[ClosetGeek-Git]

@flddr swoole_websocket_server inherits from swoole_http_server so you can use any swoole_http_server methods on your swoole_websocket_server object (such as swoole_http_server->on('request' ... ). This will allow ws and http to run on the same port (including 80) since ws just upgrades the http connection by default. swoole_websocket_server also inherits swoole_server, which allows you to use the swoole_server->set() method to define ssl properties for HTTPS but haven't used swoole with an ssl service yet so I can't really comment.

<?php
$server = new swoole_websocket_server("127.0.0.1", 80);

$server->on('start', function ($server) {
    // http 'start'
    echo "Swoole http server is started at http://127.0.0.1:80\n";
});

$server->on('request', function ($request, $response) {
	// http 'request'
    $response->header("Content-Type", "text/plain");
    $response->end("Hello World\n");
});

$server->on('open', function($server, $req) {
    // ws 'open'
    echo "connection open: {$req->fd}\n";
});

$server->on('message', function($server, $frame) {
    // ws 'message'
    echo "received message: {$frame->data}\n";
    $server->push($frame->fd, json_encode(["hello", "world"]));
});

$server->on('close', function($server, $fd) {
    // ws 'close'
    echo "connection close: {$fd}\n";
});

$server->start();

@ClosetMonkey thanks for teaching this good way - don't know, i must been drunken 😆

Thats completely correct and fine - so, now we need to know how to run this including redis 😈

Ok, but this way

$redis = new swoole_redis;
$http = new swoole_http_server('0.0.0.0', 9501);

$http->on('request', function ($request, $response) use ($redis) {
    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis, $rdata) use ($response) {
      $redis->set('key', 'swoole', function (swoole_redis $redis, $rdata) use ($response) {
          $redis->get('key', function (swoole_redis $redis, $rdata) use ($response) {
              $response->header('Content-Type', 'text/html; charset=utf-8');
              $response->end($rdata);
              $redis->close();
          });
      });
    });
});

$http->start();

should be correct?! My errors TCP_NODELAY relies on Windows WSL i guess now - i have some errors to unlimit ubuntu 18.04 and redis correct - do not know how to do this as in 16.04

What do you think @ClosetMonkey ? About this async redis?

But - my php workers in task-manager are running permanently and CPU is 100% after that...

Running this on unlimited linux works, but i guess i need correct error-handling:

Swoole http server is started at http://127.0.0.1:9501
PHP Warning:  Swoole\Redis::__call(): redis client connection is closed. in /home/flddr/y.php on LINE X
PHP Warning:  Swoole\Redis::__call(): redis client connection is closed. in /home/flddr/y.php on LINE Y
[2018-09-21 11:03:44 *2003.2]   NOTICE  swFactoryProcess_finish (ERROR 1005): connection[fd=13] does not exists.
[2018-09-21 11:03:44 *2004.3]   NOTICE  swFactoryProcess_finish (ERROR 1004): send 173 byte failed, because connection[fd=12] is closed.
[2018-09-21 11:03:44 *2002.1]   NOTICE  swFactoryProcess_finish (ERROR 1005): connection[fd=9] does not exists.

This happens while benchmarking; the workers are running permanently after that; CPU 100%.

With simple curl this works as aspected @ClosetMonkey

@twose can you help error-handling:

<?php

$redis = new swoole_redis;

$server = new swoole_websocket_server("127.0.0.1", 9501);

$server->on('request', function ($request, $response) use ($html, $redis) {
    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis, $rdata) use ($response) {
        $redis->set('key', 'swoole', function (swoole_redis $redis, $rdata) use ($response) {
            $redis->get('key', function (swoole_redis $redis, $rdata) use ($response) {
                $response->header('Content-Type', 'text/html; charset=utf-8');
                $response->end($rdata);
                $redis->close();
            });
        }); # LINE Y
      }); # LINE X
});

Can it be done this way?

$server->on('request', function ($request, $response) use ($html, $redis) {
    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis, $rdata) use ($response) {
        if ($rdata) {
            $redis->set('key', 'swoole', function (swoole_redis $redis, $rdata) use ($response) {
                if ($rdata) {
                    $redis->get('key', function (swoole_redis $redis, $rdata) use ($response) {
                        if ($rdata) {
                            $response->header('Content-Type', 'text/html; charset=utf-8');
                            $response->end($rdata);
                            $redis->close();
                        } else $redis->close();
                    });
                } else $redis->close();
            });
        } else $redis->close();
      });
});

left only:

Swoole http server is started at http://127.0.0.1:9501
[2018-09-21 11:44:59 $3220.0]   WARNING swManager_check_exit_status: worker#0 abnormal exit,status=0, signal=11
[2018-09-21 11:44:59 $3220.0]   WARNING swManager_check_exit_status: worker#1 abnormal exit,status=0, signal=11

after heavy benchmarking. What happens?

How do we prevent

[2018-09-21 12:14:37 *3754.2]   NOTICE  swFactoryProcess_finish (ERROR 1005): connection[fd=7] does not exists.

?

lastly, i end up with code like

$server->on('request', function ($request, $response) use ($redis, $server) {
    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis2, $rdata) use ($response, $server) {
        
        if ($rdata) $redis2->set('key', 'swoole', function (swoole_redis $redis3, $rdata) use ($response, $server) {
            
            if ($rdata) $redis3->get('key', function (swoole_redis $redis4, $rdata) use ($response, $server) {
                
                if ($rdata) {
                    if ($server->connections[$response->fd]) {
                        $response->header('Content-Type', 'text/html; charset=utf-8');
                        $response->end($rdata);
                    }
                    $redis4->close();
                } else $redis3->close();
                
            });

        });

      });
});

but it stays with

Swoole http server is started at http://127.0.0.1:9501
[2018-09-21 12:52:58 $4976.0]   WARNING swManager_check_exit_status: worker#0 abnormal exit,status=0, signal=11
[2018-09-21 12:52:58 $4976.0]   WARNING swManager_check_exit_status: worker#2 abnormal exit,status=0, signal=11
[2018-09-21 12:52:58 $4976.0]   WARNING swManager_check_exit_status: worker#3 abnormal exit,status=0, signal=11

when benchmarking - only curl works.

Everytime workers with abnormal exit runs detached 100% in background 😕

OH,

this way it fully works:

$server->on('request', function ($request, $response) use ($server) {

    $redis = new swoole_redis; # CHANGED TO INSIDE REQUEST

    $redis->connect('127.0.0.1', 6379, function (swoole_redis $redis2, $rdata) use ($response, $server) {
        
        if ($rdata) $redis2->set('key', 'swoole', function (swoole_redis $redis3, $rdata) use ($response, $server) {
            
            if ($rdata) $redis3->get('key', function (swoole_redis $redis4, $rdata) use ($response, $server) {
                
                if ($rdata) {
                    if ($server->connections[$response->fd]) {
                        $response->header('Content-Type', 'text/html; charset=utf-8');
                        $response->end($rdata);
                    }
                } else {
                    if ($server->connections[$response->fd]) {
                        $response->header('Content-Type', 'text/html; charset=utf-8');
                        $response->end("nodata");
                    }
                }
                $redis4->close();
                
            });
            else $redis3->close();

        });
        else $redis2->close();

      });

    # HOW TO CLOSE HERE? OR ALL IN ALL BETTER?
    
});

but on the next runs redis is getting slower - the closing isnt correct i guess?

@ClosetMonkey this way it runs lastly without errors, but i guess, it could be faster. First run is about 11k and then - after and after - it stays at about 1k.

Sometimes i got [2018-09-21 13:36:52 *2967.1] NOTICE swFactoryProcess_finish (ERROR 1004): send 173 byte failed, because connection[fd=24] is closed. - but this is due to response-error?

This is shorter

$server->on('request', function ($request, $response) use ($server) {

    $client = new swoole_redis;
    $client->connect('127.0.0.1', 6379, function (swoole_redis $client, $result) use ($response, $server) {
        $client->set('key', 'swoole', function (swoole_redis $client, $result) use ($response, $server) {
            $client->get('key', function (swoole_redis $client, $result) use ($response, $server) {
                
                if ($server->connections[$response->fd]) {
                    $response->header('Content-Type', 'text/html; charset=utf-8');
                    $response->end($result);
                }
                
                $client->close();
            });
        });
    });
    
});

But how to check this if ($server->connections[$response->fd]) { correct?

It lastly errors

[2018-09-21 14:03:05 *4021.1]   NOTICE  swFactoryProcess_finish (ERROR 1004): send 173 byte failed, because connection[fd=31] is closed.
[2018-09-21 14:03:05 *4022.2]   NOTICE  swFactoryProcess_finish (ERROR 1005): connection[fd=32] does not exists.

[twose]

You just get a "NOTICE", it's usual, it means the client closed the connection, you can ignore it or set a higher log_level.
About signall 11, What is your swoole version?
async redis client is nearly deprecated now, we use coroutine, write the async program with sync style code.
You can see some examples in:
https://github.com/swoole/swoole-src/tree/master/tests/swoole_redis_coro
https://github.com/swoole/swoole-src/tree/master/examples/coroutine/redis

[twose]

when benchmarking with time parameter, when the test timeout, test script will force disconnect the connection, so the swoole server will notice you connection[fd=\d+] does not exist.

and you benchmark script was wrong, without any connection pool, too many connections would lead to block.