SessionMonitor::getSessionIds() - Code Metrics - Inspection of "refactored session monitor and monitor trait" - tidal/WampWatch - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#31)

by Timo

created 2016-07-19 22:50 UTC

SessionMonitor::getSessionIds() A

↳ Parent: SessionMonitor

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	1	Features	1

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

<?php

/*
 * This file is part of the Tidal/WampWatch package.
 *   (c) 2016 Timo Michna <timomichna/yahoo.de>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 *
 */

namespace Tidal\WampWatch;

use Evenement\EventEmitterInterface;
use Tidal\WampWatch\ClientSessionInterface as ClientSession;

/**
 * Description of SessionMonitor.
 *
 * @author Timo
 */
class SessionMonitor implements MonitorInterface, EventEmitterInterface
{
    use MonitorTrait;

    const SESSION_JOIN_TOPIC = 'wamp.session.on_join';
    const SESSION_LEAVE_TOPIC = 'wamp.session.on_leave';
    const SESSION_COUNT_TOPIC = 'wamp.session.count';
    const SESSION_LIST_TOPIC = 'wamp.session.list';
    const SESSION_INFO_TOPIC = 'wamp.session.get';

    /**
     * @var array monitored session ids
     */
    protected $sessionIds = [];

    /**
     * @var int subscription id for on_join
     */
    protected $joinSubscriptionId = 0;

    /**
     * @var int subscription id for on_leave
     */
    protected $leaveSubscriptionId = 0;

    /**
     * Constructor.
     *
     * @param ClientSession $session
     */
    public function __construct(ClientSession $session)
    {
        $this->setClientSession($session);
        $this->initSetupCalls();
    }

    /**
     * Retrieves the session-info for given sessionId
     * and populates it in via given callback.
     *
     * @param          $sessionId
     * @param callable $callback
     *
     * @return mixed
     */
    public function getSessionInfo($sessionId, callable $callback = null)
    {
        return $this->session->call(self::SESSION_INFO_TOPIC, [$sessionId])->then(
            function ($res) use ($callback) {
                $this->emit('info', [$res[0]]);
                if ($callback !== null) {
                    $callback($res[0]);
                }
            },
            function ($error) {
                $this->emit('error', [$error]);
            }
        );
    }

    /**
     * Retrieves the Ids of the sessions currently
     * registered on the wamp-router in the monitor's realm
     * and populates the data via given callback,.
     *
     * @param callable $callback
     *
     * @return mixed
     */
    public function getSessionIds(callable $callback)
    {
        if (!count($this->sessionIds)) {
            $this->retrieveSessionIds($callback);

            return;
        }

        $callback($this->sessionIds);
    }

    /**
     * Checks if a session id is known.
     *
     * @param $sessionId
     *
     * @return bool
     */
    public function hasSessionId($sessionId)
    {
        return array_search($sessionId, $this->sessionIds) !== false;
    }

    /**
     * Removes a session id.
     *
     * @param int $sessionId
     */
    protected function removeSessionId($sessionId)
    {
        if (!$this->hasSessionId($sessionId)) {
            return;
        }
        $key = array_search($sessionId, $this->sessionIds);
        unset($this->sessionIds[$key]);
        $this->sessionIds = array_values($this->sessionIds);
        $this->emit('leave', [$sessionId]);
    }

    /**
     * Checks if a session is known by extracting its id.
     *
     * @param $sessionInfo
     *
     * @return bool
     */
    protected function hasSession($sessionInfo)
    {
        return $this->hasSessionId($sessionInfo->session);
    }

    /**
     * Adds and publishes a joined session.
     *
     * @param $sessionInfo
     */
    protected function addSession($sessionInfo)
    {
        $this->sessionIds[] = $sessionInfo->session;
        $this->emit('join', [$sessionInfo]);
    }

    /**
     * Validates the sessionInfo sent from the router.
     *
     * @param string $sessionInfo
     *
     * @return bool
     */
    protected function validateSessionInfo($sessionInfo)
    {
        return is_object($sessionInfo) && property_exists($sessionInfo, 'session');
    }

