Dispatcher::initFeedbackConnection() - Code Metrics - Inspection of "Dispatching messages and response handling updated" - zbox/UnifiedPush - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 31963b...74f330 )

by Alexander

created 2016-03-28 22:34 UTC

Dispatcher::initFeedbackConnection() A

↳ Parent: Dispatcher

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php

/*
 * (c) Alexander Zhukov <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zbox\UnifiedPush;

use Zbox\UnifiedPush\Message\MessageInterface;
use Zbox\UnifiedPush\Notification\NotificationBuilder;
use Zbox\UnifiedPush\NotificationService\NotificationServices,
    Zbox\UnifiedPush\NotificationService\ServiceClientInterface,
    Zbox\UnifiedPush\NotificationService\ServiceClientFactory,
    Zbox\UnifiedPush\NotificationService\ResponseHandler;
use Zbox\UnifiedPush\Exception\ClientException,
    Zbox\UnifiedPush\Exception\RuntimeException;
use Psr\Log\LoggerAwareInterface,
    Psr\Log\LoggerInterface,
    Psr\Log\NullLogger;

/**
 * Class Dispatcher
 * @package Zbox\UnifiedPush
 */
class Dispatcher implements LoggerAwareInterface
{
    /**
     * @var array
     */
    private $connectionPool;

    /**
     * @var ServiceClientFactory
     */
    private $clientFactory;

    /**
     * @var NotificationBuilder
     */
    private $notificationBuilder;

    /**
     * @var ResponseHandler
     */
    private $responseHandler;

    /**
     * @var LoggerInterface
     */
    private $logger;

    /**
     * @param ServiceClientFactory $clientFactory
     * @param NotificationBuilder $notificationBuilder
     * @param ResponseHandler $responseHandler
     */
    public function __construct(
        ServiceClientFactory $clientFactory,
        NotificationBuilder $notificationBuilder,
        ResponseHandler $responseHandler
    ){
        $this->clientFactory        = $clientFactory;
        $this->notificationBuilder  = $notificationBuilder;
        $this->responseHandler      = $responseHandler;

        $this->setLogger(new NullLogger());
    }

    /**
     * @param LoggerInterface $logger
     * @return $this
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
        return $this;
    }

    /**
     * @param bool $isDevelopment
     * @return $this
     */
    public function setDevelopmentMode($isDevelopment)
    {
        $this->clientFactory->setDevelopmentMode($isDevelopment);
        return $this;
    }

    /**
     * Gets a service client connection by service name
     *
     * @param string $serviceName
     * @return ServiceClientInterface
     */
    public function getConnection($serviceName)
    {
        if (empty($this->connectionPool[$serviceName])) {
            $this->initConnection($serviceName);
        }

        return $this->connectionPool[$serviceName];
    }

    /**
     * Initialize service client connection by service name
     *
     * @param string $serviceName
     * @return $this
     */
    public function initConnection($serviceName)
    {
        $connection = $this->clientFactory->createServiceClient($serviceName);
        $this->connectionPool[$serviceName] = $connection;

        return $this;
    }

    /**
     * Creates a feedback service connection
     *
     * @param string $serviceName
     * @return ServiceClientInterface
     */
    public function initFeedbackConnection($serviceName)
    {
        return $this->clientFactory->createServiceClient($serviceName, true);
    }

    /**
     * @return ResponseHandler
     */
    public function getResponseHandler()
    {
        return $this->responseHandler;
    }

    /**
     * Tries to dispatch all messages to notification service
     *
     * @param MessageInterface $message
     */
    public function dispatch(MessageInterface $message)
    {
        try {
            $this->logger->info(
                sprintf(
                    "Dispatching message id: '%s'",
                    $message->getMessageIdentifier()
                )
            );

            $this->notificationBuilder->buildNotifications($message);
            $this->sendNotifications($message->getMessageIdentifier());

        } catch (ClientException $e) {
            $this->logger->error(
                sprintf("Client connection error: %s", $e->getMessage())
            );

        } catch (RuntimeException $e) {
            $this->logger->error(
                sprintf("Runtime error: %s", $e->getMessage())
            );

        } catch (\Exception $e) {
            $this->logger->error(
                sprintf("Error occurs: %s", $e->getMessage())
            );
        }
    }

