• R/O
  • SSH
  • HTTPS

galleryes: Commit


Commit MetaInfo

Revision9 (tree)
Zeit2011-09-06 02:13:00
Autorokuyamaoo

Log Message

test001

Ändern Zusammenfassung

Diff

--- trunk/branch001/src/galleryes/base/parameter/config/HelperConfigMap.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/parameter/config/HelperConfigMap.java (revision 9)
@@ -0,0 +1,138 @@
1+package galleryes.base.parameter.config;
2+
3+import java.util.ArrayList;
4+
5+
6+/**
7+ * 一つのHelperに対する詳細情報を保持する.<br>
8+ *
9+ *
10+ * @author T.Okuyama
11+ * @license GPL(Lv3)
12+ */
13+public class HelperConfigMap {
14+
15+ private String helperName = null;
16+
17+ private String helperClassName = null;
18+
19+ private String helperInit = null;
20+
21+ private String helperOption = null;
22+
23+ private int helperLimitSize = 0;
24+
25+ private int maxHelperUse = 0;
26+
27+ private String[] helperDbgroupList = null;
28+
29+ private String helperCommit = null;
30+
31+
32+ /**
33+ * Helper定義情報を初期化.<br>
34+ *
35+ * @param helperName
36+ * @param helperClassName
37+ * @param helperInit
38+ * @param helperOption
39+ * @param helperLimitSize
40+ * @param maxHelperUse
41+ */
42+ public HelperConfigMap(String helperName, String helperClassName, String helperInit, String helperOption, int helperLimitSize, int maxHelperUse, String[] helperDbgroupList, String helperCommit) {
43+ this.helperName = helperName;
44+ this.helperClassName = helperClassName;
45+ this.helperInit = helperInit;
46+ this.helperOption = helperOption;
47+ this.helperLimitSize = helperLimitSize;
48+ this.maxHelperUse = maxHelperUse;
49+ this.helperDbgroupList = helperDbgroupList;
50+ this.helperCommit = helperCommit;
51+ }
52+
53+
54+ /**
55+ * Helper名を返す.<br>
56+ *
57+ * @return String Helper名
58+ */
59+ public String getHelperName() {
60+ return this.helperName;
61+ }
62+
63+
64+ /**
65+ * Helperクラス名を返す.<br>
66+ *
67+ * @return String Helperクラス名
68+ */
69+ public String getHelperClassName() {
70+ return this.helperClassName;
71+ }
72+
73+
74+ /**
75+ * Initオプションを返す.<br>
76+ *
77+ * @return String Initオプション値
78+ */
79+ public String getHelperInit() {
80+ return this.helperInit;
81+ }
82+
83+ /**
84+ * Helperのオプション値を返す
85+ *
86+ * @return String オプション値
87+ */
88+ public String getHelperOption() {
89+ return this.helperOption;
90+ }
91+
92+ /**
93+ * Helperのインスタンス化可能数を返す
94+ *
95+ * @return int
96+ */
97+ public int getHelperLimitSize() {
98+ return this.helperLimitSize;
99+ }
100+
101+ /**
102+ * Helperの1インスタンスあたりの使用上限回数を返す.<br>
103+ *
104+ * @return int
105+ */
106+ public int getMaxHelperUse() {
107+ return this.maxHelperUse;
108+ }
109+
110+ /**
111+ * HelperDbgroup指定が存在するかを返す.<br>
112+ *
113+ * @return boolean 真偽値
114+ */
115+ public boolean isHelperDbGroup() {
116+ if (this.helperDbgroupList == null) {
117+ return false;
118+ }
119+ return true;
120+ }
121+
122+ /**
123+ * 自身が使用するデータベースグループ名を返す.<br>
124+ *
125+ * @return String[] グループリスト
126+ */
127+ public String[] getHelperDbgroupList() {
128+ return this.helperDbgroupList;
129+ }
130+
131+ /**
132+ * 自身のCommit指定を返す.<br>
133+ */
134+ public String getHelperCommit() {
135+ return this.helperCommit;
136+ }
137+
138+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/parameter/config/BatchConfig.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/parameter/config/BatchConfig.java (revision 9)
@@ -0,0 +1,184 @@
1+package galleryes.base.parameter.config;
2+
3+import java.io.InputStream;
4+import java.io.File;
5+import java.io.IOException;
6+import java.io.FileInputStream;
7+import java.util.Iterator;
8+import java.util.Properties;
9+import java.util.Set;
10+import java.util.Map;
11+import java.util.Hashtable;
12+
13+import galleryes.base.lang.BaseException;
14+import galleryes.base.util.ILogger;
15+import galleryes.base.util.LoggerFactory;
16+import galleryes.base.util.ClassUtility;
17+
18+/**
19+ * Batchの設定を読み込み保持する.<br>
20+ *
21+ * @author T.Okuyama
22+ * @license GPL(Lv3)
23+ */
24+public class BatchConfig {
25+
26+ private String configFile = null;
27+ // Logger
28+ private ILogger logger = LoggerFactory.createLogger(BatchConfig.class);
29+
30+ // 設定情報格納用Table
31+ private Map configTable = null;
32+
33+ /**
34+ * 設定ファイル名を渡すことにより、生成.<br>
35+ *
36+ * @param fileName
37+ * @throws BaseException
38+ */
39+ public BatchConfig(String fileName) throws BaseException {
40+ this.configTable = new Hashtable();
41+
42+ this.configFile = fileName;
43+ File jobConfigFile = new File(fileName);
44+ if (jobConfigFile.exists()) {
45+
46+ try {
47+ this.initConfig(new FileInputStream(fileName));
48+ } catch (Exception e) {
49+ throw new BaseException(e);
50+ }
51+ } else {
52+
53+ this.initConfig(JobConfig.class.getResourceAsStream(fileName));
54+ }
55+ }
56+
57+
58+ /**
59+ * 設定ファイル名を渡すことにより、生成.<br>
60+ *
61+ * @param fileName
62+ * @throws BaseException
63+ */
64+ public BatchConfig(Map parameters) throws BaseException {
65+ this.configTable = new Hashtable(7);
66+
67+ this.initConfig(parameters);
68+ }
69+
70+
71+ /**
72+ * 設定ファイルを解析し自身に蓄える.<br>
73+ *
74+ * @param is ファイルストリーム
75+ * @throws BaseException
76+ */
77+ private void initConfig(InputStream is) throws BaseException {
78+ logger.debug("BatchConfig - initConfig - start");
79+ Properties prop = null;
80+
81+ String key = null;
82+
83+ int index = 0;
84+
85+ try {
86+ prop = new Properties();
87+ prop.load(is);
88+
89+ Set keys = prop.keySet();
90+
91+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
92+
93+ key = (String)iterator.next();
94+
95+ this.configTable.put(key, prop.getProperty(key));
96+ }
97+
98+ // 設定ファイルをチェック
99+ this.checkConfig();
100+
101+ } catch(Exception e) {
102+ logger.error("BatchConfig - initConfig - Exception", e);
103+ throw new BaseException(e);
104+ } finally {
105+ try {
106+ if (is != null) {
107+ is.close();
108+ }
109+ } catch (IOException ie) {
110+ // 無視
111+ logger.error("initConfig - File Stream Close Error");
112+ }
113+ }
114+ logger.debug("BatchConfig - initConfig - end");
115+ }
116+
117+
118+ /**
119+ * 設定ファイルを解析し自身に蓄える.<br>
120+ *
121+ * @param parameters パラメータ用のMap
122+ * @throws BaseException
123+ */
124+ private void initConfig(Map parameters) throws BaseException {
125+ logger.debug("BatchConfig - initConfig - start");
126+
127+ String key = null;
128+
129+ int index = 0;
130+
131+ try {
132+
133+ if (parameters == null || parameters.size() < 7) throw new BaseException("Basic setting information is insufficient")
134+
135+ Set keys = parameters.keySet();
136+
137+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
138+
139+ key = (String)iterator.next();
140+
141+ this.configTable.put(key, (String)parameters.get(key));
142+ }
143+
144+ // 設定ファイルをチェック
145+ this.checkConfig();
146+
147+
148+ } catch(BaseException be) {
149+ logger.error("BatchConfig - initConfig - Exception", be);
150+ throw be;
151+ } catch(Exception e) {
152+
153+ logger.error("BatchConfig - initConfig - Exception", e);
154+ throw new BaseException(e);
155+ }
156+ logger.debug("BatchConfig - initConfig - end");
157+ }
158+
159+
160+ /**
161+ * 設定情報をチェック
162+ */
163+ private void checkConfig() {
164+ // TODO:Nonimplement
165+ return ;
166+ }
167+
168+ /**
169+ * 設定されている設定情報を取り出す.<br>
170+ * 存在しない場合はnullを返す.<br>
171+ *
172+ * @param key バッチ設定ファイルに記述されているキー値
173+ * @return String バッチ設定ファイルに記述されている設定値
174+ */
175+ public String getBatchParam(String key) {
176+ String ret = null;
177+
178+ if (this.configTable.containsKey(key)) {
179+
180+ ret = (String)this.configTable.get(key);
181+ }
182+ return ret;
183+ }
184+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/parameter/config/JobConfig.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/parameter/config/JobConfig.java (revision 9)
@@ -0,0 +1,479 @@
1+package galleryes.base.parameter.config;
2+
3+import java.io.File;
4+import java.io.InputStream;
5+import java.io.FileInputStream;
6+import java.io.IOException;
7+import java.util.LinkedHashMap;
8+import java.util.Hashtable;
9+import java.util.Iterator;
10+import java.util.Properties;
11+import java.util.Set;
12+
13+import galleryes.base.lang.BatchDefine;
14+import galleryes.base.lang.BaseException;
15+import galleryes.base.util.ILogger;
16+import galleryes.base.util.LoggerFactory;
17+import galleryes.base.util.ClassUtility;
18+
19+/**
20+ * ルールの設定を読み込み保持する.<br>
21+ *
22+ * @author T.Okuyama
23+ * @license GPL(Lv3)
24+ */
25+public class JobConfig {
26+
27+ // Logger
28+ private ILogger logger = LoggerFactory.createLogger(JobConfig.class);
29+
30+ // joblistをキーにして、そのルールをさらにLinkedHashMapとして格納している
31+ // 格納済みのLinkedHashMapのキーはルールクラス名で、パラメータは初期値
32+ private LinkedHashMap configMap = null;
33+
34+ private LinkedHashMap helperMap = null;
35+
36+ // ユーザがJob設定ファイルに自由に設定した情報を格納
37+ private Hashtable userPrivateValuesMap = null;
38+
39+ private String configFileName = null;
40+
41+ private File configFile = null;
42+
43+ private long fileModifiedTime = 0L;
44+
45+
46+ /**
47+ * 設定ファイル名を渡すことにより、生成.<br>
48+ * コンストラクタ<br>
49+ *
50+ * @param fileName 設定ファイル名
51+ * @throws BaseException
52+ */
53+ public JobConfig(String fileName) throws BaseException {
54+ this.configMap = new LinkedHashMap();
55+ this.helperMap = new LinkedHashMap();
56+ this.userPrivateValuesMap = new Hashtable();
57+ this.configFileName = fileName;
58+
59+ this.configFile = new File(fileName);
60+ try {
61+ if (this.configFile.exists()) {
62+
63+ this.initConfig(new FileInputStream(this.configFile));
64+ } else {
65+
66+ this.configFile = new File(JobConfig.class.getResource(this.configFileName).toURI());
67+ this.initConfig(new FileInputStream(this.configFile));
68+ }
69+ } catch (Exception e) {
70+ throw new BaseException(e);
71+ }
72+ }
73+
74+
75+ /**
76+ * 設定ファイルを解析し、自身に蓄える.<br>
77+ *
78+ * @param is 設定ファイルストリーム
79+ * @throws BaseException
80+ */
81+ private void initConfig(InputStream is) throws BaseException {
82+ Properties prop = null;
83+
84+ String jobs = null;
85+ String[] jobList = null;
86+
87+ String helpers = null;
88+ String[] helperList = null;
89+
90+ String jobClass = null;
91+ String optionValue = null;
92+ String initValue = null;
93+ String dependValue = null;
94+ String helperLimitSizeStr = null;
95+ int helperLimitSize = 0;
96+ String helperMaxUseStr = null;
97+ int helperMaxUse = 0;
98+
99+ String[] dependList = null;
100+ String dbgroupValue = null;
101+ String[] dbgroupList = null;
102+ String commitValue = null;
103+
104+ String helperDbgroupValue = null;
105+ String[] helperDbgroupList = null;
106+ String helperCommitValue = null;
107+
108+ String helperClass = null;
109+
110+ Set keys = null;
111+ String key = null;
112+
113+ JobConfigMap jobConfigMap = null;
114+ HelperConfigMap helperConfigMap = null;
115+
116+ try {
117+ logger.debug("initConfig - Start");
118+ prop = new Properties();
119+ prop.load(is);
120+
121+ // 対象job一覧取得
122+ jobs = prop.getProperty(BatchDefine.JOB_CONFIG_JOBLIST_KEY);
123+
124+ logger.debug("JOBLIST:[" + jobs + "]");
125+
126+ // 対象JobListを分解
127+ jobList = jobs.split(BatchDefine.JOB_CONFIG_JOBLIST_SEP);
128+
129+ // 実行Jobの情報を分析
130+ for (int index = 0; index < jobList.length; index++) {
131+ jobClass = null;
132+ initValue = null;
133+ optionValue = null;
134+ dependValue = null;
135+ dependList = null;
136+ dbgroupValue = null;
137+ dbgroupList = null;
138+ commitValue = null;
139+
140+ logger.debug("Job Parse Job:[" + jobList[index] + "]");
141+ // 対象Job名を使用して、情報を取り出す
142+ jobClass = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_CLASS_KEY);
143+
144+ // ルールの有無を調べる
145+ if (jobClass == null) {
146+
147+ logger.error("Job Class Configure Not Found");
148+ logger.error("Error Job Name:[" + jobList[index] + "]");
149+ throw new BaseException("Job Class Configure Error");
150+ } else {
151+
152+ logger.debug("Job Class Configure Exists");
153+ logger.debug("Job Class Name:[" + jobClass + "]");
154+
155+ // Option値取得(NULLの可能性もある)
156+ optionValue = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_OPTION_KEY);
157+
158+ // Option値取得(NULLの可能性もある)
159+ initValue = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_INIT_KEY);
160+
161+ // Depend値取得(NULLの可能性もある)
162+ dependValue = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_DEPEND_KEY);
163+ if (dependValue != null && !dependValue.equals("")) {
164+ if(dependValue.indexOf(BatchDefine.JOB_CONFIG_DEPEND_SEP) == -1) {
165+ dependList = new String[1];
166+ dependList[0] = dependValue;
167+ } else {
168+ dependList = dependValue.split(BatchDefine.JOB_CONFIG_DEPEND_SEP);
169+ }
170+ }
171+
172+ // Dbgroup値取得(NULLの可能性もある)
173+ dbgroupValue = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_DBGROUP_KEY);
174+ if (dbgroupValue != null && !dbgroupValue.equals("")) {
175+ if(dbgroupValue.indexOf(BatchDefine.JOB_CONFIG_DBGROUP_SEP) == -1) {
176+ dbgroupList = new String[1];
177+ dbgroupList[0] = dbgroupValue;
178+ } else {
179+ dbgroupList = dbgroupValue.split(BatchDefine.JOB_CONFIG_DBGROUP_SEP);
180+ }
181+ }
182+
183+ // Commit値取得(NULLの可能性もある)
184+ commitValue = (String)prop.remove(jobList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_COMMIT_KEY);
185+
186+ // 値を保存
187+ jobConfigMap = new JobConfigMap(jobList[index], jobClass, initValue, optionValue, dependList, dbgroupList, commitValue);
188+
189+ logger.info("Job Name" + jobList[index] +
190+ ", Class Name[" + jobClass + "]" +
191+ ", Init Name[" + initValue + "]" +
192+ ", Option Name[" + optionValue + "]" +
193+ ", Depend Name[" + dependValue + "]" +
194+ ", Dbgroup Name[" + dbgroupValue + "]" +
195+ ", Commit Name[" + commitValue + "]");
196+
197+
198+ // キー(Job名)値と、詳細情報
199+ this.configMap.put(jobList[index], jobConfigMap);
200+ }
201+ }
202+
203+
204+
205+ // 対象Helper一覧取得
206+ helpers = prop.getProperty(BatchDefine.JOB_CONFIG_HELPERLIST_KEY);
207+
208+ logger.debug("HelperList:[" + helpers + "]");
209+
210+ if (helpers != null && !helpers.equals("")) {
211+ // 対象JobListを分解
212+ helperList = helpers.split(BatchDefine.JOB_CONFIG_JOBLIST_SEP);
213+
214+ // 実行Jobの情報を分析
215+ for (int index = 0; index < helperList.length; index++) {
216+ helperClass = null;
217+ initValue = null;
218+ optionValue = null;
219+ helperDbgroupValue = null;
220+ helperDbgroupList = null;
221+ helperCommitValue = null;
222+
223+
224+ logger.debug("Helper Parse List:[" + helperList[index] + "]");
225+ // 対象Job名を使用して、情報を取り出す
226+ helperClass = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_HELPER_CLASS_KEY);
227+
228+ // ルールの有無を調べる
229+ if (helperClass == null) {
230+
231+ logger.error("Helper Class Not Found");
232+ logger.error("Target Helper :[" + helperList[index] + "]");
233+ throw new BaseException("ConfigureError");
234+ } else {
235+
236+ // Option値取得(NULLの可能性もある)
237+ optionValue = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_OPTION_KEY);
238+
239+ // Init値取得(NULLの可能性もある)
240+ initValue = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_INIT_KEY);
241+
242+ // Limit値取得(同時インスタンス化数)(NULLの可能性もある)
243+ helperLimitSize = 0;
244+ helperLimitSizeStr = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_HELPER_LIMIT_KEY);
245+
246+ if (helperLimitSizeStr != null) {
247+ try {
248+ // 数値変換
249+ helperLimitSize = Integer.parseInt(helperLimitSizeStr);
250+ } catch (NumberFormatException nfe) {
251+ logger.error("[" + helperList[index] + "]");
252+ throw new BaseException("Cofigure File[ Helper Limit ] Error[" + helperLimitSizeStr + "]");
253+ }
254+ }
255+
256+ // MaxUse値取得(1インスタンスの使用回数)(NULLの可能性もある)
257+ helperMaxUse = 0;
258+ helperMaxUseStr = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_HELPER_MAX_USE_KEY);
259+
260+ if (helperMaxUseStr != null) {
261+ try {
262+ // 数値変換
263+ helperMaxUse = Integer.parseInt(helperMaxUseStr);
264+ } catch (NumberFormatException nfe) {
265+ logger.error("Helper Name:[" + helperList[index] + "]");
266+ throw new BaseException("Helper[ Helper Max Use ]Configure Error[" + helperMaxUseStr + "]");
267+ }
268+ }
269+
270+ }
271+
272+
273+ // HelperDbgroupValue値取得(NULLの可能性もある)
274+ helperDbgroupValue = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_HELPER_DBGROUP_KEY);
275+ if (helperDbgroupValue != null && !helperDbgroupValue.equals("")) {
276+ if(helperDbgroupValue.indexOf(BatchDefine.JOB_CONFIG_HELPER_DBGROUP_SEP) == -1) {
277+ helperDbgroupList = new String[1];
278+ helperDbgroupList[0] = helperDbgroupValue;
279+ } else {
280+ helperDbgroupList = helperDbgroupValue.split(BatchDefine.JOB_CONFIG_HELPER_DBGROUP_SEP);
281+ }
282+ }
283+
284+ // Commit値取得(NULLの可能性もある)
285+ helperCommitValue = (String)prop.remove(helperList[index] + BatchDefine.JOB_CONFIG_JOIN_SEP + BatchDefine.JOB_CONFIG_HELPER_COMMIT_KEY);
286+
287+ // 値を保存
288+ helperConfigMap = new HelperConfigMap(helperList[index], helperClass, initValue, optionValue, helperLimitSize, helperMaxUse, helperDbgroupList, helperCommitValue);
289+
290+ logger.info("Helper Name" + helperList[index] +
291+ ", Class Name[" + helperClass + "]" +
292+ ", Init Parameter[" + initValue + "]" +
293+ ", Option Parameter[" + optionValue + "]" +
294+ ", Limit Parameter[" + helperLimitSizeStr + "]" +
295+ ", MaxUse Parameter[" + helperMaxUseStr + "]" +
296+ ", Dbgroup Parameter[" + helperDbgroupValue + "]" +
297+ ", Commit Parameter[" + helperCommitValue + "]");
298+
299+ // キー(Job名)値と、詳細情報
300+ this.helperMap.put(helperList[index], helperConfigMap);
301+
302+ }
303+ }
304+
305+ // システム設定以外の情報(自由な値)を自身に設定
306+ keys = prop.keySet();
307+ key = null;
308+ if (keys != null) {
309+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
310+ key = (String)iterator.next();
311+ this.userPrivateValuesMap.put(key, prop.get(key));
312+ }
313+ }
314+ this.fileModifiedTime = this.configFile.lastModified();
315+ } catch (Exception e) {
316+ logger.error("initConfig - Error");
317+ throw new BaseException(e);
318+ } finally {
319+ try {
320+ if (is != null) {
321+ is.close();
322+ }
323+ } catch (IOException ie) {
324+ // 無視
325+ logger.error("initConfig - File Stream Close Error");
326+ }
327+ }
328+ logger.debug("initConfig - End");
329+ }
330+
331+ /**
332+ * 設定されているconfigMapの情報を基に、Job名リストを取り出す.<br>
333+ *
334+ * @return String[] Job名リスト
335+ */
336+ public String[] getJobNameList() {
337+ String[] returnKyes;
338+ int index = 0;
339+ String key;
340+
341+ Set keys = this.configMap.keySet();
342+ returnKyes = new String[keys.size()];
343+
344+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
345+
346+ key = (String)iterator.next();
347+ returnKyes[index] = key;
348+
349+ index++;
350+ }
351+ return returnKyes;
352+ }
353+
354+ /**
355+ * 設定されているconfigMapの情報を基に、Helper名リストを取り出す.<br>
356+ *
357+ * @return String[] Helper名リスト
358+ */
359+ public String[] getHelperNameList() {
360+ String[] returnKyes;
361+ int index = 0;
362+ String key;
363+
364+ Set keys = this.helperMap.keySet();
365+ returnKyes = new String[keys.size()];
366+
367+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
368+
369+ key = (String)iterator.next();
370+ returnKyes[index] = key;
371+
372+ index++;
373+ }
374+ return returnKyes;
375+ }
376+
377+ /**
378+ * 設定されているconfigMapの情報を基に、Job名をキーにそのJobに紐付く詳細を取り出す.<br>
379+ * 詳細情報が存在しないExceptionとする<br>
380+ *
381+ * @param jobName Job名
382+ * @return JobConfigMap Job設定情報
383+ */
384+ public JobConfigMap getJobConfig(String jobName) {
385+ JobConfigMap jobConfigMap = (JobConfigMap)this.configMap.get(jobName);
386+
387+ return jobConfigMap;
388+ }
389+
390+ /**
391+ * 設定されているconfigMapの情報を基に、Helper名をキーにそのHelperに紐付く詳細を取り出す.<br>
392+ * 詳細情報が存在しないExceptionとする<br>
393+ *
394+ * @param helperName Helper名
395+ * @return HelperConfigMap Helper設定情報
396+ */
397+ public HelperConfigMap getHelperConfig(String helperName) throws BaseException {
398+ HelperConfigMap helperConfigMap = null;
399+ if (this.helperMap.containsKey(helperName)) {
400+
401+ helperConfigMap = (HelperConfigMap)this.helperMap.get(helperName);
402+ } else {
403+ throw new BaseException(helperName + ":Helper Not Found");
404+ }
405+ return helperConfigMap;
406+ }
407+
408+ /**
409+ * ユーザが自由に設定した設定情報を取り出す.<br>
410+ * 存在しない場合はnullを返す.<br>
411+ *
412+ * @param key 設定ファイルに設定されているユーザパラメータのキー値
413+ * @return String ユーザパラメータ
414+ */
415+ public String getUserParam(String key) {
416+ String ret = null;
417+
418+ if (this.userPrivateValuesMap.containsKey(key)) {
419+
420+ ret = (String)this.userPrivateValuesMap.get(key);
421+ }
422+ return ret;
423+ }
424+
425+ /**
426+ * 設定ファイルに変更があったかをチェックする.<br>
427+ *
428+ * @return boolean
429+ */
430+ public boolean isChangePropertiesFile() throws BaseException {
431+ boolean ret = false;
432+ try {
433+
434+ if(this.fileModifiedTime != this.configFile.lastModified()) ret = true;
435+ } catch(Exception e) {
436+ // エラー
437+ logger.error("isChangePropertiesFile - Error" + e);
438+ }
439+ return ret;
440+
441+ }
442+
443+ /**
444+ * ユーザが自由に設定した設定情報を再読み込みする.<br>
445+ *
446+ * @param key 設定ファイルに設定されているユーザパラメータのキー値
447+ */
448+ public void reloadUserParam(String[] keys) throws BaseException {
449+ InputStream is = null;
450+
451+ try {
452+ this.fileModifiedTime = this.configFile.lastModified();
453+ is = new FileInputStream(this.configFile);
454+
455+ Properties prop = new Properties();
456+ prop.load(is);
457+
458+ for (int i = 0; i < keys.length; i++) {
459+ String value = (String)prop.get(keys[i]);
460+ if (value != null) {
461+ this.userPrivateValuesMap.put(keys[i], value);
462+ }
463+ }
464+ } catch (Exception e) {
465+ logger.error("reloadUserParam - Error");
466+ throw new BaseException(e);
467+ } finally {
468+ try {
469+ if (is != null) {
470+ is.close();
471+ }
472+ } catch (IOException ie) {
473+ // 無視
474+ logger.error("reloadUserParam - File Stream Close Error");
475+ }
476+ }
477+ }
478+
479+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/parameter/config/ConfigFolder.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/parameter/config/ConfigFolder.java (revision 9)
@@ -0,0 +1,82 @@
1+package galleryes.base.parameter.config;
2+
3+import java.util.Hashtable;
4+
5+import galleryes.base.lang.BaseException;
6+
7+
8+/**
9+ * BatchConfigとJobConfigを保持する.<br>
10+ * 設定情報に対するクリティカルなアクセスを想定して作成.<br>
11+ * シングルトンで作成.<br>
12+ *
13+ * @author T.Okuyama
14+ * @license GPL(Lv3)
15+ */
16+public class ConfigFolder {
17+
18+ private static Hashtable table = null;
19+
20+ // staticイニシャライザ
21+ static {
22+ table = new Hashtable(2);
23+ }
24+
25+ private ConfigFolder(){}
26+
27+ // 設定情報をセット
28+ public static void setConfig(BatchConfig batchConfig, JobConfig jobConfig) {
29+ table.put("batch", batchConfig);
30+ table.put("job", jobConfig);
31+ }
32+
33+
34+ public static BatchConfig getBatchConfig() {
35+ return (BatchConfig)table.get("batch");
36+ }
37+
38+ public static JobConfig getJobConfig() {
39+ return (JobConfig)table.get("job");
40+ }
41+
42+ /**
43+ * Helper情報を取り出す.<br>
44+ * 存在しない場合はExceptionが返る.<br>
45+ *
46+ * @param helperName Helper名
47+ * @return HelperConfigMap 取得値
48+ */
49+ public static HelperConfigMap getHelperConfigMap(String helperName) throws BaseException {
50+ return (HelperConfigMap)((JobConfig)table.get("job")).getHelperConfig(helperName);
51+ }
52+
53+ /**
54+ * ユーザが自由に設定した値を取り出す.<br>
55+ * 存在しない場合はnullが返る.<br>
56+ *
57+ * @param key キー値
58+ * @return String 取得値
59+ */
60+ public static String getJobUserParam(String key) {
61+ return (String)((JobConfig)table.get("job")).getUserParam(key);
62+ }
63+
64+ /**
65+ * Job設定に変更があったかをチェックする.<br>
66+ *
67+ * @return boolean true=変更あり false=変更なし
68+ */
69+ public static boolean isJobFileChange() throws BaseException {
70+ return ((JobConfig)table.get("job")).isChangePropertiesFile();
71+ }
72+
73+ /**
74+ * Job設定の指定のキーの値を再読み込みする.<br>
75+ *
76+ * @param keys 指定のキー値
77+ */
78+ public static void reloadJobFileParameter(String[] keys) throws BaseException {
79+ ((JobConfig)table.get("job")).reloadUserParam(keys);
80+ }
81+
82+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/parameter/config/JobConfigMap.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/parameter/config/JobConfigMap.java (revision 9)
@@ -0,0 +1,114 @@
1+package galleryes.base.parameter.config;
2+
3+import java.util.ArrayList;
4+
5+
6+/**
7+ * 一つのJobに対する詳細情報を保持する.<br>
8+ *
9+ * @author T.Okuyama
10+ * @license GPL(Lv3)
11+ */
12+public class JobConfigMap {
13+
14+ private String jobName = null;
15+
16+ private String jobClassName = null;
17+
18+ private String jobInit = null;
19+
20+ private String jobOption = null;
21+
22+ private String[] jobDependList = null;
23+
24+ private String[] jobDbgroupList = null;
25+
26+ private String jobCommit = null;
27+
28+ /**
29+ * Job定義情報を初期化.<br>
30+ */
31+ public JobConfigMap(String jobName, String jobClassName, String jobInit, String jobOption, String[] jobDependList, String[] jobDbgroupList, String jobCommit) {
32+ this.jobName = jobName;
33+ this.jobClassName = jobClassName;
34+ this.jobInit = jobInit;
35+ this.jobOption = jobOption;
36+ this.jobDependList = jobDependList;
37+ this.jobDbgroupList = jobDbgroupList;
38+ this.jobCommit = jobCommit;
39+ }
40+
41+
42+ /**
43+ * Job名を返す.<br>
44+ */
45+ public String getJobName() {
46+ return this.jobName;
47+ }
48+
49+
50+ /**
51+ * Jobクラス名を返す.<br>
52+ */
53+ public String getJobClassName() {
54+ return this.jobClassName;
55+ }
56+
57+
58+ /**
59+ * Initオプションを返す.<br>
60+ */
61+ public String getJobInit() {
62+ return this.jobInit;
63+ }
64+
65+ /**
66+ * Jobオプションを返す.<br>
67+ */
68+ public String getJobOption() {
69+ return this.jobOption;
70+ }
71+
72+
73+ /**
74+ * 依存関係が存在するかを返す.<br>
75+ */
76+ public boolean isDepend() {
77+ if (this.jobDependList == null) {
78+ return false;
79+ }
80+ return true;
81+ }
82+
83+ /**
84+ * 自身が依存しているJob名を返す.<br>
85+ */
86+ public String[] getJobDependList() {
87+ return this.jobDependList;
88+ }
89+
90+
91+ /**
92+ * Dbgroup指定が存在するかを返す.<br>
93+ */
94+ public boolean isDbGroup() {
95+ if (this.jobDbgroupList == null) {
96+ return false;
97+ }
98+ return true;
99+ }
100+
101+ /**
102+ * 自身が使用するデータベースグループ名を返す.<br>
103+ */
104+ public String[] getDbgroupList() {
105+ return this.jobDbgroupList;
106+ }
107+
108+ /**
109+ * 自身のCommit指定を返す.<br>
110+ */
111+ public String getJobCommit() {
112+ return this.jobCommit;
113+ }
114+}
--- trunk/branch001/src/galleryes/base/JavaMain.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/JavaMain.java (revision 9)
@@ -0,0 +1,109 @@
1+package galleryes.base;
2+
3+import java.util.Map;
4+import java.util.HashMap;
5+
6+import galleryes.base.lang.BaseException;
7+import galleryes.base.util.ILogger;
8+import galleryes.base.util.LoggerFactory;
9+import galleryes.base.util.ClassUtility;
10+import galleryes.base.parameter.config.BatchConfig;
11+import galleryes.base.parameter.config.ConfigFolder;
12+import galleryes.base.parameter.config.JobConfig;
13+
14+/**
15+ * メインクラス.<br>
16+ *
17+ * @author T.Okuyama
18+ * @license GPL(Lv3)
19+ */
20+public class JavaMain {
21+
22+ // Logger
23+ private static ILogger logger = LoggerFactory.createLogger(JavaMain.class);
24+
25+ /**
26+ * 起動メソッド
27+ * @param args [0]=GalleryEs設定ファイル名
28+ */
29+ public static void main(String[] args) {
30+ logger.info("JavaMain - start");
31+ try {
32+
33+ if (args == null || args.length < 1) {
34+ if (args == null) {
35+ System.err.println("Error : JavaMain The argument is illega [GalleryEs.properties]");
36+ throw new BaseException("JavaMain Configure File Not Found");
37+ } else {
38+ System.err.println("Error : JavaMain The argument is illega [GalleryEs.properties]");
39+ throw new BaseException("JavaMain Configure File Not Found");
40+ }
41+ }
42+
43+ JavaMain me = new JavaMain();
44+ me.exec(args[0]);
45+
46+ } catch (BaseException be) {
47+ logger.error("JavaMain - error", be);
48+ System.exit(1);
49+ }
50+
51+ logger.info("JavaMain - end");
52+ }
53+
54+
55+ /**
56+ * メイン処理.<br>
57+ *
58+ * @param jobConfPath Job設定ファイルパス
59+ * @throws BaseException
60+ */
61+ public void exec(String jobConfPath) throws BaseException {
62+ logger.debug("JavaMain - exec - start");
63+ String controllerClassName = null;
64+
65+ try {
66+ Map parameters = JavaMain.crateBaseSettingParameters();
67+
68+ BatchConfig batchConfig = new BatchConfig(parameters);
69+ JobConfig jobConfig = new JobConfig(jobConfPath);
70+
71+ // Folderに設定情報を格納
72+ ConfigFolder.setConfig(batchConfig, jobConfig);
73+
74+ // Controller作成
75+ IJobController jobController = (IJobController)ClassUtility.createInstance(batchConfig.getBatchParam("controller"));
76+ // 実行
77+ jobController.execute();
78+ } catch (BaseException be) {
79+ logger.info("JavaMain - exec - error1");
80+ throw be;
81+ } catch (Exception e) {
82+ logger.info("JavaMain - exec - error2");
83+ throw new BaseException(e);
84+ }
85+ logger.debug("JavaMain - exec - end");
86+ }
87+
88+ public static void shutdownMainProccess() {
89+ System.exit(0);
90+ }
91+
92+ private static Map crateBaseSettingParameters(Map updateMap) {
93+ Map parameters = new HashMap(7);
94+
95+ parameters.put("controller", "galleryes.base.DefaultJobController");
96+ parameters.put("maxloop", "-1");
97+ parameters.put("looptimewait", "60000");
98+ parameters.put("normalendfile", "nend");
99+ parameters.put("endfile", "end");
100+ parameters.put("startchkfile", "start");
101+ parameters.put("reloop", "false");
102+
103+ if (updateMap != null) {
104+ // TODO:Nonimplement
105+ // Setting Overwrite
106+ }
107+ return parameters;
108+ }
109+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/lang/BaseException.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/lang/BaseException.java (revision 9)
@@ -0,0 +1,42 @@
1+package galleryes.base.lang;
2+
3+/**
4+ * Exceptionの共通クラス.<br>
5+ *
6+ * @author T.Okuyama
7+ * @license GPL(Lv3)
8+ */
9+public class BaseException extends Exception {
10+
11+ public BaseException() {
12+ super();
13+ }
14+
15+ /**
16+ * コンストラクタ
17+ *
18+ * @param message 例外文字列
19+ */
20+ public BaseException(String message) {
21+ super(message);
22+ }
23+
24+ /**
25+ * コンストラクタ
26+ *
27+ * @param message 例外文字列
28+ * @param th 例外
29+ */
30+ public BaseException(String message, Throwable th) {
31+ super(message, th);
32+ }
33+
34+ /**
35+ * コンストラクタ
36+ *
37+ * @param th 例外
38+ */
39+ public BaseException(Throwable th) {
40+ super(th);
41+ }
42+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/lang/BatchDefine.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/lang/BatchDefine.java (revision 9)
@@ -0,0 +1,88 @@
1+package galleryes.base.lang;
2+
3+/**
4+ * フレームワークが使用する定数値定義用クラス.<br>
5+ *
6+ * @author T.Okuyama
7+ * @license GPL(Lv3)
8+ */
9+public class BatchDefine {
10+
11+ // AbstractJobのステータス文字列
12+ public static final String JOB_STATUS_WAIT = "job_wait";
13+ public static final String JOB_STATUS_RUN = "job_run";
14+ public static final String JOB_STATUS_ERR = "job_err";
15+ public static final String JOB_STATUS_END = "job_end";
16+
17+ // JobEndWaitWorkerのステータス文字列とチェック間隔時間(ms)
18+ public static final String JOB_END_WAIT_WORKER_WAIT = "wait_worker_wait";
19+ public static final String JOB_END_WAIT_WORKER_RUN = "wait_worker_run";
20+ public static final String JOB_END_WAIT_WORKER_ERR = "wait_worker_err";
21+ public static final String JOB_END_WAIT_WORKER_END = "wait_worker_end";
22+ public static final long JOB_END_WAIT_WORKER_TIMER = 50000;
23+
24+ // HelperPoolWorkerのステータス文字列とHelperチェック間隔時間(ms)
25+ public static final String HELPER_POOL_WORKER_WAIT = "helper_pool_worker_wait";
26+ public static final String HELPER_POOL_WORKER_RUN = "helper_pool_worker_run";
27+ public static final String HELPER_POOL_WORKER_ERR = "helper_pool_worker_err";
28+ public static final String HELPER_POOL_WORKER_END = "helper_pool_worker_end";
29+ public static final long HELPER_POOL_WORKER_TIMER = 50000;
30+
31+
32+ // ジョブ設定ファイルのキー文字列
33+ public static final String JOB_CONFIG_JOBLIST_KEY = "joblist";
34+ public static final String JOB_CONFIG_HELPERLIST_KEY = "helperlist";
35+ public static final String JOB_CONFIG_JOBLIST_SEP = ",";
36+ public static final String JOB_CONFIG_JOIN_SEP = ".";
37+ public static final String JOB_CONFIG_CLASS_KEY = "JobClass";
38+ public static final String JOB_CONFIG_HELPER_CLASS_KEY = "HelperClass";
39+ public static final String JOB_CONFIG_INIT_KEY = "Init";
40+ public static final String JOB_CONFIG_OPTION_KEY = "Option";
41+ public static final String JOB_CONFIG_HELPER_LIMIT_KEY = "Limit";
42+ public static final String JOB_CONFIG_HELPER_MAX_USE_KEY = "MaxUse";
43+ public static final String JOB_CONFIG_DEPEND_KEY = "Depend";
44+ public static final String JOB_CONFIG_DEPEND_SEP = ",";
45+ public static final String JOB_CONFIG_DBGROUP_KEY = "Dbgroup";
46+ public static final String JOB_CONFIG_DBGROUP_SEP = ",";
47+ public static final String JOB_CONFIG_COMMIT_KEY = "Commit";
48+ public static final String JOB_CONFIG_COMMIT_TYPE1 = "system";
49+ public static final String JOB_CONFIG_COMMIT_TYPE2 = "auto";
50+ public static final String JOB_CONFIG_COMMIT_TYPE3 = "user";
51+
52+ public static final String JOB_CONFIG_HELPER_DBGROUP_KEY = "Dbgroup";
53+ public static final String JOB_CONFIG_HELPER_DBGROUP_SEP = ",";
54+ public static final String JOB_CONFIG_HELPER_COMMIT_KEY = "Commit";
55+ public static final String JOB_CONFIG_HELPER_COMMIT_TYPE1 = "system";
56+ public static final String JOB_CONFIG_HELPER_COMMIT_TYPE2 = "auto";
57+ public static final String JOB_CONFIG_HELPER_COMMIT_TYPE3 = "user";
58+
59+
60+
61+
62+ // バッチ設定ファイルのキー文字列
63+ public static final String BATCH_CONFIG_CONTROLLER = "controller";
64+ public static final String BATCH_CONFIG_MAXLOOP = "maxloop";
65+ public static final String BATCH_CONFIG_LOOPTIMEWAIT = "looptimewait";
66+ public static final String BATCH_CONFIG_STARTCHKFILE = "startchkfile";
67+ public static final String BATCH_CONFIG_NORMALENDFILE = "normalendfile";
68+ public static final String BATCH_CONFIG_ENDFILE = "endfile";
69+ public static final String BATCH_CONFIG_RELOOP = "reloop";
70+ public static final String BATCH_CONFIG_PREPROCESS = "preprocess";
71+ public static final String BATCH_CONFIG_PREPROCESSOPTION = "preprocessoption";
72+ public static final String BATCH_CONFIG_POSTPROCESS = "postprocess";
73+ public static final String BATCH_CONFIG_POSTPROCESSOPTION = "postprocessoption";
74+ public static final String BATCH_CONFIG_ERRORPROCESS = "errorprocess";
75+ public static final String BATCH_CONFIG_ERRORPROCESSOPTION = "errorprocessoption";
76+ public static final String BATCH_CONFIG_SQL_DUMP_LOG = "sqldumplog";
77+ public static final String BATCH_CONFIG_DATABASEDRIVER = "databasedriver";
78+ public static final String BATCH_CONFIG_DATABASENAME = "databasename";
79+ public static final String BATCH_CONFIG_DATABASEUSER = "databaseuser";
80+ public static final String BATCH_CONFIG_DATABASEPASS = "databasepass";
81+ public static final String BATCH_CONFIG_COMMIT = "commit";
82+ public static final String BATCH_CONFIG_STATUSSERVER = "statusserver";
83+
84+ public static final String COMMIT_TYPE_SYSTEM = "system";
85+ public static final String COMMIT_TYPE_AUTO = "auto";
86+ public static final String COMMIT_TYPE_USER = "user";
87+
88+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/DefaultJobController.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/DefaultJobController.java (revision 9)
@@ -0,0 +1,725 @@
1+package galleryes.base;
2+
3+import java.util.ArrayList;
4+import java.util.Hashtable;
5+import java.io.*;
6+import java.net.*;
7+
8+import galleryes.base.lang.BaseException;
9+import galleryes.base.lang.BatchDefine;
10+import galleryes.base.job.AbstractJob;
11+import galleryes.base.job.IJob;
12+import galleryes.base.parameter.config.ConfigFolder;
13+import galleryes.base.parameter.config.BatchConfig;
14+import galleryes.base.parameter.config.JobConfig;
15+import galleryes.base.parameter.config.JobConfigMap;
16+import galleryes.base.parameter.config.HelperConfigMap;
17+import galleryes.base.process.IErrorProcess;
18+import galleryes.base.process.IProcess;
19+
20+import galleryes.base.util.ClassUtility;
21+import galleryes.base.util.ILogger;
22+import galleryes.base.util.HelperPool;
23+import galleryes.base.util.LoggerFactory;
24+import galleryes.base.util.JobEndWaitWorker;
25+
26+/**
27+ * Job実行コントローラクラス.<br>
28+ * 標準版.<br>
29+ * JobConfigの情報に従って処理を実行.<br>
30+ *
31+ * @author T.Okuyama
32+ * @license GPL(Lv3)
33+ */
34+public class DefaultJobController implements IJobController {
35+
36+ // Logger
37+ private ILogger logger = LoggerFactory.createLogger(DefaultJobController.class);
38+
39+
40+ // 監視回数
41+ private int maxLoop = 0;
42+ // 監視間隔時間(ミリ秒)
43+ private int loopTimewait = 0;
44+
45+ // 開始確認ファイル
46+ private String startChkFile = null;
47+ // 開始確認NGの場合の一時停止時間(ミリ秒)
48+ private int startChkTimewait = 250;
49+ // 標準終了ファイル
50+ private String normalEndFile = null;
51+ // 強制終了ファイル
52+ private String endFile = null;
53+
54+ // 最大枠ループ指定
55+ private boolean reloop = false;
56+
57+ // preprocessクラス名
58+ private String preProcessClass = null;
59+ // preprocessオプション文字列
60+ private String preProcessOption = null;
61+
62+ // postprocess名
63+ private String postProcessClass = null;
64+ // postprocessオプション文字列
65+ private String postProcessOption = null;
66+
67+ // errprocess名
68+ private String errProcessClass = null;
69+ // errprocessオプション文字列
70+ private String errProcessOption = null;
71+
72+ // 全Jobインスタンス格納テーブル
73+ private Hashtable jobTable = null;
74+
75+ // 全Jobのステータス格納用テーブル
76+ private Hashtable allJobStatusTable = null;
77+
78+ // 全Job名リスト
79+ private String[] jobNameList = null;
80+
81+ // Job終了待ち受けクラス(標準終了ファイルが配置された場合に使用)
82+ private JobEndWaitWorker jobEndWaitWorker = null;
83+
84+
85+
86+
87+ /**
88+ * コントローラ実行メソッド.<br>
89+ *
90+ * @throw BaseException
91+ */
92+ public void execute() throws BaseException {
93+ logger.debug("execute - start");
94+ BatchConfig batchConfig = null;
95+ JobConfig jobConfig = null;
96+
97+ try {
98+ batchConfig = ConfigFolder.getBatchConfig();
99+ jobConfig = ConfigFolder.getJobConfig();
100+
101+ // 設定情報を自身に蓄える
102+ this.initConfigSet(batchConfig);
103+
104+ // 処理の実行を委譲
105+ this.executeJob(jobConfig);
106+ } catch (BaseException be) {
107+ logger.error("execute - error", be);
108+ throw be;
109+ }
110+ logger.debug("execute - end");
111+ }
112+
113+
114+ /**
115+ * 設定情報初期化メソッド.<br>
116+ * 自身に設定情報を蓄える.<br>
117+ *
118+ * @param batchConfig 設定情報
119+ * @throws BaseException
120+ */
121+ private void initConfigSet(BatchConfig batchConfig) throws BaseException {
122+ logger.debug("initConfigSet - start");
123+ try {
124+ // 必須設定情報を設定
125+ this.maxLoop = Integer.parseInt(batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_MAXLOOP));
126+ this.loopTimewait = Integer.parseInt(batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_LOOPTIMEWAIT));
127+ this.normalEndFile = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_NORMALENDFILE);
128+ this.endFile = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_ENDFILE);
129+
130+ // 設定ファイル確認
131+ if (this.endFile == null || this.normalEndFile == null )
132+ throw new BaseException("Batch ConfigFile Error EndFil Error");
133+
134+
135+ // 必須ではない設定情報を設定
136+ // 開始チェックファイル
137+ this.startChkFile = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_STARTCHKFILE);
138+
139+ // reloopはチェック
140+ if (batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_RELOOP) != null) {
141+ String reloopCheck = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_RELOOP);
142+
143+ if (reloopCheck.equals("true") || reloopCheck.equals("false")) {
144+ this.reloop = new Boolean(reloopCheck).booleanValue();
145+ } else {
146+ throw new BaseException("Batch ConfigFile Error reloop Param");
147+ }
148+ }
149+
150+ // Process設定格納
151+ this.preProcessClass = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_PREPROCESS);
152+ this.preProcessOption = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_PREPROCESSOPTION);
153+ this.postProcessClass = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_POSTPROCESS);
154+ this.postProcessOption = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_POSTPROCESSOPTION);
155+ this.errProcessClass = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_ERRORPROCESS);
156+ this.errProcessOption = batchConfig.getBatchParam(BatchDefine.BATCH_CONFIG_ERRORPROCESSOPTION);
157+
158+
159+ } catch(BaseException be) {
160+ logger.error("initConfigSet - error", be);
161+ throw be;
162+ } catch(Exception e) {
163+ logger.error("initConfigSet - error", e);
164+ throw new BaseException(e);
165+ }
166+ logger.debug("initConfigSet - end");
167+ }
168+
169+
170+ /**
171+ * メイン処理.<br>
172+ * Job実行管理メソッド.<br>
173+ *
174+ * @param jobConfig Job設定情報
175+ * @throws BaseException
176+ */
177+ private void executeJob(JobConfig jobConfig) throws BaseException {
178+ logger.debug("executeJob - start");
179+
180+ // Job
181+ AbstractJob job = null;
182+ // Job設定
183+ JobConfigMap jobConfigMap = null;
184+ // Helper設定
185+ HelperConfigMap helperConfigMap = null;
186+
187+
188+ // 現在の実行監視数
189+ int loopCnt = 0;
190+ // 全てのJobが終了しているかを格納
191+ boolean allEnd = true;
192+
193+ // Jobがエラーで終了しているかを格納
194+ boolean jobErrorEnd = false;
195+
196+ boolean reloopFlg = true;
197+
198+ // PreProcessの戻り値
199+ String preProcessRet = null;
200+ // PostProcessの戻り値
201+ String postProcessRet = null;
202+
203+ String[] helperNameList = null;
204+
205+ try {
206+
207+ // reloopがtrueの場合このループで周り続ける
208+ while (reloopFlg) {
209+ if (!this.checkBatchStart()) {
210+ // reloop設定を変更
211+ reloopFlg = this.reloop;
212+ continue;
213+ }
214+
215+ // 終了ファイル確認
216+ if (this.checkBatchEnd()) break;
217+
218+ // Jobの名前一覧を取り出し
219+ this.jobNameList = jobConfig.getJobNameList();
220+ // Jobインスタンス格納用リスト初期化
221+ this.jobTable = new Hashtable(this.jobNameList.length);
222+ // 状態テーブル初期化
223+ this.allJobStatusTable = new Hashtable(this.jobNameList.length);
224+
225+ // preprocessを実行
226+ preProcessRet = this.executeProcess(1);
227+
228+ // 実行Jobをアイドル状態にする
229+ // インスタンス化
230+ for (int i = 0; i < this.jobNameList.length; i++) {
231+
232+ // JobConfig情報取り出し
233+ jobConfigMap = jobConfig.getJobConfig(this.jobNameList[i]);
234+
235+ // Jobインスタンス化
236+ job = ClassUtility.createJobInstance(jobConfigMap.getJobClassName());
237+
238+ // Jobに設定情報を格納
239+ job.setConfig(jobConfigMap);
240+
241+ // PreProcess,PostProcessの戻り値を設定
242+ job.setPreProcess(preProcessRet);
243+ job.setPostProcess(postProcessRet);
244+
245+ // Jobステータスを管理テーブルに格納
246+ this.allJobStatusTable.put(jobConfigMap.getJobName(), job.getStatus());
247+
248+ // アイドルTableに格納
249+ this.jobTable.put(this.jobNameList[i], job);
250+ }
251+
252+ // Helperをアイドル状態にする
253+ helperNameList = jobConfig.getHelperNameList();
254+
255+ // HelperPoolを完全初期化
256+ HelperPool.initializeHelperPool();
257+ for (int helperNameListIndex = 0; helperNameListIndex < helperNameList.length; helperNameListIndex++) {
258+ helperConfigMap = jobConfig.getHelperConfig(helperNameList[helperNameListIndex]);
259+ HelperPool.managedHelperConfig(helperConfigMap);
260+ }
261+
262+ HelperPool helperPool = new HelperPool();
263+ helperPool.start();
264+ // 標準終了ファイル確認(全てのJobアイドルになってから確認)
265+ if (this.checkNormalBatchEnd()) break;
266+
267+ // 実行監視回数初期化
268+ loopCnt = 0;
269+
270+ // 実行監視開始
271+ while (true) {
272+ // 強制終了ファイル確認
273+ if (this.checkBatchEnd()) break;
274+ // 標準終了ファイル確認
275+ if (this.checkNormalBatchEnd()) break;
276+
277+ logger.debug("Job Watch - start");
278+
279+ // 全てのJob完了フラグを初期化
280+ allEnd = true;
281+ jobErrorEnd = false;
282+
283+ // Jobを1づつ実行OKか確認して実行
284+ for (int jobIndex = 0; jobIndex < this.jobNameList.length; jobIndex++) {
285+
286+ // インスタンス化したJob
287+ job = (AbstractJob)this.jobTable.get(this.jobNameList[jobIndex]);
288+
289+ // JobConfig情報取り出し
290+ jobConfigMap = jobConfig.getJobConfig(this.jobNameList[jobIndex]);
291+
292+ logger.debug("Job Status Check Job Name[" + jobConfigMap.getJobName() + "]");
293+
294+ // 実行状態に合わせて処理を変更
295+ if(job.getStatus().equals(BatchDefine.JOB_STATUS_WAIT)) {
296+ // All End ?
297+ allEnd = false;
298+
299+ // 実行待ち状態
300+ // Jobの依存状態確認
301+ if (!jobConfigMap.isDepend()) {
302+
303+ // 依存関係無し
304+ // 実行
305+ job.start();
306+ // Jobステータスを管理テーブルに格納
307+ this.allJobStatusTable.put(jobConfigMap.getJobName(), BatchDefine.JOB_STATUS_RUN);
308+ } else {
309+
310+ // 依存関係有り
311+ // 依存関係のあるJobの状態確認
312+ if (this.checkDepend(jobConfigMap)) {
313+ // 依存関係のあるJobが全て終了しているのでJob実行
314+ job.start();
315+ // Jobステータスを管理テーブルに格納
316+ this.allJobStatusTable.put(jobConfigMap.getJobName(), BatchDefine.JOB_STATUS_RUN);
317+ }
318+ }
319+ } else if (job.getStatus().equals(BatchDefine.JOB_STATUS_ERR)) {
320+
321+ // エラー発生
322+ // Jobステータスがエラーの場合はここで状態管理テーブルに格納
323+ this.allJobStatusTable.put(jobConfigMap.getJobName(), job.getStatus());
324+
325+ // reloopの設定がtrueの場合1件でもJobがエラーの場合も終了せずに実行中のJobの終了を待つ
326+ // reloopがfalseの場合は直ちに終了
327+ // 両方とも後続ジョブを行わない
328+ if (this.reloop) {
329+ logger.error("Job Status Error End Job Name[" + jobConfigMap.getJobName() + "]");
330+ this.runJobEndWait();
331+ // ErrorProcess実行
332+ this.executeErrorProcess();
333+ jobErrorEnd = true;
334+ break;
335+ } else {
336+ throw new BaseException("Job Status Error End JobName[" + jobConfigMap.getJobName() + "]");
337+ }
338+
339+ } else if (job.getStatus().equals(BatchDefine.JOB_STATUS_RUN)) {
340+
341+ // Jobステータスを管理テーブルに格納
342+ this.allJobStatusTable.put(jobConfigMap.getJobName(), BatchDefine.JOB_STATUS_RUN);
343+
344+ // 現在実行中
345+ allEnd = false;
346+ } else if (job.getStatus().equals(BatchDefine.JOB_STATUS_END)) {
347+
348+ // Jobステータスを管理テーブルに格納
349+ this.allJobStatusTable.put(jobConfigMap.getJobName(), BatchDefine.JOB_STATUS_END);
350+ }
351+
352+ // JobTableに戻す
353+ this.jobTable.put(this.jobNameList[jobIndex], job);
354+ }
355+
356+ // 現在のJobステータスを出力
357+ logger.debug("Now All Job Status :" + this.allJobStatusTable);
358+ logger.debug("Job Watch - end");
359+ // Jobがエラーで終了しているか確認
360+
361+ if (jobErrorEnd) {
362+ logger.info("Job Watch - Job Error");
363+
364+ break;
365+ }
366+
367+ // 全てのJobが終了しているか確認
368+ if (allEnd){
369+ logger.info("Job Watch - All Job End");
370+ break;
371+ }
372+
373+
374+ // 実行監視サイクル確認
375+ if (maxLoop != -1) {
376+
377+ loopCnt++;
378+ // 監視回数到達
379+ if(maxLoop == loopCnt) {
380+
381+ logger.error("Job WatchLimitCount Over!!");
382+ // reloopの設定がtrueの場合は上限でもバッチは終了せずに現在実行中のJobの終了を待つ、reloopがfalseの場合は直ちに終了
383+ if (this.reloop) {
384+ this.runJobEndWait();
385+ // ErrorProcess実行
386+ this.executeErrorProcess();
387+ break;
388+ } else {
389+ throw new BaseException("Exception - Job WatchLimitCount Over!!");
390+ }
391+ }
392+ }
393+
394+ // 一時停止
395+ logger.debug("Job Watch - sleep");
396+ Thread.sleep(loopTimewait);
397+ }
398+
399+ // Helperの監視を終了
400+ helperPool.poolEnd();
401+ helperPool.join(60000);
402+ helperPool = null;
403+
404+ logger.debug("Job Watch - finish");
405+
406+ // PostProcess実行
407+ postProcessRet = this.executeProcess(2);
408+
409+ // reloop設定を変更
410+ reloopFlg = this.reloop;
411+ }
412+ } catch (BaseException be) {
413+ logger.error("executeJob - error", be);
414+ // ErrorProcess実行
415+ this.executeErrorProcess();
416+ throw be;
417+ } catch (Exception e) {
418+ logger.error("executeJob - error", e);
419+ throw new BaseException(e);
420+ }
421+
422+ logger.debug("executeJob - end");
423+ }
424+
425+
426+ /**
427+ * Pre、PostProcessクラスを実行.<br>
428+ *
429+ * @param type 1:preprocess 2:postprocess
430+ * @return String それぞれのprocessの戻り値を返す
431+ * @throws BaseException
432+ */
433+ public String executeProcess(int type) throws BaseException {
434+ logger.debug("executeProcess - start");
435+ IProcess processClass = null;
436+ String processOption = null;
437+ String ret = null;
438+
439+ try {
440+ // 呼び出しパターンによってクラスを切り替え
441+ if (type == 1) {
442+
443+ // PreProcess
444+ if(this.preProcessClass != null && !this.preProcessClass.equals("")) {
445+ processClass = (IProcess)ClassUtility.createInstance(this.preProcessClass);
446+ processOption = this.preProcessOption;
447+ }
448+ } else if(type == 2) {
449+
450+ // PostProcess
451+ if(this.postProcessClass != null && !this.postProcessClass.equals("")) {
452+ processClass = (IProcess)ClassUtility.createInstance(this.postProcessClass);
453+ processOption = this.postProcessOption;
454+ }
455+ } else {
456+
457+ // エラー
458+ ;
459+ }
460+
461+ // 設定が存在する場合のみ実行
462+ if (processClass != null)
463+ ret = processClass.process(processOption);
464+ } catch (BaseException be) {
465+ logger.error("executeProcess - error", be);
466+ throw be;
467+ } catch (Exception e) {
468+ logger.error("executeProcess - error", e);
469+ throw new BaseException(e);
470+ }
471+ logger.debug("executeProcess - end");
472+ return ret;
473+ }
474+
475+
476+ /**
477+ * ErrorProcessクラスを実行.<br>
478+ * 本メソットは例外をスローしない.<br>
479+ * 例外内容のみログに吐き出す.<br>
480+ */
481+ public void executeErrorProcess() {
482+ logger.debug("executeErrorProcess - start");
483+ IErrorProcess processClass = null;
484+
485+ try {
486+
487+ // ErrorProcessの設定を確認
488+ if(this.errProcessClass != null && !this.errProcessClass.equals("")) {
489+ // 設定が存在する場合のみ実行
490+ processClass = (IErrorProcess)ClassUtility.createInstance(this.errProcessClass);
491+ processClass.errorProcess(this.jobTable, this.allJobStatusTable, this.errProcessOption);
492+ }
493+
494+ } catch (BaseException be) {
495+ logger.error("executeErrorProcess - error ", be);
496+ // スロー無し
497+ } catch (Exception e) {
498+ logger.error("executeErrorProcess - error ", e);
499+ // スロー無し
500+ }
501+ logger.debug("executeErrorProcess - end");
502+ }
503+
504+
505+ /**
506+ * バッチの開始確認ファイル有無を確認.<br>
507+ * 本メソッドを呼び出し、開始NGファイルがある場合CPUの負荷を分散するために<br>
508+ * startChkTimewaitに設定された時間停止する.<br>
509+ *
510+ *
511+ * @return boolean true:開始OK false:開始NG
512+ * @throws BaseException
513+ */
514+ private boolean checkBatchStart() throws BaseException {
515+ logger.debug("checkBatchStart - start");
516+ boolean ret = true;
517+ try {
518+ // ファイルの設定がない場合は無条件で開始OK
519+ if (this.startChkFile == null) return ret;
520+
521+ File file = new File(new File(this.startChkFile).getAbsolutePath());
522+ if (file.exists()) {
523+ ret = false;
524+ Thread.sleep(startChkTimewait);
525+ logger.info("checkBatchEnd - Start NGFile Exists");
526+ }
527+ } catch (Exception e) {
528+ logger.error("checkBatchStart - error", e);
529+ throw new BaseException(e);
530+ }
531+ logger.debug("checkBatchStart - end");
532+ return ret;
533+ }
534+
535+
536+ /**
537+ * バッチの強制終了ファイル有無を確認.<br>
538+ *
539+ * @return boolean true:終了 false:続行
540+ * @throws BaseException
541+ */
542+ private boolean checkBatchEnd() throws BaseException {
543+ logger.debug("checkBatchEnd - start");
544+ boolean ret = false;
545+ try {
546+ File file = new File(new File(this.endFile).getAbsolutePath());
547+ if (file.exists()) {
548+ ret = true;
549+ logger.info("checkBatchEnd - End File Exists");
550+ }
551+ } catch (Exception e) {
552+ logger.error("checkBatchEnd - error", e);
553+ throw new BaseException(e);
554+ }
555+ logger.debug("checkBatchEnd - end");
556+ return ret;
557+ }
558+
559+ /**
560+ * 現在RUNのステータスになっているJobを終了するのを待つ<br>
561+ * スレッドを起動する.<br>
562+ *
563+ * @throws Exception
564+ */
565+ public void runJobEndWait() throws Exception {
566+ logger.debug("runJobEndWait - start");
567+ AbstractJob job = null;
568+ ArrayList jobs = null;
569+ int runJobCount = 0;
570+
571+ try {
572+
573+ // 終了待ちスレッド起動準備
574+
575+ // RUNになっているJobを数える
576+ if (this.jobNameList != null && this.jobNameList.length > 0) {
577+
578+ jobs = new ArrayList();
579+ for (int i = 0; i < this.jobNameList.length; i++) {
580+ job = (AbstractJob)this.jobTable.get(this.jobNameList[i]);
581+
582+ if (job.getStatus().equals(BatchDefine.JOB_STATUS_RUN)) {
583+ jobs.add(job);
584+ }
585+ }
586+
587+ // 終了待ちスレッド起動
588+ this.jobEndWaitWorker = new JobEndWaitWorker();
589+ this.jobEndWaitWorker.setTargetJobs(jobs);
590+ this.jobEndWaitWorker.start();
591+
592+ // 終了待ちスレッドが終了するのを待つ
593+ while(true) {
594+
595+ // 終了待機スレッド確認
596+ // エラーになっていないか?
597+ if (this.jobEndWaitWorker.getStatus().equals(BatchDefine.JOB_END_WAIT_WORKER_ERR))
598+ throw new BaseException("JobEndWaitWorker Error");
599+ // 終了していないか?
600+ if (this.jobEndWaitWorker.getStatus().equals(BatchDefine.JOB_END_WAIT_WORKER_END)) break;
601+
602+ // 強制終了ファイル確認
603+ if (this.checkBatchEnd()) break;
604+
605+ logger.debug("runJobEndWait - run Job Wait");
606+ Thread.sleep(BatchDefine.JOB_END_WAIT_WORKER_TIMER);
607+ }
608+ }
609+ } catch (Exception e) {
610+ logger.error("runJobEndWait - error", e);
611+ throw e;
612+ }
613+ logger.debug("runJobEndWait - end");
614+ }
615+
616+ /**
617+ * 標準終了ファイルの存在を確認し存在する場合は<br>
618+ * 現在RUNのステータスになっているJobを終了するのを待つ<br>
619+ * スレッドを起動する.<br>
620+ * スレッド起動後再度このメソッドが呼ばれた場合はそのスレッドの<br>
621+ * 終了を確認するそのスレッドが終了したタイミングで<br>
622+ * 終了したことをリターンで通知する.<br>
623+ *
624+ * @return boolean true:終了ファイルあり false:終了ファイルなし
625+ * @throws Exception
626+ */
627+ public boolean checkNormalBatchEnd() throws Exception {
628+ logger.debug("checkNormalBatchEnd - start");
629+ boolean ret = false;
630+ AbstractJob job = null;
631+ ArrayList jobs = null;
632+ int runJobCount = 0;
633+
634+ try {
635+ File file = new File(new File(this.normalEndFile).getAbsolutePath());
636+ if (file.exists()) {
637+ logger.debug("checkNormalBatchEnd - Normal End File Exists");
638+
639+ ret = true;
640+
641+ // 終了待ちスレッド起動準備
642+
643+ // RUNになっているJobを数える
644+ if (this.jobNameList != null && this.jobNameList.length > 0) {
645+
646+ jobs = new ArrayList();
647+ for (int i = 0; i < this.jobNameList.length; i++) {
648+ job = (AbstractJob)this.jobTable.get(this.jobNameList[i]);
649+
650+ if (job.getStatus().equals(BatchDefine.JOB_STATUS_RUN)) {
651+ jobs.add(job);
652+ }
653+ }
654+
655+ // 終了待ちスレッド起動
656+ this.jobEndWaitWorker = new JobEndWaitWorker();
657+ this.jobEndWaitWorker.setTargetJobs(jobs);
658+ this.jobEndWaitWorker.start();
659+
660+ // 終了待ちスレッドが終了するのを待つ
661+ while(true) {
662+
663+ // 終了待機スレッド確認
664+ // エラーになっていないか?
665+ if (this.jobEndWaitWorker.getStatus().equals(BatchDefine.JOB_END_WAIT_WORKER_ERR))
666+ throw new BaseException("JobEndWaitWorker - Error");
667+ // 終了していないか?
668+ if (this.jobEndWaitWorker.getStatus().equals(BatchDefine.JOB_END_WAIT_WORKER_END)) break;
669+
670+ // 強制終了ファイル確認
671+ if (this.checkBatchEnd()) break;
672+
673+ logger.info("checkNormalBatchEnd - Run Job Wait");
674+ Thread.sleep(BatchDefine.JOB_END_WAIT_WORKER_TIMER);
675+ }
676+ }
677+ }
678+ } catch (Exception e) {
679+ logger.error("checkNormalBatchEnd - error", e);
680+ throw e;
681+ }
682+ logger.debug("checkNormalBatchEnd - end");
683+ return ret;
684+ }
685+
686+
687+ /**
688+ * 依存関係チェック.<br>
689+ *
690+ * @param jobConfigMap Job情報
691+ * @return boolean true:依存関係Job全終了 false:依存関係Jobが終了していない
692+ * @throws BaseException
693+ */
694+ private boolean checkDepend(JobConfigMap jobConfigMap) throws BaseException {
695+ logger.debug("checkDepend - start");
696+ boolean checkFlg = true;
697+ String[] dependJobList = null;
698+ String dependJobStatus = null;
699+
700+ try {
701+ dependJobList = jobConfigMap.getJobDependList();
702+ // 依存関係のあるJobの状態を確認
703+ for (int dependIndex = 0; dependIndex < dependJobList.length; dependIndex++) {
704+
705+ // 依存関係の設定確認
706+ if(this.allJobStatusTable.containsKey(dependJobList[dependIndex])) {
707+
708+ // 依存関係確認
709+ dependJobStatus = (String)this.allJobStatusTable.get(dependJobList[dependIndex]);
710+ // 1件でも終了していない場合は実行しない
711+ if (!dependJobStatus.equals(BatchDefine.JOB_STATUS_END)) checkFlg = false;
712+ } else {
713+ throw new BaseException("Depend Config Error:" + jobConfigMap.getJobName());
714+ }
715+ }
716+ } catch(BaseException be) {
717+ logger.error("checkDepend -error", be);
718+ throw be;
719+ }
720+ logger.debug("checkDepend - end");
721+ return checkFlg;
722+ }
723+}
724+
725+
--- trunk/branch001/src/galleryes/base/IJobController.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/IJobController.java (revision 9)
@@ -0,0 +1,17 @@
1+package galleryes.base;
2+
3+import galleryes.base.lang.BaseException;
4+import galleryes.base.parameter.config.JobConfig;
5+import galleryes.base.parameter.config.BatchConfig;
6+
7+/**
8+ * JobControllerクラスのインタフェース.<br>
9+ *
10+ * @author T.Okuyama
11+ * @license GPL(Lv3)
12+ */
13+public interface IJobController {
14+
15+ public void execute() throws BaseException;
16+
17+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/job/IJob.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/job/IJob.java (revision 9)
@@ -0,0 +1,34 @@
1+package okuyama.base.job;
2+
3+import okuyama.base.lang.BaseException;
4+
5+
6+/**
7+ * Job実行クラスのインタフェース.<br>
8+ * 実行順序としては、initJobが呼び出され、<br>
9+ * その後、executeJobが呼び出される.<br>
10+ *
11+ *
12+ * @author T.Okuyama
13+ * @license GPL(Lv3)
14+ */
15+public interface IJob {
16+
17+ /**
18+ * 特殊な初期化の処理を行う
19+ *
20+ * @param initValue 初期値(設定ファイルの「init」で指定した値になる)
21+ */
22+ public void initJob(String initValue) ;
23+
24+
25+ /**
26+ * Job実行部分.<br>
27+ * ユーザ実装部分<br>
28+ *
29+ * @param optionParam 初期値(設定ファイルの「option」で指定した値になる)
30+ * @return String 自身の親クラスの定義文字列 SUCCESS, ERROR
31+ * @throws BaseException
32+ */
33+ public String executeJob(String optionParam) throws BaseException;
34+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/job/AbstractHelper.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/job/AbstractHelper.java (revision 9)
@@ -0,0 +1,458 @@
1+package galleryes.base.job;
2+
3+import java.util.ArrayList;
4+import java.util.HashMap;
5+import java.util.concurrent.ConcurrentHashMap;
6+import java.util.concurrent.ConcurrentLinkedQueue;
7+
8+import galleryes.base.parameter.config.ConfigFolder;
9+import galleryes.base.parameter.config.HelperConfigMap;
10+import galleryes.base.lang.BaseException;
11+import galleryes.base.lang.BatchDefine;
12+import galleryes.base.util.ILogger;
13+import galleryes.base.util.LoggerFactory;
14+import galleryes.base.util.HelperPool;
15+
16+/**
17+ * JobHelperの基底クラス.<br>
18+ *
19+ * @author T.Okuyama
20+ * @license GPL(Lv3)
21+ */
22+// ExecutorService を使用するために変更
23+//abstract public class AbstractHelper extends Thread {
24+abstract public class AbstractHelper implements Runnable{
25+
26+ // Logger
27+ private ILogger logger = LoggerFactory.createLogger(AbstractHelper.class);
28+
29+ // wait:実行待ち
30+ public static String WAIT = BatchDefine.JOB_STATUS_WAIT;
31+
32+ // run:実行中
33+ public static String RUN = BatchDefine.JOB_STATUS_RUN;
34+
35+ // err:エラー
36+ public static String ERR = BatchDefine.JOB_STATUS_ERR;
37+
38+ // end:終了
39+ public static String END = BatchDefine.JOB_STATUS_END;
40+
41+ // 正しく実行終了
42+ protected static String SUCCESS = END;
43+
44+ // エラー実行終了
45+ protected static String ERROR = ERR;
46+
47+ // 自身のステータス
48+ // wait:実行待ち
49+ // run:実行中
50+ // err:エラー
51+ // end:終了
52+ protected String status = WAIT;
53+
54+ // 自身の設定情報
55+ protected HelperConfigMap helperConfigMap = null;
56+
57+ // 使用回数
58+ private int useCount = 0;
59+
60+ // 再起動設定
61+ private boolean reboot = false;
62+
63+ private String name = null;
64+
65+ private boolean threadEnd = false;
66+
67+ /**
68+ * Helper同士で値やり取りを行う領域.<br>
69+ * 一度登録した値はHelperが終了するまで維持される.<br>
70+ */
71+ private static ConcurrentHashMap helperParamShareMap = new ConcurrentHashMap(1024, 512, 1024);
72+
73+ // 呼び出し時に直接渡すパラメータ
74+ private Object[] parameters = null;
75+
76+ // Helper実行後に返したい値を格納する
77+ private Object returnParameter = null;
78+
79+
80+
81+ /**
82+ * コンストラクタ
83+ */
84+ public AbstractHelper() {
85+ }
86+
87+
88+ /**
89+ * Queueの現在のサイズを返す
90+ *
91+ * @param params パラメータ
92+ * @return int
93+ */
94+ public int getParameterQueueSize(String helperName) throws Exception {
95+ int ret = -1;
96+ try {
97+ ret = HelperPool.getParameterQueueSize(helperName);
98+ } catch (Exception e) {
99+ throw e;
100+ }
101+ return ret;
102+ }
103+
104+
105+ /**
106+ * 最もサイズの小さいQueueに追加する
107+ *
108+ * @param params パラメータ
109+ * @return int
110+ */
111+ public void addSmallSizeParameterQueue(String helperNames[], Object[] params) throws Exception {
112+ try {
113+ String targetQueue = null;
114+ boolean fix = false;
115+ int targetSize = Integer.MAX_VALUE;
116+
117+ for (int i = 0; i < helperNames.length; i++) {
118+ int size = this.getParameterQueueSize(helperNames[i]);
119+ if (size == 0 ) {
120+ // メソッドチェーンいやなので!
121+ // 多分なにもかわらん。。
122+ HelperPool.addSpecificationParameterQueue(helperNames[i], params, false);
123+ fix = true;
124+ break;
125+ } else if(targetSize > size) {
126+ targetSize = size;
127+ targetQueue = helperNames[i];
128+ }
129+ }
130+
131+ if (!fix) addSpecificationParameterQueue(targetQueue, params, false);
132+ } catch (Exception e) {
133+ throw e;
134+ }
135+ }
136+
137+
138+ /**
139+ * Helper用のパラメータQueueに追加
140+ *
141+ * @param params パラメータ
142+ * @return int
143+ */
144+ public void addSpecificationParameterQueue(String helperName, Object[] params) throws Exception {
145+ try {
146+ addSpecificationParameterQueue(helperName, params, false);
147+ } catch (Exception e) {
148+ throw e;
149+ }
150+ }
151+
152+
153+ /**
154+ * Helper用のパラメータQueueに追加
155+ *
156+ * @param params パラメータ
157+ * @return int
158+ */
159+ public void addSpecificationParameterQueue(String helperName, Object[] params, boolean debug) throws Exception {
160+ try {
161+ HelperPool.addSpecificationParameterQueue(helperName, params, debug);
162+ } catch (Exception e) {
163+ throw e;
164+ }
165+ }
166+
167+ /**
168+ * Helper用のパラメータQueueに追加
169+ *
170+ * @param params パラメータ
171+ * @return int
172+ */
173+ public void addParameterQueue(Object[] params) throws Exception {
174+ try {
175+ HelperPool.addParameterQueue(params);
176+ } catch (Exception e) {
177+ throw e;
178+ }
179+ }
180+
181+
182+
183+ /**
184+ * Helper用のパラメータQueueから取得
185+ *
186+ * @return Object[] パラメータ
187+ */
188+ public Object[] pollSpecificationParameterQueue(String helperName) {
189+
190+ return (Object[])HelperPool.pollSpecificationParameterQueue(helperName);
191+ }
192+
193+ /**
194+ * Helper用のパラメータQueueから取得
195+ *
196+ * @return Object[] パラメータ
197+ */
198+ public Object[] pollParameterQueue() {
199+ return (Object[])HelperPool.pollParameterQueue();
200+ }
201+
202+ /**
203+ * 初期化メソッド.<br>
204+ */
205+ public void initialize() {
206+ this.status = WAIT;
207+ this.parameters = null;
208+ this.returnParameter = null;
209+ this.useCount++;
210+ }
211+
212+ /**
213+ * 自身の設定情報格納
214+ * @param helperConfigMap Job設定情報
215+ */
216+ public void setConfig(HelperConfigMap helperConfigMap) {
217+ this.helperConfigMap = helperConfigMap;
218+ }
219+
220+ /**
221+ * 自身の設定情報を返す
222+ * @return HelperConfigMap Job設定情報
223+ */
224+ public HelperConfigMap getConfig() {
225+ return this.helperConfigMap;
226+ }
227+
228+
229+ /**
230+ * initHelper.<br>
231+ * ユーザHelper実装部分.<br>
232+ * @param initValue
233+ */
234+ public abstract void initHelper(String initValue);
235+
236+
237+ /**
238+ * executeHelper.<br>
239+ * ユーザHelper実装部分.<br>
240+ *
241+ * @param optionParam
242+ * @return String 実行結果
243+ */
244+ public abstract String executeHelper(String optionParam) throws BaseException;
245+
246+ /**
247+ * endHelper.<br>
248+ * ユーザHelper終了処理部分.<br>
249+ *
250+ * @return String 実行結果
251+ */
252+ public abstract void endHelper();
253+
254+ /**
255+ * メイン実行部分.<br>
256+ * 自身のサブクラスを実行.<br>
257+ * 実行順序はinitHelper - executeHelper.<br>
258+ *
259+ */
260+ public void run() {
261+
262+ logger.debug("Helper - [" + helperConfigMap.getHelperName() + "] - run - start");
263+ String retStatus = null;
264+
265+ // ステータスを実行中に変更
266+ this.status = RUN;
267+
268+
269+ try {
270+
271+
272+ // 初期化メソッド呼び出し
273+ initHelper(this.helperConfigMap.getHelperInit());
274+
275+ // 実行メインメソッド呼び出し
276+ retStatus = executeHelper(this.helperConfigMap.getHelperOption());
277+
278+ // 実行結果確認
279+ if (retStatus != null) {
280+
281+ if (retStatus.equals(SUCCESS)) {
282+ // 正常終了
283+ this.status = retStatus;
284+ } else if(retStatus.equals(ERROR)) {
285+ // エラー終了
286+ this.status = retStatus;
287+ } else {
288+ // 不明
289+ throw new BaseException("Helper End Erro Return Value");
290+ }
291+ } else {
292+ throw new BaseException("Helper End Erro Return Value");
293+ }
294+ } catch (BaseException be) {
295+ logger.error("AbstractHelperJob - run - BaseException ",be);
296+
297+ // ステータスをエラーにする
298+ this.status = ERR;
299+ } catch (Exception e) {
300+ logger.error("AbstractHelperJob - run - Exception",e);
301+ // ステータスをエラーにする
302+ this.status = ERR;
303+ } finally {
304+ threadEnd = true;
305+ }
306+ logger.debug("Helper - run - end");
307+ }
308+
309+
310+
311+ /**
312+ * 自身のステータスを返す.<br>
313+ *
314+ * @return String ステータス文字列
315+ */
316+ public String getStatus() {
317+ return this.status;
318+ }
319+
320+
321+ /**
322+ * Job設定ファイルの自由に設定出来る値を取得する.<br>
323+ * 設定情報が存在しない場合はnullを返す.<br>
324+ *
325+ * @param key 設定情報のキー名
326+ * @return String ユーザ設定パラメータ
327+ **/
328+ protected String getPropertiesValue(String key) {
329+ return ConfigFolder.getJobUserParam(key);
330+ }
331+
332+ /**
333+ * Job設定ファイルの変更をチェック.<br>
334+ *
335+ * @return boolean 変更有無
336+ **/
337+ protected boolean isJobFileChange() throws BaseException {
338+ return ConfigFolder.isJobFileChange();
339+ }
340+
341+ /**
342+ * Job設定ファイルの指定のキー値を再読み込みする.<br>
343+ *
344+ * @param String[] キー値
345+ **/
346+ protected void reloadJobFileParameter(String[] keys) throws BaseException {
347+ ConfigFolder.reloadJobFileParameter(keys);
348+ }
349+
350+ /**
351+ * Helper間で共有する値をセットする.<br>
352+ *
353+ * @param key キー値
354+ * @param val 値
355+ */
356+ public void setHelperShareParam(Object key, Object val) {
357+ helperParamShareMap.put(key, val);
358+ }
359+
360+ /**
361+ * Helper間で共有する値を取得する.<br>
362+ * 存在しない場合はNullを返す.<br>
363+ *
364+ * @param key キー値
365+ * @return Object 値
366+ */
367+ public Object getHelperShareParam(Object key) {
368+ Object ret = null;
369+
370+ if (helperParamShareMap.containsKey(key)) {
371+
372+ ret = helperParamShareMap.get(key);
373+ }
374+ return ret;
375+ }
376+
377+ /**
378+ * Helper間で共有する値を削除する.<br>
379+ *
380+ * @param key キー値
381+ * @return Objet 値
382+ */
383+ public Object removeHelperShareParam(Object key) {
384+ if (helperParamShareMap.containsKey(key)) {
385+ return helperParamShareMap.remove(key);
386+ }
387+ return null;
388+ }
389+
390+
391+ /**
392+ * Helper用のパラメータ設定.<br>
393+ *
394+ * @param parameters パラメータ値
395+ */
396+ public void setParameters(Object[] parameters) {
397+ this.parameters = parameters;
398+ }
399+
400+ /**
401+ * Helper用のパラメータ取得.<br>
402+ *
403+ * @return Object[] パラメータ値
404+ */
405+ public Object[] getParameters() {
406+ return this.parameters;
407+ }
408+
409+
410+ /**
411+ * Helperが終了した際に外部に伝播したいパラメータをセット.<br>
412+ *
413+ * @param Object パラメータ値
414+ */
415+ public void setReturnParameter(Object value) {
416+ this.returnParameter = value;
417+ }
418+
419+ /**
420+ * Helperが終了した際に外部に伝播したいパラメータを取得.<br>
421+ *
422+ * @return Object パラメータ値
423+ */
424+ public Object getReturnParameter() {
425+ return this.returnParameter;
426+ }
427+
428+ //
429+ public int getUseCount() {
430+ return this.useCount;
431+ }
432+
433+
434+ //
435+ public void setReboot(boolean reboot) {
436+ this.reboot = reboot;
437+ }
438+
439+ //
440+ public boolean getReboot() {
441+ return this.reboot;
442+ }
443+
444+
445+ //
446+ public void setName(String name) {
447+ this.name = name;
448+ }
449+
450+ //
451+ public String getName() {
452+ return this.name;
453+ }
454+
455+ public boolean getThreadEnd() {
456+ return threadEnd;
457+ }
458+}
--- trunk/branch001/src/galleryes/base/job/AbstractJob.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/job/AbstractJob.java (revision 9)
@@ -0,0 +1,620 @@
1+package galleryes.base.job;
2+
3+import java.util.ArrayList;
4+import java.util.Hashtable;
5+import java.util.Set;
6+import java.util.Iterator;
7+import java.util.concurrent.ConcurrentHashMap;
8+
9+import galleryes.base.parameter.config.ConfigFolder;
10+import galleryes.base.parameter.config.JobConfigMap;
11+import galleryes.base.parameter.config.HelperConfigMap;
12+import galleryes.base.lang.BaseException;
13+import galleryes.base.lang.BatchDefine;
14+import galleryes.base.util.ILogger;
15+import galleryes.base.util.LoggerFactory;
16+import galleryes.base.util.HelperPool;
17+import galleryes.base.util.ClassUtility;
18+
19+/**
20+ * Jobの基底クラス.<br>
21+ *
22+ * @author T.Okuyama
23+ * @license GPL(Lv3)
24+ */
25+abstract public class AbstractJob extends Thread {
26+
27+ // Logger
28+ private ILogger logger = LoggerFactory.createLogger(AbstractJob.class);
29+
30+ // PreProcessの返値
31+ private String preProcessRet = null;
32+
33+ // PostProcessの返値
34+ private String postProcessRet = null;
35+
36+ // wait:実行待ち
37+ public static String WAIT = BatchDefine.JOB_STATUS_WAIT;
38+
39+ // run:実行中
40+ public static String RUN = BatchDefine.JOB_STATUS_RUN;
41+
42+ // err:エラー
43+ public static String ERR = BatchDefine.JOB_STATUS_ERR;
44+
45+ // end:終了
46+ public static String END = BatchDefine.JOB_STATUS_END;
47+
48+ // 正しく実行終了
49+ protected static String SUCCESS = END;
50+
51+ // エラー実行終了
52+ protected static String ERROR = ERR;
53+
54+ // 自身のステータス
55+ // wait:実行待ち
56+ // run:実行中
57+ // err:エラー
58+ // end:終了
59+ protected String status = WAIT;
60+
61+ // 自身の設定情報
62+ protected JobConfigMap jobConfigMap = null;
63+
64+ /**
65+ * Job間に値やり取りを行う領域.<br>
66+ * 一度登録した値はバッチが終了するまで維持される.<br>
67+ */
68+ private static ConcurrentHashMap jobParamShareMap = new ConcurrentHashMap(10, 10, 10);
69+
70+ /**
71+ * コンストラクタ
72+ */
73+ public AbstractJob() {
74+ }
75+
76+ /**
77+ * 自身の設定情報格納.<br>
78+ *
79+ * @param jobConfigMap Job設定情報
80+ */
81+ public void setConfig(JobConfigMap jobConfigMap) {
82+ this.jobConfigMap = jobConfigMap;
83+ }
84+
85+ /**
86+ * initJob.<br>
87+ * ユーザJob実装部分.<br>
88+ * @param initValue
89+ */
90+ public abstract void initJob(String initValue);
91+
92+ /**
93+ * executeJob.<br>
94+ * ユーザJob実装部分.<br>
95+ *
96+ * @param optionParam
97+ * @return String 実行結果
98+ * @throws BaseException
99+ */
100+ public abstract String executeJob(String optionParam) throws BaseException;
101+
102+
103+
104+ /**
105+ * メイン実行部分.<br>
106+ * 自身のサブクラスを実行.<br>
107+ * 実行順序はinitJob - executeJob.<br>
108+ *
109+ */
110+ public void run() {
111+ logger.debug("Execution - Start");
112+
113+ String retStatus = null;
114+
115+ // ステータスを実行中に変更
116+ this.status = RUN;
117+
118+
119+ try {
120+
121+ // 初期化メソッド呼び出し
122+ initJob(this.jobConfigMap.getJobInit());
123+ // 実行メインメソッド呼び出し
124+ retStatus = executeJob(this.jobConfigMap.getJobOption());
125+
126+ // 実行結果確認
127+ if (retStatus != null) {
128+
129+ if (retStatus.equals(SUCCESS)) {
130+ // 正常終了
131+ this.status = retStatus;
132+ } else if(retStatus.equals(ERROR)) {
133+ // エラー終了
134+ this.status = retStatus;
135+ } else {
136+ // 不明
137+ throw new BaseException("Job End Return Value Error");
138+ }
139+ } else {
140+ throw new BaseException("Job End Return Value Error");
141+ }
142+ } catch (BaseException be) {
143+ logger.error("AbstractJob - Error",be);
144+ // ステータスをエラーにする
145+ this.status = ERR;
146+ } catch (Exception e) {
147+ logger.error("AbstractJob - Error",e);
148+ // ステータスをエラーにする
149+ this.status = ERR;
150+ }
151+ logger.debug("Execution End");
152+ }
153+
154+
155+ /**
156+ * Helperクラスインスタンスを返す.<br>
157+ * Helperが存在しない場合はExceptionを返す.<br>
158+ *
159+ *
160+ * @param helperName helperName名
161+ * @param helpreParams helperパラメータ配列
162+ * @param inputHelperShareParam ヘルパー共有領域に事前に登録したいパラメータ Key-Valueのセットで配列登録すること(inputHelperShareParam[0]=1番目の要素のKey,inputHelperShareParam[1]=1番目の要素のValue,inputHelperShareParam[2]=2番目の要素のKey,inputHelperShareParam[3]=2番目の要素のValue)
163+ * @return AbstractHelper Helperインスタンス
164+ * @throws BaseException
165+ **/
166+ protected int executeHelperQueue(String helperName, Object[] helpreParams, Object[] inputHelperShareParam) throws BaseException {
167+ logger.debug("executeHelperQueue - start");
168+ int ret = 0;
169+ AbstractHelper helper = null;
170+ try {
171+ while (true) {
172+ helper = HelperPool.getHelper(helperName);
173+ if (helper != null) break;
174+ }
175+
176+ for (int i = 0; i < inputHelperShareParam.length; i=i+2) {
177+ helper.setHelperShareParam(inputHelperShareParam[i], inputHelperShareParam[i+1]);
178+ }
179+
180+ helper.addParameterQueue(helpreParams);
181+ helper.setParameters(null);
182+ // ExecutorService を使用するために変更
183+ //helper.start();
184+
185+ HelperPool.returnHelper(helperName,helper);
186+ ret = helper.hashCode();
187+ } catch (BaseException be) {
188+ logger.error("createHelper - BaseException");
189+ throw be;
190+ } catch (Exception e) {
191+ logger.error("createHelper - Exception");
192+ throw new BaseException(e);
193+ }
194+ logger.debug("executeHelper - end");
195+ return ret;
196+ }
197+
198+
199+ /**
200+ * Helperクラスインスタンスを返す.<br>
201+ * Helperが存在しない場合はExceptionを返す.<br>
202+ *
203+ *
204+ * @param helperName helperName名
205+ * @param helpreParams helperパラメータ配列
206+ * @return AbstractHelper Helperインスタンス
207+ * @throws BaseException
208+ **/
209+ protected int executeHelperQueue(String helperName, Object[] helpreParams) throws BaseException {
210+ logger.debug("executeHelperQueue - start");
211+ int ret = 0;
212+ AbstractHelper helper = null;
213+ try {
214+ while (true) {
215+ helper = HelperPool.getHelper(helperName);
216+ if (helper != null) break;
217+ }
218+
219+ helper.addParameterQueue(helpreParams);
220+ helper.setParameters(null);
221+ // ExecutorService を使用するために変更
222+ //helper.start();
223+
224+ HelperPool.returnHelper(helperName,helper);
225+ ret = helper.hashCode();
226+ } catch (BaseException be) {
227+ logger.error("createHelper - BaseException");
228+ throw be;
229+ } catch (Exception e) {
230+ logger.error("createHelper - Exception");
231+ throw new BaseException(e);
232+ }
233+ logger.debug("executeHelper - end");
234+ return ret;
235+ }
236+
237+
238+ /**
239+ * オリジナルのキュー領域を作成する.<br>
240+ *
241+ */
242+ protected void createUniqueHelperParamQueue(String helperName, int size) throws Exception {
243+ try {
244+ HelperPool.createUniqueHelperParamQueue(helperName, size);
245+ } catch (Exception e) {
246+ throw e;
247+ }
248+ }
249+
250+
251+ /**
252+ * キューに対する追加メソッド.<br>
253+ * キュー指定あり.<br>
254+ *
255+ */
256+ protected void addSpecificationParameterQueue(String helperName, Object[] params) throws Exception {
257+ try {
258+ HelperPool.addSpecificationParameterQueue(helperName, params);
259+ } catch (Exception e) {
260+ throw e;
261+ }
262+ }
263+
264+ /**
265+ * キューに対する追加メソッド.<br>
266+ * 全共通キュー.<br>
267+ *
268+ */
269+ protected void addHelperQueueParam(Object[] params) throws Exception {
270+ try {
271+ HelperPool.addParameterQueue(params);
272+ } catch (Exception e) {
273+ throw e;
274+ }
275+ }
276+
277+
278+ /**
279+ * Helperクラスインスタンスを返す.<br>
280+ * Helperが存在しない場合はExceptionを返す.<br>
281+ *
282+ *
283+ * @param helperName helperName名
284+ * @param helpreParams helperパラメータ配列
285+ * @return AbstractHelper Helperインスタンス
286+ * @throws BaseException
287+ **/
288+ protected int executeHelper(String helperName, Object[] helpreParams) throws BaseException {
289+ return executeHelper(helperName, helpreParams, false);
290+ }
291+
292+
293+ /**
294+ * Helperクラスインスタンスを返す.<br>
295+ * Helperが存在しない場合はExceptionを返す.<br>
296+ *
297+ *
298+ * @param helperName helperName名
299+ * @param helpreParams helperパラメータ配列
300+ * @return AbstractHelper Helperインスタンス
301+ * @throws BaseException
302+ **/
303+ protected int executeHelper(String helperName, Object[] helpreParams, boolean reboot) throws BaseException {
304+ logger.debug("executeHelper - start");
305+ int ret = 0;
306+ AbstractHelper helper = null;
307+ try {
308+ while (true) {
309+ helper = HelperPool.getHelper(helperName);
310+ if (helper != null) break;
311+ }
312+
313+ helper.setParameters(helpreParams);
314+ helper.setReboot(reboot);
315+ // ExecutorService を使用するために変更
316+ //helper.start();
317+
318+ HelperPool.returnHelper(helperName,helper);
319+ ret = helper.hashCode();
320+ } catch (BaseException be) {
321+ logger.error("createHelper - BaseException");
322+ throw be;
323+ } catch (Exception e) {
324+ logger.error("createHelper - Exception");
325+ throw new BaseException(e);
326+ }
327+ logger.debug("executeHelper - end");
328+ return ret;
329+ }
330+
331+
332+ /**
333+ * Helperクラスインスタンスを返す.<br>
334+ * Helperが存在しない場合はExceptionを返す.<br>
335+ *
336+ *
337+ * @param helperName helperName名
338+ * @param helpreParams helperパラメータ配列
339+ * @param inputHelperShareParam ヘルパー共有領域に事前に登録したいパラメータ Key-Valueのセットで配列登録すること(inputHelperShareParam[0]=1番目の要素のKey,inputHelperShareParam[1]=1番目の要素のValue,inputHelperShareParam[2]=2番目の要素のKey,inputHelperShareParam[3]=2番目の要素のValue)
340+ * @return AbstractHelper Helperインスタンス
341+ * @throws BaseException
342+ **/
343+ protected int executeHelper(String helperName, Object[] helpreParams, boolean reboot, Object[] inputHelperShareParam) throws BaseException {
344+ logger.debug("executeHelper - start");
345+ int ret = 0;
346+ AbstractHelper helper = null;
347+ try {
348+ while (true) {
349+ helper = HelperPool.getHelper(helperName);
350+ if (helper != null) break;
351+ }
352+
353+ for (int i = 0; i < inputHelperShareParam.length; i=i+2) {
354+ helper.setHelperShareParam(inputHelperShareParam[i], inputHelperShareParam[i+1]);
355+ }
356+
357+ helper.setParameters(helpreParams);
358+ helper.setReboot(reboot);
359+ // ExecutorService を使用するために変更
360+ //helper.start();
361+
362+ HelperPool.returnHelper(helperName,helper);
363+ ret = helper.hashCode();
364+ } catch (BaseException be) {
365+ logger.error("createHelper - BaseException");
366+ throw be;
367+ } catch (Exception e) {
368+ logger.error("createHelper - Exception");
369+ throw new BaseException(e);
370+ }
371+ logger.debug("executeHelper - end");
372+ return ret;
373+ }
374+
375+
376+ /**
377+ * Job設定ファイルの自由に設定出来る値を取得する.<br>
378+ * 設定情報が存在しない場合はnullを返す.<br>
379+ *
380+ * @param key 設定情報のキー名
381+ * @return String ユーザ設定パラメータ
382+ **/
383+ protected String getPropertiesValue(String key) {
384+ return ConfigFolder.getJobUserParam(key);
385+ }
386+
387+ /**
388+ * Job設定ファイルの変更をチェック.<br>
389+ *
390+ * @return boolean 変更有無
391+ **/
392+ protected boolean isJobFileChange() throws BaseException {
393+ return ConfigFolder.isJobFileChange();
394+ }
395+
396+ /**
397+ * Job設定ファイルの指定のキー値を再読み込みする.<br>
398+ *
399+ * @param String[] キー値
400+ **/
401+ protected void reloadJobFileParameter(String[] keys) throws BaseException {
402+ ConfigFolder.reloadJobFileParameter(keys);
403+ }
404+
405+
406+
407+ /**
408+ * 自身のステータスを返す
409+ *
410+ * @return String ステータス文字列
411+ */
412+ public String getStatus() {
413+ return this.status;
414+ }
415+
416+ /**
417+ * Helperのステータスを返す
418+ *
419+ * @param hashCode Helperのコード
420+ * @return String ステータス文字列
421+ */
422+ public String getHelperStatus(int code) {
423+ return HelperPool.getHelperStatus(code);
424+ }
425+
426+ /**
427+ * 指定のHelperの実行中の数を返す
428+ *
429+ * @param hashName Helper名
430+ * @return int 実行中の数
431+ */
432+ public int getActiveHelperCount(String helperName) {
433+ return HelperPool.getActiveHelperInstanceCount(helperName);
434+ }
435+
436+ /**
437+ * Helperの戻り値を返す.<br>
438+ * 本メソットで値が取得できるのは1度のみ.<br>
439+ * 対象Helperが終了していない状態で本クラスを呼び出すとBaseExceptionがthrowされる.<br>
440+ * 必ずgetHelperStatusメソッドで終了を確認してから呼び出すこと.<br>
441+ * 実装例)Jobクラス内で呼び出し
442+ * int helperCode = executeHelper("TestHelper",new {"param"});
443+ * Object helperRet = null;
444+ *
445+ * // Helperからの戻り値を取得する
446+ * System.out.println("Helper End Wait Start");
447+ * while(true) {
448+ * System.out.println("Wait...");
449+ * if (super.getHelperStatus(helperCode).equals(BatchDefine.JOB_STATUS_END)) {
450+ * helperRet = super.removeHelperReturnParam(helperCode);
451+ * break;
452+ * }
453+ *
454+ * if (super.getHelperStatus(helperCode).equals(BatchDefine.JOB_STATUS_ERR)) {
455+ * break;
456+ * }
457+ * // 100ミリ停止
458+ * Thread.sleep(100);
459+ *
460+ * }
461+ * System.out.println(helperRet);
462+ *
463+ *
464+ * @param hashCode Helperのコード
465+ * @return Object 戻り値
466+ */
467+ public Object removeHelperReturnParam(int code) throws BaseException {
468+ Object ret = null;
469+ if (HelperPool.getHelperStatus(code).equals(BatchDefine.JOB_STATUS_END)) {
470+ ret = HelperPool.getReturnParam(code);
471+ HelperPool.cleanEndHelper(code);
472+ } else {
473+ throw new BaseException("Helper No End Status!!");
474+ }
475+ return ret;
476+ }
477+
478+
479+ /**
480+ * Helperの戻り値を返す.<br>
481+ * 本メソットで値が取得できるのは1度のみ.<br>
482+ * 本メソッドはHelperが終了もしくはエラーになるまで待ち、その後値を返す.<br>
483+ * 返却値はObjectの配列で1番目の要素がステータスとなり、2番目の要素が<br>
484+ * 返却値となる.<br>
485+ * ERRORステータスの場合値はnullとなる.<br>
486+ * HelperPoolが終了の値を回収するのに10秒のタイムラグがある為、10秒以上は停止するべきである.<br>
487+ *
488+ *
489+ * @param hashCode Helperのコード
490+ * @param limitTile リターン値が指定秒以内に返却されない場合はnullを返す.<br>
491+ * 指定は秒.<br>
492+ * @return Object[] 1番目の要素がステータス、2番目の要素が返却値
493+ */
494+ public Object[] waitGetHelperReturnParam(int helperCode, int limitTime) throws BaseException {
495+ Object[] ret = null;
496+ Object helperRet = null;
497+ try {
498+
499+ for(int i = 0; i < limitTime; i++) {
500+ if (getHelperStatus(helperCode).equals(BatchDefine.JOB_STATUS_END)) {
501+ helperRet = removeHelperReturnParam(helperCode);
502+ ret = new Object[2];
503+ ret[0] = BatchDefine.JOB_STATUS_END;
504+ ret[1] = helperRet;
505+ break;
506+ }
507+
508+ if (getHelperStatus(helperCode).equals(BatchDefine.JOB_STATUS_ERR)) {
509+ ret = new Object[2];
510+ ret[0] = BatchDefine.JOB_STATUS_ERR;
511+ ret[1] = null;
512+ break;
513+ }
514+
515+ // 980ミリ停止
516+ Thread.sleep(980);
517+ }
518+ } catch (BaseException be) {
519+ throw be;
520+ } catch (Exception e) {
521+ throw new BaseException(e);
522+ }
523+ return ret;
524+ }
525+
526+ /**
527+ * 自身の名前を返す
528+ *
529+ * @return String Job名文字列
530+ */
531+ public String getJobName() {
532+ return this.jobConfigMap.getJobName();
533+ }
534+
535+ /**
536+ * Job間で共有する値をセットする.<br>
537+ *
538+ * @param key キー値
539+ * @param val 値
540+ */
541+ public void setJobShareParam(Object key, Object val) {
542+ jobParamShareMap.put(key, val);
543+ }
544+
545+ /**
546+ * Job間で共有する値を取得する.<br>
547+ * 存在しない場合はNullを返す.<br>
548+ *
549+ * @param key キー値
550+ * @return Object 値
551+ */
552+ public Object getJobShareParam(Object key) {
553+ Object ret = null;
554+
555+ if (jobParamShareMap.containsKey(key)) {
556+
557+ ret = jobParamShareMap.get(key);
558+ }
559+ return ret;
560+ }
561+
562+ /**
563+ * Job間で共有する値のキー一覧を返す.<br>
564+ *
565+ * @return Object[] キー値配列
566+ */
567+ public Object[] getJobShareParamKeys() {
568+ Set keys = jobParamShareMap.keySet();
569+ Object[] keyList = new Object[keys.size()];
570+ int index = 0;
571+
572+ if (keys != null) {
573+ for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
574+ keyList[index] = iterator.next();
575+ index++;
576+ }
577+ }
578+
579+ return keyList;
580+ }
581+
582+ /**
583+ * PreProcessの返り値値をセット.<br>
584+ *
585+ * @param preProcessRet PreProcessの返り値
586+ */
587+ public void setPreProcess(String preProcessRet) {
588+ this.preProcessRet = preProcessRet;
589+ }
590+
591+ /**
592+ * PostProcessの値をセット.<br>
593+ *
594+ * @param postProcessRet PostProcessの返り値
595+ */
596+ public void setPostProcess(String postProcessRet) {
597+ this.postProcessRet = postProcessRet;
598+ }
599+
600+ /**
601+ * PreProcessの戻り値を返す.<br>
602+ *
603+ * @return String PreProcessの戻り値
604+ */
605+ protected String getPreProcess() {
606+ return preProcessRet;
607+ }
608+
609+ /**
610+ * PostProcessの戻り値を返す.<br>
611+ * PostProcessは全てのJobが終了してから呼び出されるので、<br>
612+ * この値は、reloopをtrueにした場合に前回処理のPostProcessの戻り値が取得可能となる<br>
613+ *
614+ * @return String PostProcessの戻り値
615+ */
616+ protected String getPostProcess() {
617+ return postProcessRet;
618+ }
619+
620+}
--- trunk/branch001/src/galleryes/base/util/JobEndWaitWorker.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/JobEndWaitWorker.java (revision 9)
@@ -0,0 +1,68 @@
1+package galleryes.base.util;
2+
3+import java.util.ArrayList;
4+import galleryes.base.util.ILogger;
5+import galleryes.base.util.LoggerFactory;
6+import galleryes.base.lang.BatchDefine;
7+import galleryes.base.job.AbstractJob;
8+
9+/**
10+ * Jobの終了を待機するスレッド.<br>
11+ *
12+ * @author T.Okuyama
13+ * @license GPL(Lv3)
14+ */
15+public class JobEndWaitWorker extends Thread {
16+
17+ // Logger
18+ private ILogger logger = LoggerFactory.createLogger(JobEndWaitWorker.class);
19+
20+ private ArrayList jobs = null;
21+
22+ // 自身のステータス
23+ private String status = BatchDefine.JOB_END_WAIT_WORKER_WAIT;
24+
25+ /**
26+ * メイン実行部分
27+ *
28+ */
29+ public void run() {
30+ logger.debug("JobEndWaitWorker - run - start");
31+ try {
32+ this.status = BatchDefine.JOB_END_WAIT_WORKER_RUN;
33+ AbstractJob job = null;
34+
35+ for (int i = 0; i < this.jobs.size(); i++) {
36+ job = (AbstractJob)this.jobs.get(i);
37+ logger.debug("[" + job.getJobName() + "] : End Wait Start");
38+ job.join();
39+ logger.debug("[" + job.getJobName() + "] : End Wait End");
40+ }
41+
42+ this.status = BatchDefine.JOB_END_WAIT_WORKER_END;
43+ } catch (Exception e) {
44+ logger.error("JobEndWaitWorker - run - error", e);
45+ this.status = BatchDefine.JOB_END_WAIT_WORKER_ERR;
46+ }
47+ logger.debug("JobEndWaitWorker - run - end");
48+ }
49+
50+
51+ /**
52+ * 自身のステータスを返す.<br>
53+ *
54+ * @return String ステータス文字列
55+ */
56+ public String getStatus() {
57+ return this.status;
58+ }
59+
60+ /**
61+ * 終了確認を行いたいJobを設定する.<br>
62+ *
63+ * @param jobs Jobリスト
64+ */
65+ public void setTargetJobs(ArrayList jobs) {
66+ this.jobs = jobs;
67+ }
68+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/util/DefaultLogger.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/DefaultLogger.java (revision 9)
@@ -0,0 +1,115 @@
1+package galleryes.base.util;
2+
3+import java.io.*;
4+
5+import org.apache.log4j.Logger;
6+import org.apache.log4j.PropertyConfigurator;
7+import org.apache.log4j.RollingFileAppender;
8+import org.apache.log4j.PatternLayout;
9+import org.apache.log4j.Level;
10+
11+/**
12+ * 標準ログクラス.<br>
13+ * Log4jをラップしたのみ<br>
14+ *
15+ * @author T.Okuyama
16+ * @license GPL(Lv3)
17+ */
18+public class DefaultLogger implements ILogger {
19+
20+ Logger logger = null;
21+
22+ public DefaultLogger(Class clazz) {
23+
24+ //設定ファイルを読み込む
25+ if (new File("log4j.properties").exists()) {
26+
27+ this.logger = Logger.getLogger(clazz);
28+ PropertyConfigurator.configure("log4j.properties");
29+ } else if (DefaultLogger.class.getResource("/log4j.properties") != null) {
30+
31+ this.logger = Logger.getLogger(clazz);
32+ PropertyConfigurator.configure(DefaultLogger.class.getResource("/log4j.properties"));
33+ } else if (DefaultLogger.class.getResource("/conf/log4j.properties") != null) {
34+
35+ this.logger = Logger.getLogger(clazz);
36+ PropertyConfigurator.configure(DefaultLogger.class.getResource("/conf/log4j.properties"));
37+ } else {
38+
39+ RollingFileAppender rollingFileAppender = null;
40+
41+ this.logger = Logger.getLogger(clazz);
42+ this.logger.setLevel(Level.ERROR);
43+
44+ PatternLayout layout = new PatternLayout("%d %5p %c{1} - %m%n");
45+
46+ try{
47+
48+ rollingFileAppender = new RollingFileAppender(layout, "galleryes_default.log");
49+ rollingFileAppender.setMaxFileSize("128MB");
50+ }catch(Exception e){
51+ e.printStackTrace();
52+ System.exit(1);
53+ }
54+
55+ this.logger.addAppender(rollingFileAppender);
56+ }
57+ }
58+
59+ public DefaultLogger(Class clazz, String configFile) {
60+ this.logger = Logger.getLogger(clazz);
61+
62+ //設定ファイルを読み込む
63+ PropertyConfigurator.configure(configFile);
64+ }
65+
66+
67+ public void trace(Object message) {
68+ this.logger.trace(message);
69+ }
70+
71+ public void trace(Object message, Throwable t) {
72+ this.logger.trace(message, t);
73+ }
74+
75+ public void debug(Object message) {
76+ this.logger.debug(message);
77+ }
78+
79+ public void debug(Object message, Throwable t) {
80+ this.logger.debug(message, t);
81+ }
82+
83+ public void info(Object message) {
84+ this.logger.info(message);
85+ }
86+
87+ public void info(Object message, Throwable t) {
88+ this.logger.info(message, t);
89+ }
90+
91+ public void error(Object message) {
92+ this.logger.error(message);
93+ }
94+
95+ public void error(Object message, Throwable t) {
96+ this.logger.error(message, t);
97+ }
98+
99+ public void fatal(Object message) {
100+ this.logger.fatal(message);
101+ }
102+
103+ public void fatal(Object message, Throwable t) {
104+ this.logger.fatal(message, t);
105+ }
106+
107+ public void warn(Object message) {
108+ this.logger.warn(message);
109+ }
110+
111+ public void warn(Object message, Throwable t) {
112+ this.logger.warn(message, t);
113+ }
114+
115+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/util/LoggerFactory.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/LoggerFactory.java (revision 9)
@@ -0,0 +1,20 @@
1+package galleryes.base.util;
2+
3+/**
4+ * ロガーファクトリ.<br>
5+ *
6+ * @author T.Okuyama
7+ * @license GPL(Lv3)
8+ */
9+public class LoggerFactory {
10+
11+ // まだ何も特殊なことはしていない
12+ public static ILogger createLogger(Class clazz) {
13+ return new DefaultLogger(clazz);
14+ }
15+
16+ // まだ何も特殊なことはしていない
17+ public static ILogger createLogger(Class clazz, String configFile) {
18+ return new DefaultLogger(clazz, configFile);
19+ }
20+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/util/ILogger.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/ILogger.java (revision 9)
@@ -0,0 +1,36 @@
1+package galleryes.base.util;
2+
3+/**
4+ * ロガーインターフェース.<br>
5+ * Log4jに合わせている<br>
6+ *
7+ * @author T.Okuyama
8+ * @license GPL(Lv3)
9+ */
10+public interface ILogger {
11+
12+ public void trace(Object message) ;
13+
14+ public void trace(Object message, Throwable t) ;
15+
16+ public void debug(Object message) ;
17+
18+ public void debug(Object message, Throwable t) ;
19+
20+ public void info(Object message) ;
21+
22+ public void info(Object message, Throwable t) ;
23+
24+ public void error(Object message) ;
25+
26+ public void error(Object message, Throwable t) ;
27+
28+ public void fatal(Object message) ;
29+
30+ public void fatal(Object message, Throwable t) ;
31+
32+ public void warn(Object message) ;
33+
34+ public void warn(Object message, Throwable t) ;
35+
36+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/util/HelperPool.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/HelperPool.java (revision 9)
@@ -0,0 +1,370 @@
1+package galleryes.base.util;
2+
3+import java.util.ArrayList;
4+import java.util.concurrent.ExecutorService;
5+import java.util.concurrent.Executors;
6+import java.util.concurrent.ThreadPoolExecutor;
7+import java.util.concurrent.ArrayBlockingQueue;
8+import java.util.concurrent.ConcurrentHashMap;
9+import java.util.concurrent.CopyOnWriteArrayList;
10+
11+import galleryes.base.util.ILogger;
12+import galleryes.base.util.LoggerFactory;
13+import galleryes.base.lang.BatchDefine;
14+import galleryes.base.lang.BaseException;
15+import galleryes.base.job.AbstractJob;
16+import galleryes.base.job.AbstractHelper;
17+import galleryes.base.parameter.config.HelperConfigMap;
18+
19+
20+/**
21+ * Helperの蓄積と状態の管理を行うスレッド.<br>
22+ *
23+ * @author T.Okuyama
24+ * @license GPL(Lv3)
25+ */
26+public class HelperPool extends Thread {
27+
28+ // Logger
29+ private static ILogger logger = LoggerFactory.createLogger(HelperPool.class);
30+
31+ // Helper管理用
32+ private static CopyOnWriteArrayList helperNameList = new CopyOnWriteArrayList();
33+ private static ConcurrentHashMap configMap = new ConcurrentHashMap(1024, 1000, 512);
34+ private static ConcurrentHashMap helperMap = new ConcurrentHashMap(1024, 1000, 512);
35+ private static ConcurrentHashMap helperReturnParamMap = new ConcurrentHashMap(1024, 1000, 512);
36+ private static ConcurrentHashMap helperStatusMap = new ConcurrentHashMap(8192, 1000, 512);
37+ private static ConcurrentHashMap executorServiceMap = new ConcurrentHashMap(1024, 1000, 512);
38+ private static ConcurrentHashMap serviceParameterQueueMap = new ConcurrentHashMap(1024, 1000, 512);
39+ private static CopyOnWriteArrayList allExecuteHelperList = new CopyOnWriteArrayList();
40+
41+
42+ // Helperチェック間隔
43+ private static int helperCheckTime = 2500;
44+
45+ // HelperThread Join待機時間
46+ private static int helperThreadJoinTime = 5000;
47+
48+ private static Object poolLock = new Object();
49+
50+ // スレッド内でのチェックをコントロール
51+ private boolean poolRunning = true;
52+
53+
54+ // 呼び出し時に直接渡すパラメータ
55+ private static ArrayBlockingQueue helperParamQueue = new ArrayBlockingQueue(1000);
56+
57+ public HelperPool() {
58+ poolRunning = true;
59+
60+ }
61+
62+ public void run () {
63+ logger.debug("HelperPool - run - start");
64+ try {
65+
66+ while(this.poolRunning) {
67+
68+ Thread.sleep(helperCheckTime);
69+ int size = allExecuteHelperList.size();
70+
71+ for (int i = 0; i < size; i++) {
72+
73+ AbstractHelper helper = (AbstractHelper)allExecuteHelperList.get(size - 1 - i);
74+
75+ if(helper.getThreadEnd()) {
76+
77+ cleanEndHelper(helper.hashCode());
78+
79+ allExecuteHelperList.remove(size - 1 - i);
80+
81+ if(helper.getReboot()) {
82+
83+ logger.debug("Helper[" + helper.getName() + " Reboot Start");
84+ AbstractHelper newHelper = getHelper(helper.getName());
85+ newHelper.setParameters(helper.getParameters());
86+ newHelper.setReboot(true);
87+ returnHelper(newHelper.getName(), newHelper);
88+ allExecuteHelperList.add(newHelper);
89+ logger.debug("Helper[" + helper.getName() + " Reboot Success");
90+ }
91+
92+ ((ThreadPoolExecutor)executorServiceMap.get(helper.getName())).remove(helper);
93+ }
94+ }
95+ }
96+ logger.debug("HelperPool - End Process Start");
97+ // システムの停止が要求されているのでHelperを制終了
98+ for (int i = 0; i < helperNameList.size(); i++) {
99+ ((ThreadPoolExecutor)executorServiceMap.get((String)helperNameList.get(i))).shutdown();
100+ }
101+
102+
103+ logger.debug("HelperPool - End Process End");
104+ } catch (Exception e) {
105+ e.printStackTrace();
106+ logger.error("HelperPool - run - Error", e);
107+ }
108+ }
109+
110+ /**
111+ * 明示的に初期化を行う
112+ */
113+ public static void initializeHelperPool() {
114+ helperNameList = new CopyOnWriteArrayList();
115+ configMap = new ConcurrentHashMap(1024, 1000, 512);
116+ helperMap = new ConcurrentHashMap(1024, 1000, 512);
117+ helperReturnParamMap = new ConcurrentHashMap(1024, 1000, 512);
118+ helperStatusMap = new ConcurrentHashMap(1024, 1000, 512);
119+ serviceParameterQueueMap = new ConcurrentHashMap(1024, 1000, 512);
120+ }
121+
122+ /**
123+ * Helperインスタンスを貸し出す.<br>
124+ * Helperが定義として存在しない場合BaseExceptionがthrowされる.<br>
125+ * 全て貸し出し中の場合はNullが返る.<br>
126+ *
127+ * @param String helperName
128+ * @return AbstractHelper ヘルパー
129+ * @throw BaseException
130+ */
131+ public static AbstractHelper getHelper(String helperName) throws BaseException {
132+ logger.debug("HelperPool - getHelper - start");
133+ AbstractHelper helper = null;
134+ Integer useCount = null;
135+ ArrayList helperList = null;
136+
137+ try {
138+ if (!helperMap.containsKey(helperName))
139+ throw new BaseException("Helper [" + helperName + "] Not Found");
140+
141+ HelperConfigMap helperConfigMap = (HelperConfigMap)configMap.get(helperName);
142+ helper = ClassUtility.createHelperInstance(helperConfigMap.getHelperClassName());
143+
144+ // Jobに設定情報を格納
145+ helper.setName(helperName);
146+ helper.setConfig(helperConfigMap);
147+ helper.initialize();
148+ helperStatusMap.put(new Integer(helper.hashCode()), helper.getStatus());
149+
150+ } catch (Exception e) {
151+ logger.error("HelperPool - getHelper - BaseException");
152+ throw new BaseException(e);
153+ }
154+ logger.debug("HelperPool - getHelper - end");
155+ return helper;
156+
157+ }
158+
159+
160+ /**
161+ * Helperインスタンスを返す.<br>
162+ * Helperが定義として存在しない場合BaseExceptionがthrowされる.<br>
163+ *
164+ * @param String helperName
165+ * @param AbstractHelper ヘルパーインスタンス
166+ * @throw BaseException
167+ */
168+ public static void returnHelper(String helperName, AbstractHelper helper) throws BaseException {
169+
170+ try {
171+ // ExecutorService を使用するために変更. 2010/03/22
172+ ((ThreadPoolExecutor)executorServiceMap.get(helperName)).execute(helper);
173+ allExecuteHelperList.add(helper);
174+ } catch (Exception be) {
175+ logger.error("HelperPool - returnHelper - BaseException");
176+ throw new BaseException(be);
177+ }
178+ }
179+
180+ public static int getActiveHelperInstanceCount(String helperName) {
181+ return ((ThreadPoolExecutor)executorServiceMap.get(helperName)).getActiveCount();
182+ }
183+
184+ /**
185+ * Helperのプールを初期化する.<br>
186+ *
187+ * @param HelperConfigMap helperConfigMap プールしたHelperの設定ファイル
188+ */
189+ public static void managedHelperConfig(HelperConfigMap helperConfigMap) throws BaseException {
190+
191+ helperNameList.add(helperConfigMap.getHelperName());
192+ configMap.put(helperConfigMap.getHelperName(),helperConfigMap);
193+ helperMap.put(helperConfigMap.getHelperName(),new ArrayList());
194+ executorServiceMap.put(helperConfigMap.getHelperName(), Executors.newCachedThreadPool());
195+ serviceParameterQueueMap.put(helperConfigMap.getHelperName(), new ArrayBlockingQueue(20000));
196+ }
197+
198+
199+ /**
200+ * オリジナルのキュー領域を作成する.<br>
201+ *
202+ * @param uniqueQueueName キュー名
203+ * @param size キューの最大サイズ
204+ */
205+ public static void createUniqueHelperParamQueue(String uniqueQueueName, int size) {
206+ serviceParameterQueueMap.put(uniqueQueueName, new ArrayBlockingQueue(size));
207+ }
208+
209+
210+ /**
211+ * パラメータキューのサイズを返す.<br>
212+ *
213+ * @param queueName 名前
214+ */
215+ public static int getParameterQueueSize(String queueName) throws Exception {
216+ int ret = -1;
217+ try {
218+ ret = ((ArrayBlockingQueue)serviceParameterQueueMap.get(queueName)).size();
219+ } catch (Exception e) {
220+ e.printStackTrace();
221+ throw e;
222+ }
223+ return ret;
224+ }
225+
226+
227+ /**
228+ * Helper用のパラメータキューに追加.<br>
229+ * 全てのHelper共通.<br>
230+ *
231+ * @param params パラメータ
232+ */
233+ public static void addParameterQueue(Object[] params) throws Exception {
234+ try {
235+ helperParamQueue.put(params);
236+ } catch (Exception e) {
237+ e.printStackTrace();
238+ throw e;
239+ }
240+ }
241+
242+
243+ /**
244+ * Helper用のパラメータキューに追加.<br>
245+ * Helper個別.<br>
246+ *
247+ * @param params パラメータ
248+ */
249+ public static void addSpecificationParameterQueue(String helperName, Object[] params) throws Exception {
250+ try {
251+ addSpecificationParameterQueue(helperName, params, false);
252+ } catch (Exception e) {
253+ e.printStackTrace();
254+ throw e;
255+ }
256+ }
257+
258+
259+ /**
260+ * Helper用のパラメータキューに追加.<br>
261+ * Helper個別.<br>
262+ *
263+ * @param params パラメータ
264+ */
265+ public static void addSpecificationParameterQueue(String helperName, Object[] params, boolean debug) throws Exception {
266+ try {
267+ if (false) {
268+ System.out.println(helperName + " =[" + ((ArrayBlockingQueue)serviceParameterQueueMap.get(helperName)).size() + "]");
269+ }
270+ ((ArrayBlockingQueue)serviceParameterQueueMap.get(helperName)).put(params);
271+ } catch (Exception e) {
272+ e.printStackTrace();
273+ throw e;
274+ }
275+ }
276+
277+
278+
279+
280+
281+ /**
282+ * Helper用のパラメータキューから取得
283+ * 全てのHelper共通
284+ *
285+ * @return Object[] パラメータ
286+ */
287+ public static Object[] pollParameterQueue() {
288+ Object[] ret = null;
289+ try {
290+
291+ ret = (Object[])helperParamQueue.take();
292+ } catch (Exception e) {
293+ e.printStackTrace();
294+ }
295+ return ret;
296+ }
297+
298+
299+ /**
300+ * Helper用のパラメータキューに追加|.<br>
301+ * Helper個別.<br>
302+ *
303+ * @param params パラメータ
304+ */
305+ public static Object[] pollSpecificationParameterQueue(String helperName) {
306+ Object[] ret = null;
307+
308+ try {
309+ ret = (Object[])((ArrayBlockingQueue)serviceParameterQueueMap.get(helperName)).take();
310+ } catch (Exception e) {
311+ logger.error("pollSpecificationParameterQueue - ERROR [" + helperName +"]");
312+ logger.error(serviceParameterQueueMap);
313+ e.printStackTrace();
314+ }
315+
316+ return ret;
317+ }
318+
319+
320+ /**
321+ * Helperが終了時にセットした返却値を取得する.<br>
322+ *
323+ * @param helperHashCode 対象HelperオブジェクトのhashCode
324+ * @return Object 返却値 値がセットされていない場合はnullが返る
325+ */
326+ public static Object getReturnParam(int helperHashCode) {
327+ Object ret = null;
328+ if (helperReturnParamMap.containsKey(new Integer(helperHashCode))) {
329+ ret = helperReturnParamMap.get(new Integer(helperHashCode));
330+ }
331+ return ret;
332+ }
333+
334+ /**
335+ * Helperが終了後のリソースを破棄する.<br>
336+ *
337+ * @param helperHashCode 対象HelperオブジェクトのhashCode
338+ */
339+ public static void cleanEndHelper(int helperHashCode) {
340+
341+ if (helperStatusMap.containsKey(new Integer(helperHashCode))) {
342+ helperStatusMap.put(new Integer(helperHashCode), BatchDefine.JOB_STATUS_END);
343+ }
344+
345+ if (helperReturnParamMap.containsKey(new Integer(helperHashCode))) {
346+ helperReturnParamMap.remove(new Integer(helperHashCode));
347+ }
348+ }
349+
350+
351+ /**
352+ * 指定したHelperのステータスを返す.<br>
353+ *
354+ * @param helperHashCode 対象HelperオブジェクトのhashCode
355+ * @return String ステータス文字列 Helperが存在しない場合はnullが返る
356+ */
357+ public static String getHelperStatus(int helperHashCode) {
358+ String ret = null;
359+ if (helperStatusMap.containsKey(new Integer(helperHashCode))) {
360+ ret = (String)helperStatusMap.get(new Integer(helperHashCode));
361+ }
362+ return ret;
363+ }
364+
365+ public void poolEnd() {
366+ this.poolRunning = false;
367+ }
368+
369+
370+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/util/ClassUtility.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/util/ClassUtility.java (revision 9)
@@ -0,0 +1,77 @@
1+package galleryes.base.util;
2+
3+import java.lang.reflect.Method;
4+
5+import galleryes.base.job.AbstractJob;
6+import galleryes.base.job.AbstractHelper;
7+
8+/**
9+ * リフレクションを使用してクラスのインスタンス生成や、<br>
10+ * そのほかメソッド実行などをまとめる.<br>
11+ *
12+ * @author T.Okuyama
13+ * @license GPL(Lv3)
14+ */
15+public class ClassUtility {
16+
17+ /**
18+ * クラスインスタンス作成.<br>
19+ *
20+ * @param className ターゲットクラス名
21+ * @return Object ターゲットクラス
22+ * @throws Exception
23+ */
24+ public static Object createInstance(String className) throws Exception {
25+ Object retObj = null;
26+ try {
27+ retObj = Class.forName(className).newInstance();
28+
29+ } catch (ClassNotFoundException ce) {
30+ throw new Exception(className + ":そのようなクラスは存在しません", ce);
31+ } catch (Exception e) {
32+ throw e;
33+ }
34+ return retObj;
35+ }
36+
37+ /**
38+ * Jobクラスインスタンス作成.<br>
39+ *
40+ * @param className ターゲットJob名
41+ * @return AbstractJob ターゲットJob
42+ * @throws Exception
43+ */
44+ public static AbstractJob createJobInstance(String className) throws Exception {
45+ Object retObj = null;
46+ try {
47+ retObj = Class.forName(className).newInstance();
48+
49+ } catch (ClassNotFoundException ce) {
50+ throw new Exception(className + ":そのようなクラスは存在しません", ce);
51+ } catch (Exception e) {
52+ throw e;
53+ }
54+ return (AbstractJob)retObj;
55+ }
56+
57+ /**
58+ * Helperクラスインスタンス作成.<br>
59+ *
60+ * @param className ターゲットHelper名
61+ * @return AbstractJob ターゲットHelper
62+ * @throws Exception
63+ */
64+ public static AbstractHelper createHelperInstance(String className) throws Exception {
65+ Object retObj = null;
66+ try {
67+ retObj = Class.forName(className).newInstance();
68+
69+ } catch (ClassNotFoundException ce) {
70+ throw new Exception(className + ":そのようなクラスは存在しません", ce);
71+ } catch (Exception e) {
72+ throw e;
73+ }
74+ return (AbstractHelper)retObj;
75+ }
76+
77+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/process/IErrorProcess.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/process/IErrorProcess.java (revision 9)
@@ -0,0 +1,27 @@
1+package galleryes.base.process;
2+
3+import java.util.Hashtable;
4+
5+import galleryes.base.lang.BaseException;
6+
7+/**
8+ * ErrorProcessクラスを実装する場合のインターフェース.<br>
9+ *
10+ *
11+ * @author T.Okuyama
12+ * @license GPL(Lv3)
13+ */
14+public interface IErrorProcess {
15+
16+
17+ /**
18+ * ErrorProcess実行部分.<br>
19+ *
20+ * @param jobTable 実行終了後のJobインスタンスがJob名をキーに格納されている
21+ * @param allJobStatusTable 各Jobのステータスを格納したテーブル
22+ * @param option 設定ファイルのoption部分
23+ */
24+ public void errorProcess(Hashtable jobTable,
25+ Hashtable allJobStatusTable,
26+ String option) throws BaseException;
27+}
\ No newline at end of file
--- trunk/branch001/src/galleryes/base/process/IProcess.java (nonexistent)
+++ trunk/branch001/src/galleryes/base/process/IProcess.java (revision 9)
@@ -0,0 +1,25 @@
1+package galleryes.base.process;
2+
3+import galleryes.base.lang.BaseException;
4+
5+
6+/**
7+ * Processクラスを実装する場合のインターフェース.<br>
8+ *
9+ * @author T.Okuyama
10+ * @license GPL(Lv3)
11+
12+ */
13+public interface IProcess {
14+
15+ /**
16+ * Process実行部分.<br>
17+ *
18+ * @param option 設定ファイルのoption部分
19+ * @return String 結果(必要な場合のみ、nullでもかまわない)
20+ * ここでのリターンの値は、AbstractJobクラスのgetPreProcessメソッド、
21+ * getPostProcessメソッドで取得可能
22+ * @throws BaseException
23+ */
24+ public String process(String option) throws BaseException;
25+}
\ No newline at end of file
Show on old repository browser