    /**
     * Initializes the subscription to the meta-events.
     */
    protected function initSetupCalls()
    {
        // @var \Tidal\WampWatch\Subscription\Collection
        $collection = $this->getSubscriptionCollection();

        $collection->addSubscription(self::SESSION_JOIN_TOPIC, function (array $res) {
            $sessionInfo = $res[0];
            if (!$this->validateSessionInfo($sessionInfo) || $this->hasSession($sessionInfo)) {
                return;
            }
            $this->addSession($sessionInfo);
        });

        $collection->addSubscription(self::SESSION_LEAVE_TOPIC, function (array $res) {
            // @bug : wamp.session.on_leave is bugged as of crossbar.io 0.11.0
            // will provide sessionID when Browser closes/reloads,
            // but not when calling connection.close();
            $sessionId = (int) $res[0];
            $this->removeSessionId($sessionId);
        });

        $this->setInitialCall(self::SESSION_LIST_TOPIC, $this->getSessionIdRetrievalCallback());
    }

    /**
     * Retrieves the list of current sessionIds on the router.
     *
     * @param callable|null $callback
     */
    protected function retrieveSessionIds(callable $callback = null)
    {
        $this->session->call(self::SESSION_LIST_TOPIC, [])
            ->then(
                $this->getSessionIdRetrievalCallback()
            )->done(function ($res) use ($callback) {
                if ($callback !== null) {
                    $callback($res);
                }
            });
    }

    protected function getSessionIdRetrievalCallback()
    {
        return function ($res) {
            // remove our own sessionID from the tracked sessions
            $sessionIds = $this->removeOwnSessionId($res[0]);
            $this->setList($sessionIds);
            $this->emit('list', [$this->getList()]);
            $this->checkStarted();

            return $this->getList();
        };
    }

    protected function setList($list)
    {
        $this->sessionIds = $list;
    }

    protected function getList()
    {
        return $this->sessionIds;
    }