    /**
     * Tries to connect and load feedback data
     *
     * @return $this
     * @throws RuntimeException
     * @throws \Exception
     */
    public function loadFeedback()
    {
        $serviceName = NotificationServices::APPLE_PUSH_NOTIFICATIONS_SERVICE;

        try {
            $this->logger->info(sprintf("Querying the feedback service '%s'", $serviceName));

            $connection = $this->initFeedbackConnection($serviceName);

            $this
                ->responseHandler
                ->addResponse(
                    $connection->sendRequest()
                );

        } catch (RuntimeException $e) {
            $this->logger->error(
                sprintf("Runtime error while acquiring feedback: %s", $e->getMessage())
            );

        } catch (\Exception $e) {
            $this->logger->error(
                sprintf("Error occurs while acquiring feedback: %s", $e->getMessage())
            );
        }

        return $this;
    }

    /**
     * Tries to connect and send a message to notification service
     *
     * @param string $messageIdentifier
     */
    private function sendNotifications($messageIdentifier)
    {
        while ($notification = $this->notificationBuilder->getNotification()) {
            $connection = $this->getConnection($notification->getType());
            $connection->setNotification($notification);

            $this
                ->responseHandler
                ->addMessageResponse(
                    $messageIdentifier,
                    $connection->sendRequest()
                );
        }
    }
}


