public function onUnsubscribe(CM_Model_Stream_Subscribe $streamSubscribe)
{
$unsubscriber = $streamSubscribe->getUser();
if ($unsubscriber && !$this->isSubscriber($unsubscriber, $streamSubscribe)) {
$unsubscriber->setOfflineStamp();
}
}
public function onUnsubscribe(CM_Model_Stream_Subscribe $streamSubscribe)
{
if ($this->hasUser()) {
$user = $streamSubscribe->getUser();
if ($user && !$this->isSubscriber($user, $streamSubscribe)) {
$delayedJobQueue = CM_Service_Manager::getInstance()->getDelayedJobQueue();
$delayedJobQueue->addJob(new CM_User_OfflineJob(), ['user' => $user], CM_Model_User::OFFLINE_DELAY);
}
}
}
/**
* @param CM_Model_Stream_Subscribe $streamSubscribe
* @return bool
* @throws CM_Exception_Invalid
*/
protected function _isSubscribeAllowed(CM_Model_Stream_Subscribe $streamSubscribe)
{
/** @var CM_Model_StreamChannel_Media|CM_StreamChannel_DisallowInterface $streamChannel */
$streamChannel = $streamSubscribe->getStreamChannel();
if (!$streamChannel instanceof CM_StreamChannel_DisallowInterface) {
throw new CM_Exception_Invalid('Streamchannel does not disallow client-connections', ['streamChannel' => $streamChannel]);
}
if ($streamSubscribe->getAllowedUntil() < time()) {
$canSubscribeUntil = $streamChannel->canSubscribe($streamSubscribe->getUser(), $streamSubscribe->getAllowedUntil());
$streamSubscribe->setAllowedUntil($canSubscribeUntil);
if ($streamSubscribe->getAllowedUntil() < time()) {
return false;
}
}
return true;
}
public function testCheckStreams()
{
$mockAdapter = $this->getMockForAbstractClass('CM_Stream_Adapter_Video_Abstract', array(), 'CM_Stream_Adapter_Video_Mock', true, true, true, array('_stopStream', 'getType'));
$mockAdapter->expects($this->exactly(2))->method('_stopStream')->will($this->returnValue(1));
$mockAdapter->expects($this->any())->method('getType')->will($this->returnValue(1));
CM_Config::get()->CM_Model_StreamChannel_Abstract->types[CM_Model_StreamChannel_Video_Mock::getTypeStatic()] = 'CM_Model_StreamChannel_Video_Mock';
$wowza = $wowza = $this->getMock('CM_Stream_Video', array('getAdapter'));
$wowza->expects($this->any())->method('getAdapter')->will($this->returnValue($mockAdapter));
/** @var $wowza CM_Stream_Video */
// allowedUntil will be updated, if stream has expired and its user isn't $userUnchanged, hardcoded in CM_Model_StreamChannel_Video_Mock::canSubscribe() using getOnline()
$userUnchanged = CMTest_TH::createUser();
$userUnchanged->setOnline();
$streamChannel = CM_Model_StreamChannel_Video_Mock::createStatic(array('key' => 'foo1', 'serverId' => 1, 'adapterType' => 1, 'width' => 100, 'height' => 100, 'thumbnailCount' => 0));
$streamSubscribeUnchanged1 = CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $userUnchanged, 'key' => 'foo1_2', 'start' => time()));
$streamSubscribeUnchanged2 = CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => CMTest_TH::createUser(), 'key' => 'foo1_4', 'start' => time()));
$streamSubscribeChanged1 = CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => CMTest_TH::createUser(), 'key' => 'foo1_3', 'start' => time()));
$streamPublishUnchanged1 = CM_Model_Stream_Publish::createStatic(array('streamChannel' => $streamChannel, 'user' => $userUnchanged, 'key' => 'foo1_2', 'start' => time()));
$streamPublishChanged1 = CM_Model_Stream_Publish::createStatic(array('streamChannel' => CM_Model_StreamChannel_Video_Mock::createStatic(array('key' => 'foo2', 'serverId' => 1, 'adapterType' => 1, 'width' => 100, 'height' => 100, 'thumbnailCount' => 0)), 'user' => CMTest_TH::createUser(), 'key' => 'foo2_1', 'start' => time()));
$this->assertSameTime($streamSubscribeUnchanged1->getAllowedUntil(), time() + 10);
$this->assertSameTime($streamSubscribeUnchanged2->getAllowedUntil(), time() + 100);
$this->assertSameTime($streamSubscribeChanged1->getAllowedUntil(), time() + 100);
$this->assertSameTime($streamPublishUnchanged1->getAllowedUntil(), time() + 10);
$this->assertSameTime($streamPublishChanged1->getAllowedUntil(), time() + 100);
CMTest_TH::timeForward(200);
$wowza->checkStreams();
$this->assertEquals($streamSubscribeUnchanged1->getAllowedUntil() + 10, $streamSubscribeUnchanged1->_change()->getAllowedUntil());
$this->assertEquals($streamSubscribeUnchanged2->getAllowedUntil() + 100, $streamSubscribeUnchanged2->_change()->getAllowedUntil());
$this->assertEquals($streamSubscribeChanged1->getAllowedUntil() + 100, $streamSubscribeChanged1->_change()->getAllowedUntil());
$this->assertEquals($streamPublishUnchanged1->getAllowedUntil() + 10, $streamPublishUnchanged1->_change()->getAllowedUntil());
$this->assertEquals($streamPublishChanged1->getAllowedUntil() + 100, $streamPublishChanged1->_change()->getAllowedUntil());
}
public function testSynchronizeMissingInWowza()
{
$streamChannel = CMTest_TH::createStreamChannel();
$streamPublish = CMTest_TH::createStreamPublish(null, $streamChannel);
$streamSubscribe = CMTest_TH::createStreamSubscribe(null, $streamChannel);
$wowza = $this->getMock('CM_Stream_Adapter_Video_Wowza', array('_fetchStatus'));
$json = $this->_generateWowzaData(array());
$wowza->expects($this->any())->method('_fetchStatus')->will($this->returnValue($json));
/** @var $wowza CM_Stream_Video */
$wowza->synchronize();
$this->assertEquals($streamChannel, CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamChannel->getKey(), $wowza->getType()));
$this->assertEquals($streamPublish, CM_Model_Stream_Publish::findByKeyAndChannel($streamPublish->getKey(), $streamChannel));
$this->assertEquals($streamSubscribe, CM_Model_Stream_Subscribe::findByKeyAndChannel($streamSubscribe->getKey(), $streamChannel));
CMTest_TH::timeForward(5);
$wowza->synchronize();
$this->assertNull(CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamChannel->getKey(), $wowza->getType()));
$this->assertNull(CM_Model_Stream_Publish::findByKeyAndChannel($streamPublish->getKey(), $streamChannel));
$this->assertNull(CM_Model_Stream_Subscribe::findByKeyAndChannel($streamSubscribe->getKey(), $streamChannel));
}
public function testUnsetUser()
{
$user = CMTest_TH::createUser();
$streamChannel = CMTest_TH::createStreamChannel();
/** @var CM_Model_Stream_Subscribe $streamSubscribe */
$streamSubscribe = CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $user, 'start' => time(), 'key' => str_repeat('a', 100)));
$this->assertEquals($user, $streamSubscribe->getUser());
$streamSubscribe->unsetUser();
$this->assertNull($streamSubscribe->getUser());
}
/**
* @expectedException CM_Exception_Invalid
* @expectedExceptionMessage not valid
*/
public function testCreateInvalidStreamChannel()
{
$user = CMTest_TH::createUser();
$streamChannel = $this->getMockBuilder('CM_Model_StreamChannel_Video')->setMethods(array('isValid'))->getMock();
$streamChannel->expects($this->any())->method('isValid')->will($this->returnValue(false));
/** @var CM_Model_StreamChannel_Video $streamChannel */
CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $user, 'start' => time(), 'key' => 'foo'));
}
/**
* @param CM_Model_User|null $user
* @param CM_Model_StreamChannel_Abstract|null $streamChannel
* @return CM_Model_Stream_Subscribe
*/
public static function createStreamSubscribe(CM_Model_User $user = null, CM_Model_StreamChannel_Abstract $streamChannel = null)
{
if (is_null($streamChannel)) {
$streamChannel = self::createStreamChannel();
}
return CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $user, 'start' => time(), 'key' => rand(1, 10000) . '_' . rand(1, 100)));
}
/**
* @param string $channel
* @param string $clientKey
* @param int $start
* @param CM_Model_User|null $user
* @throws CM_Exception_Invalid
*/
protected function _subscribe($channel, $clientKey, $start, CM_Model_User $user = null)
{
$channelData = CM_Model_StreamChannel_Message::extractStatusChannelData($channel);
$channelKey = $channelData['key'];
$channelType = $channelData['type'];
$streamChannel = CM_Model_StreamChannel_Message::findByKeyAndAdapter($channelKey, $this->getType());
if ($streamChannel && $streamChannel->getType() != $channelType) {
throw new CM_Exception_Invalid('StreamChannel type `' . $streamChannel->getType() . '` doesn\'t match expected value `' . $channelType . '`');
}
if (!$streamChannel) {
/** @var $streamChannel CM_Model_StreamChannel_Message */
$streamChannel = CM_Model_StreamChannel_Message::createType($channelType, array('key' => $channelKey, 'adapterType' => $this->getType()));
}
$streamChannelSubscribes = $streamChannel->getStreamSubscribes();
if ($streamChannelSubscribes->findKey($clientKey)) {
return;
}
CM_Model_Stream_Subscribe::createStatic(array('user' => $user, 'start' => $start, 'streamChannel' => $streamChannel, 'key' => $clientKey));
}
public function testIsSubscriberOrPublisher()
{
/** @var CM_Model_StreamChannel_Mock $streamChannel */
$streamChannel = CM_Model_StreamChannel_Mock::createStatic(array('key' => 'foo', 'adapterType' => CM_MessageStream_Adapter_SocketRedis::getTypeStatic()));
$user1 = CMTest_TH::createUser();
$publish1 = CM_Model_Stream_Publish::createStatic(array('streamChannel' => $streamChannel, 'user' => $user1, 'start' => 123123, 'key' => '1'));
$subscribe1 = CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $user1, 'start' => 123123, 'key' => '2'));
$this->assertTrue($streamChannel->isSubscriberOrPublisher($user1));
$this->assertTrue($streamChannel->isSubscriberOrPublisher($user1, $publish1));
$subscribe1->delete();
$this->assertTrue($streamChannel->isSubscriberOrPublisher($user1));
$this->assertFalse($streamChannel->isSubscriberOrPublisher($user1, $publish1));
$publish1->delete();
$this->assertFalse($streamChannel->isSubscriberOrPublisher($user1));
}
/**
* @param array $status
*/
private function _testSynchronize($status)
{
$adapter = $this->getMockBuilder('CM_MessageStream_Adapter_SocketRedis')->disableOriginalConstructor()->setMethods(array('_fetchStatus'))->getMock();
$adapter->expects($this->any())->method('_fetchStatus')->will($this->returnValue($status));
/** @var $adapter CM_MessageStream_Adapter_SocketRedis */
$adapter->synchronize();
$streamChannels = new CM_Paging_StreamChannel_AdapterType($adapter->getType());
$this->assertSame(count($status), $streamChannels->getCount());
/** @var $streamChannel CM_Model_StreamChannel_Message */
foreach ($streamChannels as $streamChannel) {
$this->assertInstanceOf('CM_Model_StreamChannel_Message', $streamChannel);
$channel = $streamChannel->getKey() . ':' . CM_Model_StreamChannel_Message::getTypeStatic();
$this->assertSame(count($status[$channel]['subscribers']), $streamChannel->getStreamSubscribes()->getCount());
}
foreach ($status as $channel => $channelData) {
list($channelKey, $channelType) = explode(':', $channel);
$streamChannel = CM_Model_StreamChannel_Message::findByKeyAndAdapter($channelKey, $adapter->getType());
$this->assertInstanceOf('CM_Model_StreamChannel_Message', $streamChannel);
foreach ($channelData['subscribers'] as $clientKey => $subscriberData) {
$subscribe = CM_Model_Stream_Subscribe::findByKeyAndChannel($clientKey, $streamChannel);
$this->assertInstanceOf('CM_Model_Stream_Subscribe', $subscribe);
$this->assertSameTime(time() - CM_MessageStream_Adapter_SocketRedis::SYNCHRONIZE_DELAY - 1, $subscribe->getStart());
}
}
}
public function testSynchronizeMissingInJanus()
{
$streamChannel = CMTest_TH::createStreamChannel(null, CM_Janus_Service::getTypeStatic());
$streamPublish = CMTest_TH::createStreamPublish(null, $streamChannel);
$streamSubscribe = CMTest_TH::createStreamSubscribe(null, $streamChannel);
$existingStreamChannel = CMTest_TH::createStreamChannel(null, CM_Janus_Service::getTypeStatic());
$existingStreamPublish = CMTest_TH::createStreamPublish(null, $existingStreamChannel);
$existingStreamSubscribe = CMTest_TH::createStreamSubscribe(null, $existingStreamChannel);
$emptyStreamChannel = CMTest_TH::createStreamChannel(null, CM_Janus_Service::getTypeStatic());
$location = $this->mockClass('CM_Geo_Point')->newInstanceWithoutConstructor();
$server1 = $this->mockClass('CM_Janus_Server')->newInstance([1, 'key', 'http://mock', 'ws://mock', [], $location]);
/** @var CM_Janus_ServerList|\Mocka\AbstractClassTrait $serverList */
$serverList = $this->mockObject('CM_Janus_ServerList');
$serverList->mockMethod('getAll')->set([$server1]);
/** @var CM_Janus_HttpApiClient|\Mocka\AbstractClassTrait $httpApiClient */
$httpApiClient = $this->mockClass('CM_Janus_HttpApiClient')->newInstanceWithoutConstructor();
$httpApiClient->mockMethod('fetchStatus')->set([['id' => $existingStreamPublish->getKey(), 'channelName' => $existingStreamChannel->getKey(), 'isPublish' => true], ['id' => $existingStreamSubscribe->getKey(), 'channelName' => $existingStreamChannel->getKey(), 'isPublish' => false]]);
$janus = new CM_Janus_Service($serverList, $httpApiClient);
$janus->synchronize();
$this->assertEquals($streamChannel, CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamChannel->getKey(), $janus->getType()));
$this->assertEquals($streamPublish, CM_Model_Stream_Publish::findByKeyAndChannel($streamPublish->getKey(), $streamChannel));
$this->assertEquals($streamSubscribe, CM_Model_Stream_Subscribe::findByKeyAndChannel($streamSubscribe->getKey(), $streamChannel));
$this->assertEquals($existingStreamChannel, CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($existingStreamChannel->getKey(), $janus->getType()));
$this->assertEquals($existingStreamPublish, CM_Model_Stream_Publish::findByKeyAndChannel($existingStreamPublish->getKey(), $existingStreamChannel));
$this->assertEquals($existingStreamSubscribe, CM_Model_Stream_Subscribe::findByKeyAndChannel($existingStreamSubscribe->getKey(), $existingStreamChannel));
$this->assertNull(CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($emptyStreamChannel->getKey(), $janus->getType()));
CMTest_TH::timeForward(5);
$janus->synchronize();
$this->assertNull(CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamChannel->getKey(), $janus->getType()));
$this->assertNull(CM_Model_Stream_Publish::findByKeyAndChannel($streamPublish->getKey(), $streamChannel));
$this->assertNull(CM_Model_Stream_Subscribe::findByKeyAndChannel($streamSubscribe->getKey(), $streamChannel));
$this->assertEquals($existingStreamChannel, CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($existingStreamChannel->getKey(), $janus->getType()));
$this->assertEquals($existingStreamPublish, CM_Model_Stream_Publish::findByKeyAndChannel($existingStreamPublish->getKey(), $existingStreamChannel));
$this->assertEquals($existingStreamSubscribe, CM_Model_Stream_Subscribe::findByKeyAndChannel($existingStreamSubscribe->getKey(), $existingStreamChannel));
}
/**
* @param string $streamName
* @param string $clientKey
* @param int $start
* @param string $data
* @throws CM_Exception_NotAllowed
*/
public function subscribe($streamName, $clientKey, $start, $data)
{
$streamName = (string) $streamName;
$clientKey = (string) $clientKey;
$start = (int) $start;
$data = (string) $data;
$user = null;
$params = CM_Params::factory(CM_Params::jsonDecode($data), true);
if ($params->has('sessionId')) {
if ($session = CM_Session::findById($params->getString('sessionId'))) {
$user = $session->getUser(false);
}
}
/** @var CM_Model_StreamChannel_Abstract $streamChannel */
$streamChannel = CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamName, $this->getType());
if (!$streamChannel) {
throw new CM_Exception_NotAllowed();
}
try {
CM_Model_Stream_Subscribe::createStatic(array('streamChannel' => $streamChannel, 'user' => $user, 'start' => $start, 'key' => $clientKey));
} catch (CM_Exception $ex) {
throw new CM_Exception_NotAllowed('Cannot subscribe: ' . $ex->getMessage());
}
}
/**
* @param CM_Model_Stream_Subscribe $videoStreamSubscribe
* @return bool
*/
public function contains(CM_Model_Stream_Subscribe $videoStreamSubscribe)
{
return in_array($videoStreamSubscribe->getId(), $this->getItemsRaw());
}
/**
* @param CM_Model_StreamChannel_Abstract $streamChannel
* @param CM_Model_User $user
* @param string $clientKey
* @param int $start
* @return CM_Model_Stream_Subscribe
* @throws CM_Exception_NotAllowed
* @throws CM_Exception_Invalid
*/
public function createStreamSubscribe(CM_Model_StreamChannel_Abstract $streamChannel, CM_Model_User $user, $clientKey, $start)
{
return CM_Model_Stream_Subscribe::createStatic(['streamChannel' => $streamChannel, 'user' => $user, 'start' => (int) $start, 'key' => (string) $clientKey]);
}