    /**
     * remove the sessionID of the Monitor from the list.
     *
     * @param array $sessionsIds
     *
     * @return mixed
     */
    protected function removeOwnSessionId(array $sessionsIds)
    {
        $key = array_search($this->session->getSessionId(), $sessionsIds);
        if ($key >= 0) {
            unset($sessionsIds[$key]);
            $sessionsIds = array_values($sessionsIds);
        }

        return $sessionsIds;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Tidal/WampWatch package.
5			* (c) 2016 Timo Michna <timomichna/yahoo.de>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*
10			*/
11
12			namespace Tidal\WampWatch;
13
14			use Evenement\EventEmitterInterface;
15			use Tidal\WampWatch\ClientSessionInterface as ClientSession;
16
17			/**
18			* Description of SessionMonitor.
19			*
20			* @author Timo
21			*/
22			class SessionMonitor implements MonitorInterface, EventEmitterInterface
23			{
24			use MonitorTrait;
25
26			const SESSION_JOIN_TOPIC = 'wamp.session.on_join';
27			const SESSION_LEAVE_TOPIC = 'wamp.session.on_leave';
28			const SESSION_COUNT_TOPIC = 'wamp.session.count';
29			const SESSION_LIST_TOPIC = 'wamp.session.list';
30			const SESSION_INFO_TOPIC = 'wamp.session.get';
31
32			/**
33			* @var array monitored session ids
34			*/
35			protected $sessionIds = [];
36
37			/**
38			* @var int subscription id for on_join
39			*/
40			protected $joinSubscriptionId = 0;
41
42			/**
43			* @var int subscription id for on_leave
44			*/
45			protected $leaveSubscriptionId = 0;
46
47			/**
48			* Constructor.
49			*
50			* @param ClientSession $session
51			*/
52			public function __construct(ClientSession $session)
53			{
54			$this->setClientSession($session);
55			$this->initSetupCalls();
56			}
57
58			/**
59			* Retrieves the session-info for given sessionId
60			* and populates it in via given callback.
61			*
62			* @param $sessionId
63			* @param callable $callback
64			*
65			* @return mixed
66			*/
67			public function getSessionInfo($sessionId, callable $callback = null)
68			{
69			return $this->session->call(self::SESSION_INFO_TOPIC, [$sessionId])->then(
70			function ($res) use ($callback) {
71			$this->emit('info', [$res[0]]);
72			if ($callback !== null) {
73			$callback($res[0]);
74			}
75			},
76			function ($error) {
77			$this->emit('error', [$error]);
78			}
79			);
80			}
81
82			/**
83			* Retrieves the Ids of the sessions currently
84			* registered on the wamp-router in the monitor's realm
85			* and populates the data via given callback,.
86			*
87			* @param callable $callback
88			*
89			* @return mixed
90			*/
91			public function getSessionIds(callable $callback)
92			{
93			if (!count($this->sessionIds)) {
94			$this->retrieveSessionIds($callback);
95
96			return;
97			}
98
99			$callback($this->sessionIds);
100			}
101
102			/**
103			* Checks if a session id is known.
104			*
105			* @param $sessionId
106			*
107			* @return bool
108			*/
109			public function hasSessionId($sessionId)
110			{
111			return array_search($sessionId, $this->sessionIds) !== false;
112			}
113
114			/**
115			* Removes a session id.
116			*
117			* @param int $sessionId
118			*/
119			protected function removeSessionId($sessionId)
120			{
121			if (!$this->hasSessionId($sessionId)) {
122			return;
123			}
124			$key = array_search($sessionId, $this->sessionIds);
125			unset($this->sessionIds[$key]);
126			$this->sessionIds = array_values($this->sessionIds);
127			$this->emit('leave', [$sessionId]);
128			}
129
130			/**
131			* Checks if a session is known by extracting its id.
132			*
133			* @param $sessionInfo
134			*
135			* @return bool
136			*/
137			protected function hasSession($sessionInfo)
138			{
139			return $this->hasSessionId($sessionInfo->session);
140			}
141
142			/**
143			* Adds and publishes a joined session.
144			*
145			* @param $sessionInfo
146			*/
147			protected function addSession($sessionInfo)
148			{
149			$this->sessionIds[] = $sessionInfo->session;
150			$this->emit('join', [$sessionInfo]);
151			}
152
153			/**
154			* Validates the sessionInfo sent from the router.
155			*
156			* @param string $sessionInfo
157			*
158			* @return bool
159			*/
160			protected function validateSessionInfo($sessionInfo)
161			{
162			return is_object($sessionInfo) && property_exists($sessionInfo, 'session');
163			}
164
165			/**
166			* Initializes the subscription to the meta-events.
167			*/
168			protected function initSetupCalls()
169			{
170			// @var \Tidal\WampWatch\Subscription\Collection
171			$collection = $this->getSubscriptionCollection();
172
173			$collection->addSubscription(self::SESSION_JOIN_TOPIC, function (array $res) {
174			$sessionInfo = $res[0];
175			if (!$this->validateSessionInfo($sessionInfo) \|\| $this->hasSession($sessionInfo)) {
176			return;
177			}
178			$this->addSession($sessionInfo);
179			});
180
181			$collection->addSubscription(self::SESSION_LEAVE_TOPIC, function (array $res) {
182			// @bug : wamp.session.on_leave is bugged as of crossbar.io 0.11.0
183			// will provide sessionID when Browser closes/reloads,
184			// but not when calling connection.close();
185			$sessionId = (int) $res[0];
186			$this->removeSessionId($sessionId);
187			});
188
189			$this->setInitialCall(self::SESSION_LIST_TOPIC, $this->getSessionIdRetrievalCallback());
190			}
191
192			/**
193			* Retrieves the list of current sessionIds on the router.
194			*
195			* @param callable\|null $callback
196			*/
197			protected function retrieveSessionIds(callable $callback = null)
198			{
199			$this->session->call(self::SESSION_LIST_TOPIC, [])
200			->then(
201			$this->getSessionIdRetrievalCallback()
202			)->done(function ($res) use ($callback) {
203			if ($callback !== null) {
204			$callback($res);
205			}
206			});
207			}
208
209			protected function getSessionIdRetrievalCallback()
210			{
211			return function ($res) {
212			// remove our own sessionID from the tracked sessions
213			$sessionIds = $this->removeOwnSessionId($res[0]);
214			$this->setList($sessionIds);
215			$this->emit('list', [$this->getList()]);
216			$this->checkStarted();
217
218			return $this->getList();
219			};
220			}
221
222			protected function setList($list)
223			{
224			$this->sessionIds = $list;
225			}
226
227			protected function getList()
228			{
229			return $this->sessionIds;
230			}
231
232			/**
233			* remove the sessionID of the Monitor from the list.
234			*
235			* @param array $sessionsIds
236			*
237			* @return mixed
238			*/
239			protected function removeOwnSessionId(array $sessionsIds)
240			{
241			$key = array_search($this->session->getSessionId(), $sessionsIds);
242			if ($key >= 0) {
243			unset($sessionsIds[$key]);
244			$sessionsIds = array_values($sessionsIds);
245			}
246
247			return $sessionsIds;
248			}
249			}
250

tidal / WampWatch

Pull Request — master (#31)

SessionMonitor::getSessionIds() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like