Coverage Report

 /*
  * Copyright 2005-2007 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.opensource.org/licenses/ecl2.php
  *
  * 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.rice.kew.plugin;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.api.resourceloader.BaseResourceLoader;
 import org.kuali.rice.core.api.resourceloader.ResourceLoader;
 import org.kuali.rice.core.api.resourceloader.BaseResourceLoader;
 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
 import org.kuali.rice.core.api.resourceloader.ResourceLoader;
 import org.kuali.rice.core.impl.resourceloader.ResourceLoaderUtil;
 import org.kuali.rice.core.impl.resourceloader.ResourceLoaderUtil;
 import org.kuali.rice.kew.resourceloader.CoreResourceLoader;
 
 import javax.xml.namespace.QName;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FilenameFilter;
 import java.util.Iterator;
 import java.util.List;
 
 
 /**
  * Various plugin utilities.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public final class PluginUtils {
 
     private static final Logger LOG = Logger.getLogger(PluginUtils.class);
     private static final String SHARED_DIR = "shared";
 
     // maximum time we should wait for a new plugin directory to stop being
     // modified before we give up on loading it this time around
     public static final long INFINITE_MAX_WAIT = -1;
     // NOTE: must be greater than the SAFE TIME
     public static final long DEFAULT_MAX_WAIT = 90000;
 
     // amount of time since the last time the plugin dir was updated that we
     // consider "safe" to proceed with registering the plugin
     // basically, with the current implementation, an amount of time that we
     // expect any files in process of modification to complete (e.g. copy)
     // NOTE: MUST be LESS than the MAX WAIT otherwise, we will ALWAYS fail to wait
     public static final long DEFAULT_SAFE_TIME = 60000;
 
     private static final FilenameFilter JAR_FILES_FILTER = new FilenameFilter() {
         public boolean accept(File dir, String name) {
             return name.matches(".+\\.jar");
         }
     };
 
     private static final FileFilter SHARED_DIR_FILTER = new FileFilter() {
         public boolean accept(File file) {
             return file.isDirectory() && file.getName().equals(SHARED_DIR);
         }
     };
     
         private PluginUtils() {
                 throw new UnsupportedOperationException("do not call");
         }
 
     public static class PluginZipFileFilter implements FileFilter {
         public boolean accept(File file) {
             return file.isFile() && file.getName().endsWith(".zip");
         }
     }
 
     public static String getLogPrefix(Plugin plugin) {
             return getLogPrefix(plugin.getName());
     }
 
     public static String getLogPrefix(QName pluginName) {
             return "[Plugin: " + pluginName + "]";
     }
 
     static File[] findJars(File libDir) {
         File[] jarFiles = new File[0];
         if (libDir.isDirectory()) {
             jarFiles = libDir.listFiles(JAR_FILES_FILTER);
         }
         return jarFiles;
     }
 
     public static File findSharedDirectory(List pluginDirectories) {
         for (Iterator iterator = pluginDirectories.iterator(); iterator.hasNext();) {
             File dir = new File((String) iterator.next());
             if (dir.isDirectory()) {
                 File[] subDirs = dir.listFiles(SHARED_DIR_FILTER);
                 if (subDirs.length > 0) {
                     return subDirs[0];
                 }
             }
         }
         return null;
     }
 
     public static void validatePluginZipFile(File file) {
             if (file == null) {
                         throw new IllegalArgumentException("Given plugin file was 'null'");
                 } else if (!file.exists()) {
                         throw new IllegalArgumentException("Given plugin file does not exist: " + file.getAbsolutePath());
                 } else if (!file.isFile()) {
                         throw new IllegalArgumentException("Given plugin file is not a valid file: " + file.getAbsolutePath());
                 } else if (!file.canRead()) {
                         throw new IllegalArgumentException("Permission denied to read given plugin file: " + file.getAbsolutePath());
                 } else if (!file.getName().endsWith(".zip")) {
                         throw new IllegalArgumentException("Given plugin file does not end in .zip extension: " + file.getAbsolutePath());
                 }
             // now look at the directory the plugin file is in because we need to be able to extract it there
             File pluginDirectory = file.getParentFile();
             validatePluginDirectory(pluginDirectory);
             // also verify that we can write to this directory
             if (pluginDirectory == null) {
                     throw new IllegalArgumentException("Given plugin directory was 'null'");
             } else if (!pluginDirectory.canWrite()) {
                     throw new IllegalArgumentException("Impossible to write to plugin directory so plugin cannot be expanded: " + pluginDirectory.getAbsolutePath());
             }
     }
 
     public static void validatePluginDirectory(File directory) {
             if (directory == null) {
                         throw new IllegalArgumentException("Given directory was 'null'");
                 } else if (!directory.exists()) {
                         throw new IllegalArgumentException("Given directory does not exist: " + directory.getAbsolutePath());
                 } else if (!directory.isDirectory()) {
                         throw new IllegalArgumentException("Given plugin directory is not a valid directory: " + directory.getAbsolutePath());
                 } else if (!directory.canRead()) {
                         throw new IllegalArgumentException("Permission denied to read given plugin directory: " + directory.getAbsolutePath());
                 }
     }
 
     public static PluginRegistry getPluginRegistry() {
             return ((CoreResourceLoader)GlobalResourceLoader.getResourceLoader(CoreResourceLoader.NAME)).getRegistry();
     }
 
     public static void installResourceLoader(Plugin plugin) {
             if (plugin.getConfig() instanceof PluginConfig) {
                         PluginConfig pluginConfig = (PluginConfig)plugin.getConfig();
                         if (!StringUtils.isEmpty(pluginConfig.getResourceLoaderClassname())) {
                 ResourceLoader resourceLoader = (ResourceLoader) ResourceLoaderUtil.createObject(pluginConfig.getResourceLoaderClassname(), plugin.getClassLoader());
                 if (resourceLoader == null) {
                     LOG.warn("Could not create resource loader from plugin resource loader class: " + pluginConfig.getResourceLoaderClassname());
                     // if null, use a default resource loader
                                         resourceLoader = new BaseResourceLoader(plugin.getName());
                 }
                                 plugin.addResourceLoader(resourceLoader);
                         }
                 }
     }
 
     public static void installPluginListeners(Plugin plugin) {
             if (plugin.getConfig() instanceof PluginConfig) {
                         PluginConfig pluginConfig = (PluginConfig)plugin.getConfig();
                         for (Iterator iterator = pluginConfig.getListeners().iterator(); iterator.hasNext();) {
                     String pluginListenerClassName = (String) iterator.next();
                     try {
                         Class listenerClass = Class.forName(pluginListenerClassName, true, plugin.getClassLoader());
                         plugin.addPluginListener((PluginListener)listenerClass.newInstance());
                     } catch (ClassNotFoundException e) {
                         throw new PluginException(getLogPrefix(plugin)+" Error finding listener class '"+pluginListenerClassName+"'.", e);
                     } catch (InstantiationException e) {
                         throw new PluginException(getLogPrefix(plugin)+" Error creating an instance of listener class '"+pluginListenerClassName+"'.", e);
                     } catch (IllegalAccessException e) {
                         throw new PluginException(getLogPrefix(plugin)+" Error creating an instance of listener class '"+pluginListenerClassName+"'.", e);
                     } catch (ClassCastException e) {
                         throw new PluginException(getLogPrefix(plugin)+" Listener class '"+pluginListenerClassName+"' does not implement PluginListener.", e);
                     }
                 }
                 }
     }
 }

1		/*
2		* Copyright 2005-2007 The Kuali Foundation
3		*
4		*
5		* Licensed under the Educational Community License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.opensource.org/licenses/ecl2.php
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.kuali.rice.kew.plugin;
18
19		import org.apache.commons.lang.StringUtils;
20		import org.apache.log4j.Logger;
21		import org.kuali.rice.core.api.resourceloader.BaseResourceLoader;
22		import org.kuali.rice.core.api.resourceloader.ResourceLoader;
23		import org.kuali.rice.core.api.resourceloader.BaseResourceLoader;
24		import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
25		import org.kuali.rice.core.api.resourceloader.ResourceLoader;
26		import org.kuali.rice.core.impl.resourceloader.ResourceLoaderUtil;
27		import org.kuali.rice.core.impl.resourceloader.ResourceLoaderUtil;
28		import org.kuali.rice.kew.resourceloader.CoreResourceLoader;
29
30		import javax.xml.namespace.QName;
31		import java.io.File;
32		import java.io.FileFilter;
33		import java.io.FilenameFilter;
34		import java.util.Iterator;
35		import java.util.List;
36
37
38		/**
39		* Various plugin utilities.
40		*
41		* @author Kuali Rice Team (rice.collab@kuali.org)
42		*/
43		public final class PluginUtils {
44
45	0	private static final Logger LOG = Logger.getLogger(PluginUtils.class);
46		private static final String SHARED_DIR = "shared";
47
48		// maximum time we should wait for a new plugin directory to stop being
49		// modified before we give up on loading it this time around
50		public static final long INFINITE_MAX_WAIT = -1;
51		// NOTE: must be greater than the SAFE TIME
52		public static final long DEFAULT_MAX_WAIT = 90000;
53
54		// amount of time since the last time the plugin dir was updated that we
55		// consider "safe" to proceed with registering the plugin
56		// basically, with the current implementation, an amount of time that we
57		// expect any files in process of modification to complete (e.g. copy)
58		// NOTE: MUST be LESS than the MAX WAIT otherwise, we will ALWAYS fail to wait
59		public static final long DEFAULT_SAFE_TIME = 60000;
60
61	0	private static final FilenameFilter JAR_FILES_FILTER = new FilenameFilter() {
62		public boolean accept(File dir, String name) {
63	0	return name.matches(".+\\.jar");
64		}
65		};
66
67	0	private static final FileFilter SHARED_DIR_FILTER = new FileFilter() {
68		public boolean accept(File file) {
69	0	return file.isDirectory() && file.getName().equals(SHARED_DIR);
70		}
71		};
72
73	0	private PluginUtils() {
74	0	throw new UnsupportedOperationException("do not call");
75		}
76
77	0	public static class PluginZipFileFilter implements FileFilter {
78		public boolean accept(File file) {
79	0	return file.isFile() && file.getName().endsWith(".zip");
80		}
81		}
82
83		public static String getLogPrefix(Plugin plugin) {
84	0	return getLogPrefix(plugin.getName());
85		}
86
87		public static String getLogPrefix(QName pluginName) {
88	0	return "[Plugin: " + pluginName + "]";
89		}
90
91		static File[] findJars(File libDir) {
92	0	File[] jarFiles = new File[0];
93	0	if (libDir.isDirectory()) {
94	0	jarFiles = libDir.listFiles(JAR_FILES_FILTER);
95		}
96	0	return jarFiles;
97		}
98
99		public static File findSharedDirectory(List pluginDirectories) {
100	0	for (Iterator iterator = pluginDirectories.iterator(); iterator.hasNext();) {
101	0	File dir = new File((String) iterator.next());
102	0	if (dir.isDirectory()) {
103	0	File[] subDirs = dir.listFiles(SHARED_DIR_FILTER);
104	0	if (subDirs.length > 0) {
105	0	return subDirs[0];
106		}
107		}
108	0	}
109	0	return null;
110		}
111
112		public static void validatePluginZipFile(File file) {
113	0	if (file == null) {
114	0	throw new IllegalArgumentException("Given plugin file was 'null'");
115	0	} else if (!file.exists()) {
116	0	throw new IllegalArgumentException("Given plugin file does not exist: " + file.getAbsolutePath());
117	0	} else if (!file.isFile()) {
118	0	throw new IllegalArgumentException("Given plugin file is not a valid file: " + file.getAbsolutePath());
119	0	} else if (!file.canRead()) {
120	0	throw new IllegalArgumentException("Permission denied to read given plugin file: " + file.getAbsolutePath());
121	0	} else if (!file.getName().endsWith(".zip")) {
122	0	throw new IllegalArgumentException("Given plugin file does not end in .zip extension: " + file.getAbsolutePath());
123		}
124		// now look at the directory the plugin file is in because we need to be able to extract it there
125	0	File pluginDirectory = file.getParentFile();
126	0	validatePluginDirectory(pluginDirectory);
127		// also verify that we can write to this directory
128	0	if (pluginDirectory == null) {
129	0	throw new IllegalArgumentException("Given plugin directory was 'null'");
130	0	} else if (!pluginDirectory.canWrite()) {
131	0	throw new IllegalArgumentException("Impossible to write to plugin directory so plugin cannot be expanded: " + pluginDirectory.getAbsolutePath());
132		}
133	0	}
134
135		public static void validatePluginDirectory(File directory) {
136	0	if (directory == null) {
137	0	throw new IllegalArgumentException("Given directory was 'null'");
138	0	} else if (!directory.exists()) {
139	0	throw new IllegalArgumentException("Given directory does not exist: " + directory.getAbsolutePath());
140	0	} else if (!directory.isDirectory()) {
141	0	throw new IllegalArgumentException("Given plugin directory is not a valid directory: " + directory.getAbsolutePath());
142	0	} else if (!directory.canRead()) {
143	0	throw new IllegalArgumentException("Permission denied to read given plugin directory: " + directory.getAbsolutePath());
144		}
145	0	}
146
147		public static PluginRegistry getPluginRegistry() {
148	0	return ((CoreResourceLoader)GlobalResourceLoader.getResourceLoader(CoreResourceLoader.NAME)).getRegistry();
149		}
150
151		public static void installResourceLoader(Plugin plugin) {
152	0	if (plugin.getConfig() instanceof PluginConfig) {
153	0	PluginConfig pluginConfig = (PluginConfig)plugin.getConfig();
154	0	if (!StringUtils.isEmpty(pluginConfig.getResourceLoaderClassname())) {
155	0	ResourceLoader resourceLoader = (ResourceLoader) ResourceLoaderUtil.createObject(pluginConfig.getResourceLoaderClassname(), plugin.getClassLoader());
156	0	if (resourceLoader == null) {
157	0	LOG.warn("Could not create resource loader from plugin resource loader class: " + pluginConfig.getResourceLoaderClassname());
158		// if null, use a default resource loader
159	0	resourceLoader = new BaseResourceLoader(plugin.getName());
160		}
161	0	plugin.addResourceLoader(resourceLoader);
162		}
163		}
164	0	}
165
166		public static void installPluginListeners(Plugin plugin) {
167	0	if (plugin.getConfig() instanceof PluginConfig) {
168	0	PluginConfig pluginConfig = (PluginConfig)plugin.getConfig();
169	0	for (Iterator iterator = pluginConfig.getListeners().iterator(); iterator.hasNext();) {
170	0	String pluginListenerClassName = (String) iterator.next();
171		try {
172	0	Class listenerClass = Class.forName(pluginListenerClassName, true, plugin.getClassLoader());
173	0	plugin.addPluginListener((PluginListener)listenerClass.newInstance());
174	0	} catch (ClassNotFoundException e) {
175	0	throw new PluginException(getLogPrefix(plugin)+" Error finding listener class '"+pluginListenerClassName+"'.", e);
176	0	} catch (InstantiationException e) {
177	0	throw new PluginException(getLogPrefix(plugin)+" Error creating an instance of listener class '"+pluginListenerClassName+"'.", e);
178	0	} catch (IllegalAccessException e) {
179	0	throw new PluginException(getLogPrefix(plugin)+" Error creating an instance of listener class '"+pluginListenerClassName+"'.", e);
180	0	} catch (ClassCastException e) {
181	0	throw new PluginException(getLogPrefix(plugin)+" Listener class '"+pluginListenerClassName+"' does not implement PluginListener.", e);
182	0	}
183	0	}
184		}
185	0	}
186		}