Initial commit
* Initial repository commit.
* Added skeleton POM.
* Added skeleton modules core and servlet.
* Modified maven POM structure to allow modular building.
* Added initial framework to support the main engine.
* Added initial framework to support the service manager.
* Added test skeletons for the engine and service manager.
* Added definition for the caching service and testing mocks.
* Added initial engine.xml to both main and test resources.
* Added initial log4j properties files.
* Refactored project and maven POM structures to better represent the cache engine being independent from specific project use (IssueCache).
* Cache Engine can be utilized as both a singleton and non-singleton use, based on the application container & EngineFactory use.
* ServiceManager is no longer a singleton, but has reduced scope to package-private for factory method newInstance().
* EngineTestCase now creates a new Engine instance before each test (was singleton re-use).
* Moved Engine singleton initialization to on-demand with the static holder class pattern.
* Added dynamic instanceof check to ServiceManager bean loading to enforce type-checking of injected beans.
* Added new memory cache service package to be used as the default caching service.
* Moved existing unit tests to the same package name as their classes under test to allow package-private scope tests.
* Added additional unit tests.
* Added javadoc for additional interfaces.
* Updated Spring definitions to represent package and class changes.
* Minor POM updates.
* Engine now uses 'cache-engine.xml' as default applicationContext
(was: 'engine.xml').
* Moved engine.xml to cache-engine.xml.
* Moved unit test applicationContext file engine-test.xml to
cache-engine-test.xml.
* Renamed 'servlet' project to 'rest'.
* Additional Spring dependencies added to top-level POM.
* Moved cache module 'memory' into main engine for a simple default.
* Added initial skeleton for 'rest' project. This includes a generic
sample JAX-RS resource and the basic support for jUnit + Jersey test
cases (via Grizzly).

* Formatted XML
* Formatted code
Engine:

* MemoryCacheService is now final.
* MemoryCacheService now has basic debug logging.
* MemoryCacheServiceProvider is now final.
* MemoryCacheValue is now final.
* Parent maven POM now has a mockito 1.9.0 test dependency.

Rest:

* Removed test boilerplate from AdminResource.
* EngineAdapter no longer has convience methods
getCacheServiceProvider() and getCacheService().
* EngineAdapter now will throw a RuntimeException should wrapped Engine
bootstrapping fail.
* Initial ApiResource implementation added to handle JIRA API proxying.
* Initial AuthResource implementation added as a JIRA authentication
resource (TBD).
* Initial interface for CacheAdapter added.
* Initial implementation for SimpleCacheAdapter added.
* Initial implementation for ClientAdapter added.
* Initial interface for RequestCredentials added.
* Initial implementation of RequestCacheKey added.
* Initial implementation for HttpRequestCredentials added.
* Test application configuration 'rest-engine-test.xml' updated with
appropriate beans.
* Test cases updated.
General:
  * Changed maven version from 0.0.1-SNAPSHOT to 0.0.1-DEV across projects.
  * Migrated many maven POM version values to property substitutions.
  * Added project-wide maven maven-jar-plugin to build test jars.
  * Added project-wide maven dependency for power mock.
  * Added project-wide dependencies for "java concurrency in practice" annotations & findbugs reporting.

Engine:
  * Changed engine build final name from 'core' to maven default 'engine'.
  * Added concurrency annotations for many classes.
  * Changed several synchronization points to be function-wide.
  * MockCacheService now operates as a simple in-memory cache for testing.
* Added project support for maven-javadoc-plugin. Javadoc will constructed with javadoc:javadoc phase.
* Fixed several javadoc items which incorrectly referenced classes with '@' values.
* Updated several 'jcip' annotations.
* To separate generic REST code from JIRA-specific resources, created the jira project, and migrated JIRA-specific jersey resources to the new project.* Changed maven build of the rest project from WAR to JAR.
* Jira project configured as a WAR.
* Jira project uses jira-rest-engine-test.xml for spring test configuration, which loads includes bean definitions from rest-engine-test.xml in rest project.

* Renamed artifactId of engine to cache-engine.
* Renamed artifactId of rest to cache-rest.
* Updated services project POM to reflect upstream artifactId changes.