1			<?php
2
3			/*
4			* (c) Alexander Zhukov <[email protected]>
5			*
6			* For the full copyright and license information, please view the LICENSE
7			* file that was distributed with this source code.
8			*/
9
10			namespace Zbox\UnifiedPush;
11
12			use Zbox\UnifiedPush\Message\MessageInterface;
13			use Zbox\UnifiedPush\Notification\NotificationBuilder;
14			use Zbox\UnifiedPush\NotificationService\NotificationServices,
15			Zbox\UnifiedPush\NotificationService\ServiceClientInterface,
16			Zbox\UnifiedPush\NotificationService\ServiceClientFactory,
17			Zbox\UnifiedPush\NotificationService\ResponseHandler;
18			use Zbox\UnifiedPush\Exception\ClientException,
19			Zbox\UnifiedPush\Exception\RuntimeException;
20			use Psr\Log\LoggerAwareInterface,
21			Psr\Log\LoggerInterface,
22			Psr\Log\NullLogger;
23
24			/**
25			* Class Dispatcher
26			* @package Zbox\UnifiedPush
27			*/
28			class Dispatcher implements LoggerAwareInterface
29			{
30			/**
31			* @var array
32			*/
33			private $connectionPool;
34
35			/**
36			* @var ServiceClientFactory
37			*/
38			private $clientFactory;
39
40			/**
41			* @var NotificationBuilder
42			*/
43			private $notificationBuilder;
44
45			/**
46			* @var ResponseHandler
47			*/
48			private $responseHandler;
49
50			/**
51			* @var LoggerInterface
52			*/
53			private $logger;
54
55			/**
56			* @param ServiceClientFactory $clientFactory
57			* @param NotificationBuilder $notificationBuilder
58			* @param ResponseHandler $responseHandler
59			*/
60			public function __construct(
61			ServiceClientFactory $clientFactory,
62			NotificationBuilder $notificationBuilder,
63			ResponseHandler $responseHandler
64			){
65			$this->clientFactory = $clientFactory;
66			$this->notificationBuilder = $notificationBuilder;
67			$this->responseHandler = $responseHandler;
68
69			$this->setLogger(new NullLogger());
70			}
71
72			/**
73			* @param LoggerInterface $logger
74			* @return $this
75			*/
76			public function setLogger(LoggerInterface $logger)
77			{
78			$this->logger = $logger;
79			return $this;
80			}
81
82			/**
83			* @param bool $isDevelopment
84			* @return $this
85			*/
86			public function setDevelopmentMode($isDevelopment)
87			{
88			$this->clientFactory->setDevelopmentMode($isDevelopment);
89			return $this;
90			}
91
92			/**
93			* Gets a service client connection by service name
94			*
95			* @param string $serviceName
96			* @return ServiceClientInterface
97			*/
98			public function getConnection($serviceName)
99			{
100			if (empty($this->connectionPool[$serviceName])) {
101			$this->initConnection($serviceName);
102			}
103
104			return $this->connectionPool[$serviceName];
105			}
106
107			/**
108			* Initialize service client connection by service name
109			*
110			* @param string $serviceName
111			* @return $this
112			*/
113			public function initConnection($serviceName)
114			{
115			$connection = $this->clientFactory->createServiceClient($serviceName);
116			$this->connectionPool[$serviceName] = $connection;
117
118			return $this;
119			}
120
121			/**
122			* Creates a feedback service connection
123			*
124			* @param string $serviceName
125			* @return ServiceClientInterface
126			*/
127			public function initFeedbackConnection($serviceName)
128			{
129			return $this->clientFactory->createServiceClient($serviceName, true);
130			}
131
132			/**
133			* @return ResponseHandler
134			*/
135			public function getResponseHandler()
136			{
137			return $this->responseHandler;
138			}
139
140			/**
141			* Tries to dispatch all messages to notification service
142			*
143			* @param MessageInterface $message
144			*/
145			public function dispatch(MessageInterface $message)
146			{
147			try {
148			$this->logger->info(
149			sprintf(
150			"Dispatching message id: '%s'",
151			$message->getMessageIdentifier()
152			)
153			);
154
155			$this->notificationBuilder->buildNotifications($message);
156			$this->sendNotifications($message->getMessageIdentifier());
157
158			} catch (ClientException $e) {
159			$this->logger->error(
160			sprintf("Client connection error: %s", $e->getMessage())
161			);
162
163			} catch (RuntimeException $e) {
164			$this->logger->error(
165			sprintf("Runtime error: %s", $e->getMessage())
166			);
167
168			} catch (\Exception $e) {
169			$this->logger->error(
170			sprintf("Error occurs: %s", $e->getMessage())
171			);
172			}
173			}
174
175			/**
176			* Tries to connect and load feedback data
177			*
178			* @return $this
179			* @throws RuntimeException
180			* @throws \Exception
181			*/
182			public function loadFeedback()
183			{
184			$serviceName = NotificationServices::APPLE_PUSH_NOTIFICATIONS_SERVICE;
185
186			try {
187			$this->logger->info(sprintf("Querying the feedback service '%s'", $serviceName));
188
189			$connection = $this->initFeedbackConnection($serviceName);
190
191			$this
192			->responseHandler
193			->addResponse(
194			$connection->sendRequest()
195			);
196
197			} catch (RuntimeException $e) {
198			$this->logger->error(
199			sprintf("Runtime error while acquiring feedback: %s", $e->getMessage())
200			);
201
202			} catch (\Exception $e) {
203			$this->logger->error(
204			sprintf("Error occurs while acquiring feedback: %s", $e->getMessage())
205			);
206			}
207
208			return $this;
209			}
210
211			/**
212			* Tries to connect and send a message to notification service
213			*
214			* @param string $messageIdentifier
215			*/
216			private function sendNotifications($messageIdentifier)
217			{
218			while ($notification = $this->notificationBuilder->getNotification()) {
219			$connection = $this->getConnection($notification->getType());
220			$connection->setNotification($notification);
221
222			$this
223			->responseHandler
224			->addMessageResponse(
225			$messageIdentifier,
226			$connection->sendRequest()
227			);
228			}
229			}
230			}
231

zbox / UnifiedPush

GitHub Access Token became invalid

Push — master ( 31963b...74f330 )

Dispatcher::initFeedbackConnection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like