Merge pull request #51 from FriendsOfSymfony/naming

dbu · dbu · commit e0a547397c7e · 2014-04-04T15:05:18.000+02:00
Improve naming (fix #50)
diff --git a/doc/cache-invalidator.md b/doc/cache-invalidator.md
@@ -25,11 +25,11 @@ an [adapter](http://en.wikipedia.org/wiki/Adapter_pattern):
 
 ```php
 use FOS\HttpCache\CacheInvalidator;
-use FOS\HttpCache\Invalidation;
+use FOS\HttpCache\ProxyClient;
 
-$client = new Invalidation\Varnish();
+$client = new ProxyClient\Varnish();
 // or
-$client = new Invalidation\Nginx();
+$client = new ProxyClient\Nginx();
 
 $cacheInvalidator = new CacheInvalidator($client);
 ```
diff --git a/doc/proxy-clients.md b/doc/proxy-clients.md
@@ -5,7 +5,7 @@ You can use the caching proxy clients either wrapped by the cache invalidator
 (recommended), or directly for low-level access to invalidation functionality.
 
 * [Setup](#setup)
-* [CacheProxyInterface](#cacheproxyinterface)
+* [ProxyClientInterface](#cacheproxyinterface)
 * [Purge](#purge)
 * [Refresh](#refresh)
 * [Ban](#ban)
@@ -20,16 +20,16 @@ You should set up at least one caching proxy client:
 
 Then continue here to find out how to use the proxy clients.
 
-CacheProxyInterface
+ProxyClientInterface
 -------------------
 
-Each client is an implementation of [CacheProxyInterface](../src/Invalidation/CacheProxyInterface.php).
+Each client is an implementation of [ProxyClientInterface](../src/ProxyClient/ProxyClientInterface.php).
 All other interfaces, `PurgeInterface`, `RefreshInterface` and `BanInterface`
-extend this `CacheProxyInterface`. So each client implements at least one of
+extend this `ProxyClientInterface`. So each client implements at least one of
 the three [invalidation methods](invalidation-introduction.md#invalidation-methods),
 depending on the caching proxy’s abilities.
 
-The `CacheProxyInterface` has one method: `flush()`. After collecting
+The `ProxyClientInterface` has one method: `flush()`. After collecting
 invalidation requests, `flush()` needs to be called to actually send the
 requests to the caching proxy. This is on purpose: this way, we can send
 all requests together, reducing the performance impact of sending invalidation
diff --git a/doc/varnish-client.md b/doc/varnish-client.md
@@ -14,7 +14,7 @@ that you want to send invalidation requests to. Make sure to include the port
 Varnish runs on if it is not port 80.
 
 ```php
-use FOS\HttpCache\Invalidation\Varnish;
+use FOS\HttpCache\ProxyClient\Varnish;
 
 $servers = array('10.0.0.1', '10.0.0.2:6081'); // Port 80 assumed for 10.0.0.1
 $varnish = new Varnish($servers);
diff --git a/src/CacheInvalidator.php b/src/CacheInvalidator.php
@@ -6,11 +6,11 @@
 use FOS\HttpCache\Exception\InvalidArgumentException;
 use FOS\HttpCache\Exception\ProxyResponseException;
 use FOS\HttpCache\Exception\ProxyUnreachableException;
-use FOS\HttpCache\Exception\UnsupportedInvalidationMethodException;
-use FOS\HttpCache\Invalidation\CacheProxyInterface;
-use FOS\HttpCache\Invalidation\Method\BanInterface;
-use FOS\HttpCache\Invalidation\Method\PurgeInterface;
-use FOS\HttpCache\Invalidation\Method\RefreshInterface;
+use FOS\HttpCache\Exception\UnsupportedProxyOperationException;
+use FOS\HttpCache\ProxyClient\ProxyClientInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\BanInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\PurgeInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\RefreshInterface;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
@@ -38,7 +38,7 @@ class CacheInvalidator
     const INVALIDATE = 'invalidate';
 
     /**
-     * @var CacheProxyInterface
+     * @var ProxyClientInterface
      */
     protected $cache;
 
@@ -55,9 +55,9 @@ class CacheInvalidator
     /**
      * Constructor
      *
-     * @param CacheProxyInterface $cache HTTP cache
+     * @param ProxyClientInterface $cache HTTP cache
      */
-    public function __construct(CacheProxyInterface $cache)
+    public function __construct(ProxyClientInterface $cache)
     {
         $this->cache = $cache;
     }
@@ -159,14 +159,14 @@ public function getTagsHeader()
      *
      * @param string $path Path or URL
      *
-     * @throws UnsupportedInvalidationMethodException
+     * @throws UnsupportedProxyOperationException
      *
      * @return $this
      */
     public function invalidatePath($path)
     {
         if (!$this->cache instanceof PurgeInterface) {
-            throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('PURGE');
+            throw UnsupportedProxyOperationException::cacheDoesNotImplement('PURGE');
         }
 
         $this->cache->purge($path);
@@ -182,14 +182,14 @@ public function invalidatePath($path)
      *
      * @see RefreshInterface::refresh()
      *
-     * @throws UnsupportedInvalidationMethodException
+     * @throws UnsupportedProxyOperationException
      *
      * @return $this
      */
     public function refreshPath($path, array $headers = array())
     {
         if (!$this->cache instanceof RefreshInterface) {
-            throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('REFRESH');
+            throw UnsupportedProxyOperationException::cacheDoesNotImplement('REFRESH');
         }
 
         $this->cache->refresh($path, $headers);
@@ -207,14 +207,14 @@ public function refreshPath($path, array $headers = array())
      *
      * @param array $headers HTTP headers that path must match to be banned.
      *
-     * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests
+     * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests
      *
      * @return $this
      */
     public function invalidate(array $headers)
     {
         if (!$this->cache instanceof BanInterface) {
-            throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');
+            throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');
         }
 
         $this->cache->ban($headers);
@@ -240,14 +240,14 @@ public function invalidate(array $headers)
      * @param array|string $hosts       Regular expression of a host name or list of
      *                                  exact host names to limit banning.
      *
-     * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests
+     * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests
      *
      * @return $this
      */
     public function invalidateRegex($path, $contentType = null, $hosts = null)
     {
         if (!$this->cache instanceof BanInterface) {
-            throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');
+            throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');
         }
 
         $this->cache->banPath($path, $contentType, $hosts);
@@ -263,14 +263,14 @@ public function invalidateRegex($path, $contentType = null, $hosts = null)
      *
      * @param array $tags Cache tags
      *
-     * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests
+     * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests
      *
      * @return $this
      */
     public function invalidateTags(array $tags)
     {
         if (!$this->cache instanceof BanInterface) {
-            throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');
+            throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');
         }
 
         $headers = array($this->getTagsHeader() => '('.implode('|', $tags).')(,.+)?$');
diff --git a/src/Exception/ExceptionCollection.php b/src/Exception/ExceptionCollection.php
@@ -4,7 +4,7 @@
 
 /**
  * A collection of exceptions that might occur during the flush operation of a
- * CacheProxyInterface implementation
+ * ProxyClientInterface implementation
  */
 class ExceptionCollection extends \Exception implements \IteratorAggregate, \Countable,  HttpCacheExceptionInterface
 {
diff --git a/src/Exception/UnsupportedProxyOperationException.php b/src/Exception/UnsupportedProxyOperationException.php
@@ -6,12 +6,12 @@
  * Thrown when the CacheInvalidator is asked for an operation the underlying
  * cache proxy does not support.
  */
-class UnsupportedInvalidationMethodException extends \RuntimeException implements HttpCacheExceptionInterface
+class UnsupportedProxyOperationException extends \RuntimeException implements HttpCacheExceptionInterface
 {
     /**
      * @param string $method Name of the HTTP method that would be required.
      *
-     * @return UnsupportedInvalidationMethodException
+     * @return UnsupportedProxyOperationException
      */
     public static function cacheDoesNotImplement($method)
     {
diff --git a/src/ProxyClient/AbstractProxyClient.php b/src/ProxyClient/AbstractProxyClient.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation;
+namespace FOS\HttpCache\ProxyClient;
 
 use FOS\HttpCache\Exception\ExceptionCollection;
 use FOS\HttpCache\Exception\InvalidUrlException;
@@ -18,7 +18,7 @@
  *
  * @author David de Boer <david@driebit.nl>
  */
-abstract class AbstractCacheProxy implements CacheProxyInterface
+abstract class AbstractProxyClient implements ProxyClientInterface
 {
     /**
      * IP addresses/hostnames of all caching proxy servers
diff --git a/src/ProxyClient/Invalidation/BanInterface.php b/src/ProxyClient/Invalidation/BanInterface.php
@@ -1,14 +1,14 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation\Method;
+namespace FOS\HttpCache\ProxyClient\Invalidation;
 
-use FOS\HttpCache\Invalidation\CacheProxyInterface;
+use FOS\HttpCache\ProxyClient\ProxyClientInterface;
 
 /**
  * An HTTP cache that supports invalidation by banning, that is, removing
  * objects from the cache that match a regular expression
  */
-interface BanInterface extends CacheProxyInterface
+interface BanInterface extends ProxyClientInterface
 {
     const REGEX_MATCH_ALL = '.*';
     const CONTENT_TYPE_ALL = self::REGEX_MATCH_ALL;
diff --git a/src/ProxyClient/Invalidation/PurgeInterface.php b/src/ProxyClient/Invalidation/PurgeInterface.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation\Method;
+namespace FOS\HttpCache\ProxyClient\Invalidation;
 
-use FOS\HttpCache\Invalidation\CacheProxyInterface;
+use FOS\HttpCache\ProxyClient\ProxyClientInterface;
 
 /**
  * An HTTP cache that supports invalidation by purging, that is, removing one
@@ -11,7 +11,7 @@
  * Implementations should be configurable with a default host to be able to
  * handle purge calls that do not contain a full URL but only a path.
  */
-interface PurgeInterface extends CacheProxyInterface
+interface PurgeInterface extends ProxyClientInterface
 {
     /**
      * Purge a URL
diff --git a/src/ProxyClient/Invalidation/RefreshInterface.php b/src/ProxyClient/Invalidation/RefreshInterface.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation\Method;
+namespace FOS\HttpCache\ProxyClient\Invalidation;
 
-use FOS\HttpCache\Invalidation\CacheProxyInterface;
+use FOS\HttpCache\ProxyClient\ProxyClientInterface;
 
 /**
  * An HTTP cache that supports invalidation by refresh requests that force a
@@ -11,7 +11,7 @@
  * Implementations should be configurable with a default host to be able to
  * handle refresh calls that do not contain a full URL but only a path.
  */
-interface RefreshInterface extends CacheProxyInterface
+interface RefreshInterface extends ProxyClientInterface
 {
     /**
      * Refresh a URL.
diff --git a/src/ProxyClient/ProxyClientInterface.php b/src/ProxyClient/ProxyClientInterface.php
@@ -1,15 +1,15 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation;
+namespace FOS\HttpCache\ProxyClient;
 
 use FOS\HttpCache\Exception\ExceptionCollection;
 
 /**
- * An HTTP caching reverse proxy.
+ * An HTTP caching reverse proxy client
  *
- * Implementations should implement at least one of the Method interfaces.
+ * Implementations should implement at least one of the Invalidation interfaces.
  */
-interface CacheProxyInterface
+interface ProxyClientInterface
 {
     /**
      * Send all pending invalidation requests.
diff --git a/src/ProxyClient/Varnish.php b/src/ProxyClient/Varnish.php
@@ -1,19 +1,19 @@
 <?php
 
-namespace FOS\HttpCache\Invalidation;
+namespace FOS\HttpCache\ProxyClient;
 
 use FOS\HttpCache\Exception\InvalidArgumentException;
 use FOS\HttpCache\Exception\MissingHostException;
-use FOS\HttpCache\Invalidation\Method\BanInterface;
-use FOS\HttpCache\Invalidation\Method\PurgeInterface;
-use FOS\HttpCache\Invalidation\Method\RefreshInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\BanInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\PurgeInterface;
+use FOS\HttpCache\ProxyClient\Invalidation\RefreshInterface;
 
 /**
  * Varnish HTTP cache invalidator.
  *
  * @author David de Boer <david@driebit.nl>
  */
-class Varnish extends AbstractCacheProxy implements BanInterface, PurgeInterface, RefreshInterface
+class Varnish extends AbstractProxyClient implements BanInterface, PurgeInterface, RefreshInterface
 {
     const HTTP_METHOD_BAN          = 'BAN';
     const HTTP_METHOD_PURGE        = 'PURGE';
diff --git a/tests/Functional/VarnishTest.php b/tests/Functional/VarnishTest.php
@@ -2,7 +2,7 @@
 
 namespace FOS\HttpCache\Tests\Functional;
 
-use FOS\HttpCache\Invalidation\Varnish;
+use FOS\HttpCache\ProxyClient\Varnish;
 use FOS\HttpCache\Tests\VarnishTestCase;
 
 /**
diff --git a/tests/Unit/CacheInvalidatorTest.php b/tests/Unit/CacheInvalidatorTest.php
diff --git a/tests/Unit/ProxyClient/VarnishTest.php b/tests/Unit/ProxyClient/VarnishTest.php
diff --git a/tests/VarnishTestCase.php b/tests/VarnishTestCase.php

Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@`
`6`	`6`	`use FOS\HttpCache\Exception\InvalidArgumentException;`
`7`	`7`	`use FOS\HttpCache\Exception\ProxyResponseException;`
`8`	`8`	`use FOS\HttpCache\Exception\ProxyUnreachableException;`
`9`		`-use FOS\HttpCache\Exception\UnsupportedInvalidationMethodException;`
`10`		`-use FOS\HttpCache\Invalidation\CacheProxyInterface;`
`11`		`-use FOS\HttpCache\Invalidation\Method\BanInterface;`
`12`		`-use FOS\HttpCache\Invalidation\Method\PurgeInterface;`
`13`		`-use FOS\HttpCache\Invalidation\Method\RefreshInterface;`
	`9`	`+use FOS\HttpCache\Exception\UnsupportedProxyOperationException;`
	`10`	`+use FOS\HttpCache\ProxyClient\ProxyClientInterface;`
	`11`	`+use FOS\HttpCache\ProxyClient\Invalidation\BanInterface;`
	`12`	`+use FOS\HttpCache\ProxyClient\Invalidation\PurgeInterface;`
	`13`	`+use FOS\HttpCache\ProxyClient\Invalidation\RefreshInterface;`
`14`	`14`	`use Symfony\Component\EventDispatcher\EventDispatcher;`
`15`	`15`	`use Symfony\Component\EventDispatcher\EventDispatcherInterface;`
`16`	`16`	`use Symfony\Component\EventDispatcher\EventSubscriberInterface;`
`@@ -38,7 +38,7 @@ class CacheInvalidator`
`38`	`38`	`const INVALIDATE = 'invalidate';`
`39`	`39`
`40`	`40`	`/**`
`41`		`- * @var CacheProxyInterface`
	`41`	`+ * @var ProxyClientInterface`
`42`	`42`	`*/`
`43`	`43`	`protected $cache;`
`44`	`44`
`@@ -55,9 +55,9 @@ class CacheInvalidator`
`55`	`55`	`/**`
`56`	`56`	`* Constructor`
`57`	`57`	`*`
`58`		`- * @param CacheProxyInterface $cache HTTP cache`
	`58`	`+ * @param ProxyClientInterface $cache HTTP cache`
`59`	`59`	`*/`
`60`		`- public function __construct(CacheProxyInterface $cache)`
	`60`	`+ public function __construct(ProxyClientInterface $cache)`
`61`	`61`	`{`
`62`	`62`	`$this->cache = $cache;`
`63`	`63`	`}`
`@@ -159,14 +159,14 @@ public function getTagsHeader()`
`159`	`159`	`*`
`160`	`160`	`* @param string $path Path or URL`
`161`	`161`	`*`
`162`		`- * @throws UnsupportedInvalidationMethodException`
	`162`	`+ * @throws UnsupportedProxyOperationException`
`163`	`163`	`*`
`164`	`164`	`* @return $this`
`165`	`165`	`*/`
`166`	`166`	`public function invalidatePath($path)`
`167`	`167`	`{`
`168`	`168`	`if (!$this->cache instanceof PurgeInterface) {`
`169`		`- throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('PURGE');`
	`169`	`+ throw UnsupportedProxyOperationException::cacheDoesNotImplement('PURGE');`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`$this->cache->purge($path);`
`@@ -182,14 +182,14 @@ public function invalidatePath($path)`
`182`	`182`	`*`
`183`	`183`	`* @see RefreshInterface::refresh()`
`184`	`184`	`*`
`185`		`- * @throws UnsupportedInvalidationMethodException`
	`185`	`+ * @throws UnsupportedProxyOperationException`
`186`	`186`	`*`
`187`	`187`	`* @return $this`
`188`	`188`	`*/`
`189`	`189`	`public function refreshPath($path, array $headers = array())`
`190`	`190`	`{`
`191`	`191`	`if (!$this->cache instanceof RefreshInterface) {`
`192`		`- throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('REFRESH');`
	`192`	`+ throw UnsupportedProxyOperationException::cacheDoesNotImplement('REFRESH');`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`$this->cache->refresh($path, $headers);`
`@@ -207,14 +207,14 @@ public function refreshPath($path, array $headers = array())`
`207`	`207`	`*`
`208`	`208`	`* @param array $headers HTTP headers that path must match to be banned.`
`209`	`209`	`*`
`210`		`- * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests`
	`210`	`+ * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests`
`211`	`211`	`*`
`212`	`212`	`* @return $this`
`213`	`213`	`*/`
`214`	`214`	`public function invalidate(array $headers)`
`215`	`215`	`{`
`216`	`216`	`if (!$this->cache instanceof BanInterface) {`
`217`		`- throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');`
	`217`	`+ throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`$this->cache->ban($headers);`
`@@ -240,14 +240,14 @@ public function invalidate(array $headers)`
`240`	`240`	`* @param array\|string $hosts Regular expression of a host name or list of`
`241`	`241`	`* exact host names to limit banning.`
`242`	`242`	`*`
`243`		`- * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests`
	`243`	`+ * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests`
`244`	`244`	`*`
`245`	`245`	`* @return $this`
`246`	`246`	`*/`
`247`	`247`	`public function invalidateRegex($path, $contentType = null, $hosts = null)`
`248`	`248`	`{`
`249`	`249`	`if (!$this->cache instanceof BanInterface) {`
`250`		`- throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');`
	`250`	`+ throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`$this->cache->banPath($path, $contentType, $hosts);`
`@@ -263,14 +263,14 @@ public function invalidateRegex($path, $contentType = null, $hosts = null)`
`263`	`263`	`*`
`264`	`264`	`* @param array $tags Cache tags`
`265`	`265`	`*`
`266`		`- * @throws UnsupportedInvalidationMethodException If HTTP cache does not support BAN requests`
	`266`	`+ * @throws UnsupportedProxyOperationException If HTTP cache does not support BAN requests`
`267`	`267`	`*`
`268`	`268`	`* @return $this`
`269`	`269`	`*/`
`270`	`270`	`public function invalidateTags(array $tags)`
`271`	`271`	`{`
`272`	`272`	`if (!$this->cache instanceof BanInterface) {`
`273`		`- throw UnsupportedInvalidationMethodException::cacheDoesNotImplement('BAN');`
	`273`	`+ throw UnsupportedProxyOperationException::cacheDoesNotImplement('BAN');`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`$headers = array($this->getTagsHeader() => '('.implode('\|', $tags).')(,.+)?$');`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`/**`
`6`	`6`	`* A collection of exceptions that might occur during the flush operation of a`
`7`		`- * CacheProxyInterface implementation`
	`7`	`+ * ProxyClientInterface implementation`
`8`	`8`	`*/`
`9`	`9`	`class ExceptionCollection extends \Exception implements \IteratorAggregate, \Countable, HttpCacheExceptionInterface`
`10`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@`
`6`	`6`	`* Thrown when the CacheInvalidator is asked for an operation the underlying`
`7`	`7`	`* cache proxy does not support.`
`8`	`8`	`*/`
`9`		`-class UnsupportedInvalidationMethodException extends \RuntimeException implements HttpCacheExceptionInterface`
	`9`	`+class UnsupportedProxyOperationException extends \RuntimeException implements HttpCacheExceptionInterface`
`10`	`10`	`{`
`11`	`11`	`/**`
`12`	`12`	`* @param string $method Name of the HTTP method that would be required.`
`13`	`13`	`*`
`14`		`- * @return UnsupportedInvalidationMethodException`
	`14`	`+ * @return UnsupportedProxyOperationException`
`15`	`15`	`*/`
`16`	`16`	`public static function cacheDoesNotImplement($method)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`<?php`
`2`	`2`
`3`		`-namespace FOS\HttpCache\Invalidation;`
	`3`	`+namespace FOS\HttpCache\ProxyClient;`
`4`	`4`
`5`	`5`	`use FOS\HttpCache\Exception\ExceptionCollection;`
`6`	`6`	`use FOS\HttpCache\Exception\InvalidUrlException;`
`@@ -18,7 +18,7 @@`
`18`	`18`	`*`
`19`	`19`	`* @author David de Boer <[email protected]>`
`20`	`20`	`*/`
`21`		`-abstract class AbstractCacheProxy implements CacheProxyInterface`
	`21`	`+abstract class AbstractProxyClient implements ProxyClientInterface`
`22`	`22`	`{`
`23`	`23`	`/**`
`24`	`24`	`* IP addresses/hostnames of all caching proxy servers`