lars/accred
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Nouveaux fichier suite maj librairies vendor

Browse Source
This commit is contained in:
Caribana
2018-05-01 14:46:24 +02:00
parent 6d5286b888
commit 382b93196c
2318 changed files with 147474 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
vendor/google/auth/src/Cache/SysVCacheItemPool.php vendored Normal file
View File

@@ -0,0 +1,231 @@
<?php
/**
* Copyright 2018 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Google\Auth\Cache;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
/**
* SystemV shared memory based CacheItemPool implementation.
*
* This CacheItemPool implementation can be used among multiple processes, but
* it doesn't provide any locking mechanism. If multiple processes write to
* this ItemPool, you have to avoid race condition manually in your code.
*/
class SysVCacheItemPool implements CacheItemPoolInterface
{
const VAR_KEY = 1;
const DEFAULT_PROJ = 'A';
const DEFAULT_MEMSIZE = 10000;
const DEFAULT_PERM = 0600;
/** @var int */
private $sysvKey;
/**
* @var CacheItemInterface[]
*/
private $items;
/**
* @var CacheItemInterface[]
*/
private $deferredItems;
/**
* @var array
*/
private $options;
/**
* Save the current items.
*
* @return bool true when success, false upon failure
*/
private function saveCurrentItems()
{
$shmid = shm_attach(
$this->sysvKey,
$this->options['memsize'],
$this->options['perm']
);
if ($shmid !== false) {
$ret = shm_put_var(
$shmid,
$this->options['variableKey'],
$this->items
);
shm_detach($shmid);
return $ret;
}
return false;
}
/**
* Load the items from the shared memory.
*
* @return bool true when success, false upon failure
*/
private function loadItems()
{
$shmid = shm_attach(
$this->sysvKey,
$this->options['memsize'],
$this->options['perm']
);
if ($shmid !== false) {
$data = @shm_get_var($shmid, $this->options['variableKey']);
if (!empty($data)) {
$this->items = $data;
} else {
$this->items = [];
}
shm_detach($shmid);
return true;
}
return false;
}
/**
* Create a SystemV shared memory based CacheItemPool.
*
* @param array $options [optional] {
* Configuration options.
*
* @type int $variableKey The variable key for getting the data from
* the shared memory. **Defaults to** 1.
* @type string $proj The project identifier for ftok. This needs to
* be a one character string. **Defaults to** 'A'.
* @type int $memsize The memory size in bytes for shm_attach.
* **Defaults to** 10000.
* @type int $perm The permission for shm_attach. **Defaults to** 0600.
*/
public function __construct($options = [])
{
if (! extension_loaded('sysvshm')) {
throw \RuntimeException(
'sysvshm extension is required to use this ItemPool');
}
$this->options = $options + [
'variableKey' => self::VAR_KEY,
'proj' => self::DEFAULT_PROJ,
'memsize' => self::DEFAULT_MEMSIZE,
'perm' => self::DEFAULT_PERM
];
$this->items = [];
$this->deferredItems = [];
$this->sysvKey = ftok(__FILE__, $this->options['proj']);
$this->loadItems();
}
/**
* {@inheritdoc}
*/
public function getItem($key)
{
$this->loadItems();
return current($this->getItems([$key]));
}
/**
* {@inheritdoc}
*/
public function getItems(array $keys = [])
{
$this->loadItems();
$items = [];
foreach ($keys as $key) {
$items[$key] = $this->hasItem($key) ?
clone $this->items[$key] :
new Item($key);
}
return $items;
}
/**
* {@inheritdoc}
*/
public function hasItem($key)
{
$this->loadItems();
return isset($this->items[$key]) && $this->items[$key]->isHit();
}
/**
* {@inheritdoc}
*/
public function clear()
{
$this->items = [];
$this->deferredItems = [];
return $this->saveCurrentItems();
}
/**
* {@inheritdoc}
*/
public function deleteItem($key)
{
return $this->deleteItems([$key]);
}
/**
* {@inheritdoc}
*/
public function deleteItems(array $keys)
{
foreach ($keys as $key) {
unset($this->items[$key]);
}
return $this->saveCurrentItems();
}
/**
* {@inheritdoc}
*/
public function save(CacheItemInterface $item)
{
$this->items[$item->getKey()] = $item;
return $this->saveCurrentItems();
}
/**
* {@inheritdoc}
*/
public function saveDeferred(CacheItemInterface $item)
{
$this->deferredItems[$item->getKey()] = $item;
return true;
}
/**
* {@inheritdoc}
*/
public function commit()
{
foreach ($this->deferredItems as $item) {
if ($this->save($item) === false) {
return false;
}
}
$this->deferredItems = [];
return true;
}
}