* Moved ApiResource from rest project to jira project.
* Deleted AuthResource, AdminResource, and associated test cases.
* Deleted WEB-INF/* from rest project.
* Modified CacheAdapter and SimpleCacheAdapter package structures.
* ClientAdapter removed in favor of a RestAdapter and a series of Rest interfaces.
* Jersey implementation of Rest interfaces added.
* Placeholder Serialization interfaces added.
* rest-engine-test.xml removed references of jira properties bean, fixed reference to MockRestAdapter.

* EngineAdapter changed to be thread-safe.
* RequestCredentials annotated as immutable.
* RequestCacheKey annotated as immutable.
* Properly removed tracked files.
* Mock caching classes now use singleton / static behavior to emulate a (reusable) cache during testing.
* Formatted source files.
* Moved serialization classes to the provider package (was: adapters).
* Initial implementation of the JacksonSerialization provider.
* Added test cases for serialization.
* CacheAdapter now supports a save() with replacements key-value mapping.
* RestResponse.getResponse() removed.
* Added MockRequestCredentials for test stubbing.
* CacheAdapterTestCase now uses MockRequestCredentials.
* CacheAdapterTestCase now properly uses the adapter method calls to test (was: adapted service methods)
* MockRestAdapter use requires setExpectedXXX() to inject headers, body, and code values into related mock classes (was: fixed static)
* JacksonSerialization provider wired up as Spring bean serializationProvider.
* External library jersey-test-support added to support Jersey test cases + Spring bean wiring.
* jersey-apache-client added as a maven dependency.
* Added riffpie maven repository.
* ApiResource now wired with serializationProvider bean.
* ApiResource.getRequest() modified to support JSON only.
* ApiResource.getRequest() now serializes and caches valid RestResponse objects (was: header + body aggregate).
* RestResourceTestCase changed to leverage jersey-test-support base class AbstractSpringAwareJerseyTest (was: JerseyTest).
* ApiResourceTestCase now sets the MockRestAdapter's expected header, body, and code values before executing each test.
* CacheService and all implementations now operate on byte[] values instead of Serializable.
* CacheService test cases now perform string <-> byte[] checks for correctness.
* ApiResource contains new inner class RestResponseUtils to perform RestResponse <-> Map adaptation for serialization.
* HTTP Response header 'IssueCached' added to JIRA /api responses.
* ApiResource test case checks for both successful non-cached and successful-cached GET requests.
* Jackson dependency updated to 1.9.11
* SimpleCacheAdapter modified to adapt string cache values to engine byte[] values.
* Engine now requires all implementations of CacheService support an additional set() function with a cache timeout parameter.
* MemoryCacheService now implements new required set() function.
* Updated MemoryCacheServiceProvider to have a better named constructor parameter.
* Updated cache-engine.xml to represent the constructor parameter name change in the above.
* Fixed thread sleep interruption in MemoryCacheServiceTestCase.
* Updated MemoryCacheValueTestCase to be final.
* CacheAdapter now requires timeout values passed to save() functions to support change in engine.
* SimpleCacheAdapter and CacheAdapterTestCase updated to support the above.
* ApiResource now requires a bean named "jiraCacheTimeoutProperties" which defines default and per-URL cache timeout values for requests.
* ApiResource "jiraProperties" has been renamed to "jiraUrlProperties".
* jira-rest-engine-test.xml updated to support the above.
* Added log4j.xml in each project's test resources with a default console appender.
* Removed engine test log4j.properties in favor of the above.
* Added unique UUID as a request id to ApiResource, which is placed in the slf4j MDC context as the requestId. This is used in the jira project's log4j.xml to identify a request's logs across thread boundaries.
* Added jira HTTP response header 'IssueCacheId' for diagnostic tracing.
* Fixed SimpleCacheAdapter to enforce UTF-8 string conversion on byte array returned from search().
* ApiResource now will compare request URL against known URL fragments for specific cache timeout values.
* Added placeholder log4j.xml and jira-rest-engine.xml for pending JIRA integration tests.
* Minor javadoc updates.
* Updated Spring and AspectJ version dependencies.
* Create test case for jira requests for failed auth resulting in a skipped-cache response.
* Updated rest project resources for non-test application context use.
* Updated jira project web.xml file to use appropriate servlet bootstrapping for spring and jersey components.
* Updated project's maven setup to use pluginManagement for common versioning.
* Normalized several maven dependencies for fewer repetitions.
* Migrated to SF4j 1.7.2.
* Modified several SF4J Logger cases to use varargs instead of string concatenation.