findbugs: make CdnInfo a static inner class

SIC: Should org.candlepin.resource.EntitlementResource$CdnInfo be a _static_
inner class?

This class is an inner class, but does not use its embedded reference to the
object which created it.  This reference makes the instances of the class
larger, and may keep the reference to the creator object alive longer than
necessary.  If possible, the class should be made static.
findbugs: use more efficient iterator

WMI: org.candlepin.jackson.DynamicFilterData.addFilters(Object, Set) makes
inefficient use of keySet iterator instead of entrySet iterator

This method accesses the value of a Map entry, using a key that was retrieved
from a keySet iterator. It is more efficient to use an iterator on the entrySet
of the map, to avoid the Map.get(key) lookup.
findbugs: make comparator serializable

Se: org.candlepin.sync.EntitlementImporter$QuantityComparator implements
Comparator but not Serializable

This class implements the Comparator interface. You should consider whether or
not it should also implement the Serializable interface. If a comparator is used
to construct an ordered collection such as a TreeMap, then the TreeMap will be
serializable only if the comparator is also serializable. As most comparators
have little or no state, making them serializable is generally easy and good
defensive programming.
findbugs: redundant null check

RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE

RCN: Nullcheck of uc at line 530 of value previously dereferenced in
org.candlepin.sync.Importer.importConsumer(Owner, File, File[],
ConflictOverrides, Meta)

A value is checked here to see whether it is null, but this value can't be null
because it was previously dereferenced and if it were null a null pointer
exception would have occurred at the earlier dereference. Essentially, this code
and the previous dereference disagree as to whether this value is allowed to be
null. Either the check is redundant or the previous dereference is erroneous.
findbugs: remove unused variable

RCN: Redundant nullcheck of exportStream which is known to be null in
org.candlepin.sync.Importer.loadExport(Owner, File, ConflictOverrides)

This method contains a redundant check of a known null value against the
constant null.

We checked a value for !null when it was never assigned to anything
except null. It effectively was never used, so I removed it.
findbugs: gave each class a private static Logger

findbugs suggested that if it was going to be a protected/public static Logger,
then it should also be final. Well that goes down a checkstyle path of requiring
the logger to be all caps: LOG. So either make all of the dependent classes
use LOG

*OR*

I could simply make all of the classes use the same pattern for loggers we have
had so far with all other classes.
findbugs: exposes array

MS: public static org.candlepin.util.ManagerCapability.getCapabilityList() may
expose internal representation by returning ManagerCapability.capabilities

A public static method returns a reference to an array that is part of the
static state of the class. Any code that calls this method can freely modify the
underlying array. One fix is to return a copy of the array.

The fix was simpler, we simply removed the entire ManagerCapability class as
it is just a wrapper for a static array of strings only used by Status class.
Just put the list in Status and move on.
findbugs: close streams to protect against leakage.

OBL: org.candlepin.sync.Exporter.addFileToArchive(ZipOutputStream, int, File)
may fail to clean up java.io.InputStream

This method may fail to clean up (close, dispose of) a stream, database object,
or other resource requiring an explicit cleanup operation.

In general, if a method opens a stream or other resource, the method should use
a try/finally block to ensure that the stream or resource is cleaned up before
the method returns.
findbugs: may fail to clean up java.io.OutputStream

OBL: org.candlepin.sync.Importer.extractArchive(File, File) may fail to clean up
java.io.OutputStream

This method may fail to clean up (close, dispose of) a stream, database object,
or other resource requiring an explicit cleanup operation.

In general, if a method opens a stream or other resource, the method should use
a try/finally block to ensure that the stream or resource is cleaned up before
the method returns.
Merge pull request #441 from candlepin/findbugs

Fix various findbugs as reported by jenkins.