160
vendor/google/auth/tests/Cache/SysVCacheItemPoolTest.php vendored Normal file
View File

@@ -0,0 +1,160 @@
<?php
/*
* Copyright 2018 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Google\Auth\Tests;
use Google\Auth\Cache\SysVCacheItemPool;
use PHPUnit\Framework\TestCase;
class SysVCacheItemPoolTest extends TestCase
{
private $pool;
public function setUp()
{
if (! extension_loaded('sysvshm')) {
$this->markTestSkipped(
'sysvshm extension is required for running the test'
);
}
$this->pool = new SysVCacheItemPool(['variableKey' => 99]);
$this->pool->clear();
}
public function saveItem($key, $value)
{
$item = $this->pool->getItem($key);
$item->set($value);
$this->assertTrue($this->pool->save($item));
return $item;
}
public function testGetsFreshItem()
{
$item = $this->pool->getItem('item');
$this->assertInstanceOf('Google\Auth\Cache\Item', $item);
$this->assertNull($item->get());
$this->assertFalse($item->isHit());
}
public function testCacheAmongProcesses()
{
$expectedValue = 'val-' . rand();
exec(sprintf('php %s/sysv_cache_creator.php %s', __DIR__, $expectedValue));
$this->assertEquals(
$expectedValue,
$this->pool->getItem('separate-process-item')->get()
);
}
public function testGetsExistingItem()
{
$key = 'item';
$value = 'value';
$this->saveItem($key, $value);
$item = $this->pool->getItem($key);
$this->assertInstanceOf('Google\Auth\Cache\Item', $item);
$this->assertEquals($value, $item->get());
$this->assertTrue($item->isHit());
}
public function testGetsMultipleItems()
{
$keys = ['item1', 'item2'];
$items = $this->pool->getItems($keys);
$this->assertEquals($keys, array_keys($items));
$this->assertContainsOnlyInstancesOf('Google\Auth\Cache\Item', $items);
}
public function testHasItem()
{
$existsKey = 'does-exist';
$this->saveItem($existsKey, 'value');
$this->assertTrue($this->pool->hasItem($existsKey));
$this->assertFalse($this->pool->hasItem('does-not-exist'));
}
public function testClear()
{
$key = 'item';
$this->saveItem($key, 'value');
$this->assertTrue($this->pool->hasItem($key));
$this->assertTrue($this->pool->clear());
$this->assertFalse($this->pool->hasItem($key));
}
public function testDeletesItem()
{
$key = 'item';
$this->saveItem($key, 'value');
$this->assertTrue($this->pool->deleteItem($key));
$this->assertFalse($this->pool->hasItem($key));
}
public function testDeletesItems()
{
$keys = ['item1', 'item2'];
foreach ($keys as $key) {
$this->saveItem($key, 'value');
}
$this->assertTrue($this->pool->deleteItems($keys));
$this->assertFalse($this->pool->hasItem($keys[0]));
$this->assertFalse($this->pool->hasItem($keys[1]));
}
public function testSavesItem()
{
$key = 'item';
$this->saveItem($key, 'value');
$this->assertTrue($this->pool->hasItem($key));
}
public function testSavesDeferredItem()
{
$item = $this->pool->getItem('item');
$this->assertTrue($this->pool->saveDeferred($item));
}
public function testCommitsDeferredItems()
{
$keys = ['item1', 'item2'];
foreach ($keys as $key) {
$item = $this->pool->getItem($key);
$item->set('value');
$this->pool->saveDeferred($item);
}
$this->assertTrue($this->pool->commit());
$this->assertTrue($this->pool->hasItem($keys[0]));
$this->assertTrue($this->pool->hasItem($keys[1]));
$this->assertEquals(
$item->get(),
$this->pool->getItem($keys[1])->get()
);
}
}

30
vendor/google/auth/tests/Cache/sysv_cache_creator.php vendored Normal file
View File

@@ -0,0 +1,30 @@
<?php
/*
* Copyright 2018 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Google\Auth\Tests;
require_once __DIR__ . '/../../vendor/autoload.php';
use Google\Auth\Cache\Item;
use Google\Auth\Cache\SysVCacheItemPool;
$value = $argv[1];
// Use the same variableKey in the test.
$pool = new SysVCacheItemPool(['variableKey' => 99]);
$item = new Item('separate-process-item');
$item->set($value);
$pool->save($item);