/**
* @param array[] $paramsList
* @return mixed[]
* @throws CM_Exception
*/
public function runMultiple(array $paramsList)
{
$this->_verifyParams($paramsList);
if (!$this->_getGearmanEnabled()) {
return $this->_runMultipleWithoutGearman($paramsList);
}
$resultList = array();
$gearmanClient = $this->_getGearmanClient();
$gearmanClient->setCompleteCallback(function (GearmanTask $task) use(&$resultList) {
$resultList[] = CM_Params::decode($task->data(), true);
});
$failureList = array();
$gearmanClient->setFailCallback(function (GearmanTask $task) use(&$failureList) {
$failureList[] = $task;
});
foreach ($paramsList as $params) {
$workload = CM_Params::encode($params, true);
$task = $gearmanClient->addTask($this->_getJobName(), $workload);
if (false === $task) {
throw new CM_Exception('Cannot add task `' . $this->_getJobName() . '`.');
}
}
$gearmanClient->runTasks();
if (count($resultList) != count($paramsList)) {
throw new CM_Exception('Job `' . $this->_getJobName() . '` failed (' . count($resultList) . '/' . count($paramsList) . ' results).');
}
return $resultList;
}
public function queueOutstanding()
{
$executeAtMax = time();
$result = CM_Db_Db::select('cm_jobdistribution_delayedqueue', '*', '`executeAt` <= ' . $executeAtMax, '`executeAt` ASC');
while ($row = $result->fetch()) {
$job = $this->_instantiateJob($row['className']);
if ($job) {
$job->queue(CM_Params::decode($row['params'], true));
}
}
CM_Db_Db::delete('cm_jobdistribution_delayedqueue', '`executeAt` <= ' . $executeAtMax);
}
public function synchronize()
{
$startStampLimit = time() - 3;
$status = array();
foreach (CM_Stream_Video::getInstance()->getServers() as $serverId => $wowzaServer) {
$singleStatus = CM_Params::decode($this->_fetchStatus($wowzaServer['privateIp']), true);
foreach ($singleStatus as $streamName => $publish) {
$publish['serverId'] = $serverId;
$publish['serverHost'] = $wowzaServer['privateIp'];
$status[$streamName] = $publish;
}
}
$streamChannels = $this->_getStreamChannels();
foreach ($status as $streamName => $publish) {
/** @var CM_Model_StreamChannel_Abstract $streamChannel */
$streamChannel = CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamName, $this->getType());
if (!$streamChannel || !$streamChannel->getStreamPublishs()->findKey($publish['clientId'])) {
$this->_stopClient($publish['clientId'], $publish['serverHost']);
}
foreach ($publish['subscribers'] as $clientId => $subscribe) {
if (!$streamChannel || !$streamChannel->getStreamSubscribes()->findKey($clientId)) {
$this->_stopClient($clientId, $publish['serverHost']);
}
}
}
/** @var CM_Model_StreamChannel_Abstract $streamChannel */
foreach ($streamChannels as $streamChannel) {
if (!$streamChannel->hasStreams()) {
$streamChannel->delete();
continue;
}
/** @var CM_Model_Stream_Publish $streamPublish */
$streamPublish = $streamChannel->getStreamPublishs()->getItem(0);
if ($streamPublish) {
if ($streamPublish->getStart() > $startStampLimit) {
continue;
}
if (!isset($status[$streamChannel->getKey()])) {
$this->unpublish($streamChannel->getKey());
}
}
/** @var CM_Model_Stream_Subscribe $streamSubscribe */
foreach ($streamChannel->getStreamSubscribes() as $streamSubscribe) {
if ($streamSubscribe->getStart() > $startStampLimit) {
continue;
}
if (!isset($status[$streamChannel->getKey()]['subscribers'][$streamSubscribe->getKey()])) {
$this->unsubscribe($streamChannel->getKey(), $streamSubscribe->getKey());
}
}
}
}
public function testPublish()
{
$adapter = $this->mockObject('CM_MessageStream_Adapter_Abstract');
$publishMethod = $adapter->mockMethod('publish')->set(function ($channel, $event, $data) {
$this->assertSame('channel', $channel);
$this->assertSame('event', $event);
$this->assertSame(['foo' => 'bar'], CM_Params::decode($data));
});
/** @var CM_MessageStream_Service|\Mocka\AbstractClassTrait $stream */
$stream = $this->mockObject('CM_MessageStream_Service', [$adapter]);
$stream->publish('channel', 'event', ['foo' => 'bar']);
$this->assertSame(1, $publishMethod->getCallCount());
$stream->mockMethod('getEnabled')->set(false);
$stream->publish('channel', 'event', ['foo' => 'bar']);
$this->assertSame(1, $publishMethod->getCallCount());
}
public function testDecodeRecursive()
{
$object = $this->mockClass(null, ['CM_ArrayConvertible', 'JsonSerializable']);
$nestedArrayConvertible = $this->mockClass(null, ['CM_ArrayConvertible']);
$nestedJsonSerializable = $this->mockClass(null, ['JsonSerializable']);
$encodedArrayConvertible = ['_class' => $nestedArrayConvertible->getClassName(), 'foo' => 2];
$encodedJsonSerializable = ['_class' => $nestedJsonSerializable->getClassName(), 'bar' => 2];
$encodedObject = ['_class' => $object->getClassName(), 'foo' => 1, 'nested1' => $encodedArrayConvertible, 'bar' => 1, 'nested2' => $encodedJsonSerializable];
$fromArrayMethodObject = $object->mockStaticMethod('fromArray')->set(function ($encoded) use($encodedJsonSerializable) {
$this->assertSame(['foo' => 1, 'nested1' => 2, 'bar' => 1, 'nested2' => $encodedJsonSerializable], $encoded);
return [$encoded['foo'], $encoded['nested1']];
});
$fromArrayMethodNestedObject = $nestedArrayConvertible->mockStaticMethod('fromArray')->set(function ($encoded) {
$this->assertSame(['foo' => 2], $encoded);
return $encoded['foo'];
});
$this->assertEquals([1, 2], CM_Params::decode($encodedObject));
$this->assertSame(1, $fromArrayMethodNestedObject->getCallCount());
$this->assertSame(1, $fromArrayMethodObject->getCallCount());
}
/**
* @param string $url
* @param array|null $query
* @param array|null $headers
* @param CM_Frontend_ViewResponse|null $scopeView
* @param CM_Frontend_ViewResponse|null $scopeComponent
* @return CM_Http_Request_Post|\Mocka\AbstractClassTrait
* @throws Mocka\Exception
*/
public function createRequest($url, array $query = null, array $headers = null, CM_Frontend_ViewResponse $scopeView = null, CM_Frontend_ViewResponse $scopeComponent = null)
{
$url = (string) $url;
$query = (array) $query;
if (!$headers) {
$site = CM_Site_Abstract::factory();
$headers = array('host' => $site->getHost());
}
$getViewInfo = function (CM_Frontend_ViewResponse $viewResponse) {
/**
* Simulate sending view-params to client and back (remove any objects)
*/
$viewParams = $viewResponse->getView()->getParams()->getParamsDecoded();
$viewParams = CM_Params::decode(CM_Params::encode($viewParams, true), true);
return array('id' => $viewResponse->getAutoId(), 'className' => get_class($viewResponse->getView()), 'params' => $viewParams);
};
$viewInfoList = array_map($getViewInfo, array_filter(['CM_View_Abstract' => $scopeView, 'CM_Component_Abstract' => $scopeComponent]));
if ($viewInfoList) {
$query['viewInfoList'] = $viewInfoList;
}
$mockClass = $this->mockClass('CM_Http_Request_Post');
$mockClass->mockMethod('getQuery')->set(function () use($query) {
return $query;
});
$mockClass->mockMethod('getIp')->set(function () {
return '16909060';
});
return $mockClass->newInstance([$url, $headers]);
}
/**
* @param string $key
* @param CM_Params|null $default
* @return CM_Params
* @throws CM_Exception_Invalid
*/
public function getParams($key, CM_Params $default = null)
{
$param = $this->getObject($key, 'CM_Params', $default, function ($className, $param) {
if (is_string($param)) {
$json = (string) $param;
try {
$array = CM_Params::decode($json, true);
} catch (CM_Exception_Invalid $e) {
throw new CM_Exception_InvalidParam('Cannot decode input', null, ['message' => $e->getMessage()]);
}
} elseif (is_array($param)) {
$array = $param;
} else {
throw new CM_Exception_InvalidParam('Unexpected type of arguments', null, ['type' => gettype($param)]);
}
return CM_Params::factory($array, false);
});
if (!$param instanceof CM_Params) {
throw new CM_Exception_Invalid('Not a CM_Params');
}
return $param;
}
public function testLoadComponent()
{
$response = $this->getResponseAjax(new CM_Component_Graph(), 'loadComponent', ['className' => 'CM_Component_Graph', 'series' => []]);
$this->assertViewResponseSuccess($response);
$successContent = CM_Params::decode($response->getContent(), true)['success'];
$autoId = $successContent['data']['autoId'];
$this->assertNotEmpty($autoId);
$html = new CM_Dom_NodeList($successContent['data']['html']);
$this->assertSame($autoId, $html->getAttribute('id'));
$this->assertArrayNotHasKey('exec', $successContent);
$this->assertContains('new CM_Component_Graph', $successContent['data']['js']);
}
public function testDecodeArrayConvertible()
{
$arrayConvertibleClass = $this->mockInterface('CM_ArrayConvertible');
$fromArrayMethod = $arrayConvertibleClass->mockStaticMethod('fromArray')->set(function ($encoded) {
$this->assertSame(['foo' => 1], $encoded);
return $encoded['foo'];
});
$encodedArrayConvertible = ['foo' => 1, '_class' => get_class($arrayConvertibleClass->newInstance())];
$this->assertEquals(1, CM_Params::decode($encodedArrayConvertible));
$this->assertSame(1, $fromArrayMethod->getCallCount());
}
