Coverage Report

Coverage Report - org.kuali.student.common.util.ManifestInspector

Classes in this File

Line Coverage

Branch Coverage

Complexity

ManifestInspector

71%

38/53

65%

17/26

5.8

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community 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.osedu.org/licenses/ECL-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.
  */
 
 package org.kuali.student.common.util;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.jar.Attributes;
 import java.util.jar.Manifest;
 
 import javax.servlet.ServletContext;
 
 import static org.apache.commons.io.IOUtils.*;
 import static org.apache.commons.lang.StringUtils.*;
 
 /**
  * Obtains version information about the application from the META-INF/MANIFEST.MF file contained inside a .war file
  */
 public class ManifestInspector {
 
         /**
          * Location of the MANIFEST.MF file
          */
         public static final String MANIFEST_LOCATION = "/META-INF/MANIFEST.MF";
         public static final String BUNDLE_NAME = "Bundle-Name";
         public static final String BUNDLE_VERSION = "Bundle-Version";
         public static final String BUNDLE_TIMESTAMP = "Bundle-Timestamp";
         public static final String BUNDLE_BUILD_NUMBER = "Bundle-BuildNumber";
         public static final String NO_BUILD_INFORMATION_AVAILABLE = "No build information available";
 
         /**
          * Return a Manifest object
          */
         protected Manifest getManifest(ServletContext servletContext) throws IOException {
                 InputStream in = null;
                 try {
                         in = servletContext.getResourceAsStream(MANIFEST_LOCATION);
                         if (in == null) {
                                 return null;
                         } else {
                                 return new Manifest(in);
                         }
                 } catch (IOException e) {
                         throw e;
                 } finally {
                         closeQuietly(in);
                 }
         }
 
         /**
          * Examine the manifest provided for build information. Returns null if manifest is null
          */
         protected BuildInformation getBuildInformation(Manifest manifest) {
                 // No Manifest is available
                 if (manifest == null) {
                         return null;
                 }
 
                 // Extract the attributes
                 Attributes attributes = manifest.getMainAttributes();
 
                 // Manifest attributes containing the build information
                 String name = attributes.getValue(BUNDLE_NAME);
                 String version = attributes.getValue(BUNDLE_VERSION);
                 String buildNumber = attributes.getValue(BUNDLE_BUILD_NUMBER);
                 String timestamp = attributes.getValue(BUNDLE_TIMESTAMP);
 
                 // Create and populate a BuildInformation object
                 BuildInformation bi = new BuildInformation();
                 bi.setName(name);
                 bi.setVersion(version);
                 bi.setBuildNumber(buildNumber);
                 bi.setTimestamp(timestamp);
                 return bi;
         }
 
         /**
          * Obtain version information from MANIFEST.MF
          */
         public String getBuildInformationString(ServletContext context) throws IOException {
                 // Get a handle to a Manifest object
                 Manifest manifest = getManifest(context);
 
                 // Store build information attributes from the manifest into a POJO
                 BuildInformation buildInformation = getBuildInformation(manifest);
 
                 // Convert the POJO to a string
                 return toString(buildInformation);
         }
 
         /**
          * Return true if BuildInformation is null or does not contain any meaningful information.
          */
         protected boolean isNullOrEmpty(BuildInformation bi) {
                 if (bi == null) {
                         return true;
                 }
                 if (!isEmpty(bi.getName())) {
                         return false;
                 }
                 if (!isEmpty(bi.getVersion())) {
                         return false;
                 }
                 if (!isEmpty(bi.getBuildNumber())) {
                         return false;
                 }
                 if (!isEmpty(bi.getTimestamp())) {
                         return false;
                 }
                 return true;
         }
 
         /**
          * Convert the build information POJO to a display String
          */
         public String toString(BuildInformation bi) {
                 /**
                  * For developers pointed at a local build, MANIFEST.MF may not be present
                  * 
                  * Since we overlay the Rice war file, the MANIFEST.MF from Rice may be present but doesn't contain build
                  * information
                  */
                 if (isNullOrEmpty(bi)) {
                         return NO_BUILD_INFORMATION_AVAILABLE;
                 }
 
                 /**
                  * Build number is only present if Hudson has done the build
                  */
                 if (!isEmpty(bi.getBuildNumber())) {
                         bi.setBuildNumber("#" + bi.getBuildNumber());
                 }
 
                 /**
                  * Build a string out of the build information
                  */
                 StringBuffer sb = new StringBuffer();
                 if (!isEmpty(bi.getName())) {
                         sb.append(bi.getName());
                         sb.append(" :: ");
                 }
                 if (!isEmpty(bi.getVersion())) {
                         sb.append(bi.getVersion());
                         sb.append(" :: ");
                 }
                 if (!isEmpty(bi.getBuildNumber())) {
                         sb.append(bi.getBuildNumber());
                         sb.append(" :: ");
                 }
                 if (!isEmpty(bi.getTimestamp())) {
                         sb.append(bi.getTimestamp());
                 }
                 return sb.toString();
         }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.util;
17
18		import java.io.IOException;
19		import java.io.InputStream;
20		import java.util.jar.Attributes;
21		import java.util.jar.Manifest;
22
23		import javax.servlet.ServletContext;
24
25		import static org.apache.commons.io.IOUtils.*;
26		import static org.apache.commons.lang.StringUtils.*;
27
28		/**
29		* Obtains version information about the application from the META-INF/MANIFEST.MF file contained inside a .war file
30		*/
31	4	public class ManifestInspector {
32
33		/**
34		* Location of the MANIFEST.MF file
35		*/
36		public static final String MANIFEST_LOCATION = "/META-INF/MANIFEST.MF";
37		public static final String BUNDLE_NAME = "Bundle-Name";
38		public static final String BUNDLE_VERSION = "Bundle-Version";
39		public static final String BUNDLE_TIMESTAMP = "Bundle-Timestamp";
40		public static final String BUNDLE_BUILD_NUMBER = "Bundle-BuildNumber";
41		public static final String NO_BUILD_INFORMATION_AVAILABLE = "No build information available";
42
43		/**
44		* Return a Manifest object
45		*/
46		protected Manifest getManifest(ServletContext servletContext) throws IOException {
47	0	InputStream in = null;
48		try {
49	0	in = servletContext.getResourceAsStream(MANIFEST_LOCATION);
50	0	if (in == null) {
51	0	return null;
52		} else {
53	0	return new Manifest(in);
54		}
55	0	} catch (IOException e) {
56	0	throw e;
57		} finally {
58	0	closeQuietly(in);
59		}
60		}
61
62		/**
63		* Examine the manifest provided for build information. Returns null if manifest is null
64		*/
65		protected BuildInformation getBuildInformation(Manifest manifest) {
66		// No Manifest is available
67	4	if (manifest == null) {
68	1	return null;
69		}
70
71		// Extract the attributes
72	3	Attributes attributes = manifest.getMainAttributes();
73
74		// Manifest attributes containing the build information
75	3	String name = attributes.getValue(BUNDLE_NAME);
76	3	String version = attributes.getValue(BUNDLE_VERSION);
77	3	String buildNumber = attributes.getValue(BUNDLE_BUILD_NUMBER);
78	3	String timestamp = attributes.getValue(BUNDLE_TIMESTAMP);
79
80		// Create and populate a BuildInformation object
81	3	BuildInformation bi = new BuildInformation();
82	3	bi.setName(name);
83	3	bi.setVersion(version);
84	3	bi.setBuildNumber(buildNumber);
85	3	bi.setTimestamp(timestamp);
86	3	return bi;
87		}
88
89		/**
90		* Obtain version information from MANIFEST.MF
91		*/
92		public String getBuildInformationString(ServletContext context) throws IOException {
93		// Get a handle to a Manifest object
94	0	Manifest manifest = getManifest(context);
95
96		// Store build information attributes from the manifest into a POJO
97	0	BuildInformation buildInformation = getBuildInformation(manifest);
98
99		// Convert the POJO to a string
100	0	return toString(buildInformation);
101		}
102
103		/**
104		* Return true if BuildInformation is null or does not contain any meaningful information.
105		*/
106		protected boolean isNullOrEmpty(BuildInformation bi) {
107	6	if (bi == null) {
108	0	return true;
109		}
110	6	if (!isEmpty(bi.getName())) {
111	4	return false;
112		}
113	2	if (!isEmpty(bi.getVersion())) {
114	0	return false;
115		}
116	2	if (!isEmpty(bi.getBuildNumber())) {
117	0	return false;
118		}
119	2	if (!isEmpty(bi.getTimestamp())) {
120	0	return false;
121		}
122	2	return true;
123		}
124
125		/**
126		* Convert the build information POJO to a display String
127		*/
128		public String toString(BuildInformation bi) {
129		/**
130		* For developers pointed at a local build, MANIFEST.MF may not be present
131		*
132		* Since we overlay the Rice war file, the MANIFEST.MF from Rice may be present but doesn't contain build
133		* information
134		*/
135	3	if (isNullOrEmpty(bi)) {
136	1	return NO_BUILD_INFORMATION_AVAILABLE;
137		}
138
139		/**
140		* Build number is only present if Hudson has done the build
141		*/
142	2	if (!isEmpty(bi.getBuildNumber())) {
143	1	bi.setBuildNumber("#" + bi.getBuildNumber());
144		}
145
146		/**
147		* Build a string out of the build information
148		*/
149	2	StringBuffer sb = new StringBuffer();
150	2	if (!isEmpty(bi.getName())) {
151	2	sb.append(bi.getName());
152	2	sb.append(" :: ");
153		}
154	2	if (!isEmpty(bi.getVersion())) {
155	2	sb.append(bi.getVersion());
156	2	sb.append(" :: ");
157		}
158	2	if (!isEmpty(bi.getBuildNumber())) {
159	1	sb.append(bi.getBuildNumber());
160	1	sb.append(" :: ");
161		}
162	2	if (!isEmpty(bi.getTimestamp())) {
163	2	sb.append(bi.getTimestamp());
164		}
165	2	return sb.toString();
166		}
167		}