HttpServiceProvider::getNewMySqlConnection() - Code Metrics - Inspection of "Merge pull request #188 from swooletw/develop" - swooletw/laravel-swoole - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( cbb991...62e47c )

by Albert
created 2019-01-13 11:57 UTC
HttpServiceProvider::getNewMySqlConnection() A

↳ Parent: HttpServiceProvider
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

namespace SwooleTW\Http;

use Illuminate\Support\Arr;
use SwooleTW\Http\Helpers\FW;
use Illuminate\Queue\QueueManager;
use Illuminate\Contracts\Http\Kernel;
use Swoole\Http\Server as HttpServer;
use Illuminate\Support\ServiceProvider;
use SwooleTW\Http\Middleware\AccessLog;
use SwooleTW\Http\Server\Facades\Server;
use Illuminate\Database\DatabaseManager;
use SwooleTW\Http\Coroutine\MySqlConnection;
use SwooleTW\Http\Commands\HttpServerCommand;
use Swoole\Websocket\Server as WebsocketServer;
use SwooleTW\Http\Task\Connectors\SwooleTaskConnector;
use SwooleTW\Http\Coroutine\Connectors\ConnectorFactory;

/**
 * @codeCoverageIgnore
 */
abstract class HttpServiceProvider extends ServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = false;

    /**
     * @var boolean
     */
    protected $isWebsocket = false;

    /**
     * @var \Swoole\Http\Server | \Swoole\Websocket\Server
     */
    protected static $server;

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->mergeConfigs();
        $this->setIsWebsocket();
        $this->registerServer();
        $this->registerManager();
        $this->registerCommands();
        $this->registerDatabaseDriver();
        $this->registerSwooleQueueDriver();
    }

    /**
     * Register manager.
     *
     * @return void
     */
    abstract protected function registerManager();

    /**
     * Boot routes.
     *
     * @return void
     */
    abstract protected function bootRoutes();

    /**
     * Boot the service provider.
     *
     * @return void
     */
    public function boot()
    {
        $this->publishes([
            __DIR__ . '/../config/swoole_http.php' => base_path('config/swoole_http.php'),
            __DIR__ . '/../config/swoole_websocket.php' => base_path('config/swoole_websocket.php'),
            __DIR__ . '/../routes/websocket.php' => base_path('routes/websocket.php'),
        ], 'laravel-swoole');

        $config = $this->app->make('config');

        if ($config->get('swoole_http.websocket.enabled')) {
            $this->bootRoutes();
        }

        if ($config->get('swoole_http.server.access_log')) {
            $this->app->make(Kernel::class)->pushMiddleware(AccessLog::class);
            $this->app->make(Kernel::class)->/** @scrutinizer ignore-call */ pushMiddleware(AccessLog::class);
        }
    }

    /**
     * Merge configurations.
     */
    protected function mergeConfigs()
    {
        $this->mergeConfigFrom(__DIR__ . '/../config/swoole_http.php', 'swoole_http');
        $this->mergeConfigFrom(__DIR__ . '/../config/swoole_websocket.php', 'swoole_websocket');
    }

    /**
     * Set isWebsocket.
     */
    protected function setIsWebsocket()
    {
        $this->isWebsocket = $this->app->make('config')
            ->get('swoole_http.websocket.enabled');
    }

    /**
     * Register commands.
     */
    protected function registerCommands()
    {
        $this->commands([
            HttpServerCommand::class,
        ]);
    }

    /**
     * Create swoole server.
     */
    protected function createSwooleServer()
    {
        $server = $this->isWebsocket ? WebsocketServer::class : HttpServer::class;
        $config = $this->app->make('config');
        $host = $config->get('swoole_http.server.host');
        $port = $config->get('swoole_http.server.port');
        $socketType = $config->get('swoole_http.server.socket_type', SWOOLE_SOCK_TCP);
        $processType = $config->get('swoole.http.server.process_type', SWOOLE_PROCESS);

        static::$server = new $server($host, $port, $processType, $socketType);
    }

    /**
     * Set swoole server configurations.
     */
    protected function configureSwooleServer()
    {
        $config = $this->app->make('config');
        $options = $config->get('swoole_http.server.options');

        // only enable task worker in websocket mode and for queue driver
        if ($config->get('queue.default') !== 'swoole' && ! $this->isWebsocket) {
            unset($config['task_worker_num']);
        }

        static::$server->set($options);
    }

    /**
     * Register manager.
     *
     * @return void
     */
    protected function registerServer()
    {
        $this->app->singleton(Server::class, function () {
            if (is_null(static::$server)) {
                $this->createSwooleServer();
                $this->configureSwooleServer();
            }

            return static::$server;
        });
        $this->app->alias(Server::class, 'swoole.server');
    }

    /**
     * Register database driver for coroutine mysql.
     */
    protected function registerDatabaseDriver()
    {
        $this->app->extend(DatabaseManager::class, function (DatabaseManager $db) {
            $db->extend('mysql-coroutine', function ($config, $name) {
                $config = $this->getMergedDatabaseConfig($config, $name);

                $connection = new MySqlConnection(
                    $this->getNewMySqlConnection($config),
                    Arr::get($config, 'database'),
                    Arr::get($config, 'prefix'),
                    $config
                );

                if (Arr::has($config, 'read')) {
                    $connection->setReadPdo($this->getNewMySqlConnection($config));
                }

                return $connection;
            });

            return $db;
        });
    }

    /**
     * Get mereged config for coroutine mysql.
     *
     * @param array $config
     * @param string $name
     *
     * @return array
     */
    protected function getMergedDatabaseConfig(array $config, string $name)
    {
        $newConfig = $config;
        $newConfig = Arr::add($newConfig, 'name', $name);
        $newConfig = array_merge($newConfig, Arr::get($newConfig, 'read', []));
        $newConfig = array_merge($newConfig, Arr::get($newConfig, 'write', []));

        return $newConfig;
    }

    /**
     * Get a new mysql connection.
     *
     * @param array $config
     *
     * @return \PDO
     */
    protected function getNewMySqlConnection(array $config)
    {
        return ConnectorFactory::make(FW::version())->connect($config);
    }

    /**
     * Register queue driver for swoole async task.
     */
    protected function registerSwooleQueueDriver()
    {
        $this->app->afterResolving('queue', function (QueueManager $manager) {
            $manager->addConnector('swoole', function () {
                return new SwooleTaskConnector($this->app->make(Server::class));
                return new SwooleTaskConnector(/** @scrutinizer ignore-type */ $this->app->make(Server::class));
            });
        });
    }
}

swooletw / laravel-swoole

Push — master ( cbb991...62e47c )

HttpServiceProvider::getNewMySqlConnection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
