KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > pentaho > plugin > shark > SharkManager


1 /*
2  * Copyright 2006 Pentaho Corporation. All rights reserved.
3  * This software was developed by Pentaho Corporation and is provided under the terms
4  * of the Mozilla Public License, Version 1.1, or any later version. You may not use
5  * this file except in compliance with the license. If you need a copy of the license,
6  * please go to http://www.mozilla.org/MPL/MPL-1.1.txt. The Original Code is the Pentaho
7  * BI Platform. The Initial Developer is Pentaho Corporation.
8  *
9  * Software distributed under the Mozilla Public License is distributed on an "AS IS"
10  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. Please refer to
11  * the license for the specific language governing your rights and limitations.
12  *
13  * @created Jul 18, 2005
14  * @author James Dixon
15  *
16  */

17 package org.pentaho.plugin.shark;
18
19 import java.io.File JavaDoc;
20 import java.io.FileInputStream JavaDoc;
21 import java.io.IOException JavaDoc;
22 import java.util.ArrayList JavaDoc;
23 import java.util.Enumeration JavaDoc;
24 import java.util.HashMap JavaDoc;
25 import java.util.Iterator JavaDoc;
26 import java.util.LinkedHashMap JavaDoc;
27 import java.util.Map JavaDoc;
28 import java.util.Properties JavaDoc;
29 import java.util.Set JavaDoc;
30 import org.enhydra.shark.Shark;
31 import org.enhydra.shark.api.client.wfbase.BaseException;
32 import org.enhydra.shark.api.client.wfmodel.CannotAcceptSuspended;
33 import org.enhydra.shark.api.client.wfmodel.InvalidData;
34 import org.enhydra.shark.api.client.wfmodel.UpdateNotAllowed;
35 import org.enhydra.shark.api.client.wfmodel.WfActivity;
36 import org.enhydra.shark.api.client.wfmodel.WfAssignment;
37 import org.enhydra.shark.api.client.wfmodel.WfProcess;
38 import org.enhydra.shark.api.client.wfmodel.WfProcessMgr;
39 import org.enhydra.shark.api.client.wfservice.ConnectFailed;
40 import org.enhydra.shark.api.client.wfservice.ExecutionAdministration;
41 import org.enhydra.shark.api.client.wfservice.NotConnected;
42 import org.enhydra.shark.api.client.wfservice.PackageAdministration;
43 import org.enhydra.shark.api.client.wfservice.PackageHasActiveProcesses;
44 import org.enhydra.shark.api.client.wfservice.PackageInUse;
45 import org.enhydra.shark.api.client.wfservice.ParticipantMap;
46 import org.enhydra.shark.api.client.wfservice.ParticipantMappingAdministration;
47 import org.enhydra.shark.api.client.wfservice.RepositoryMgr;
48 import org.enhydra.shark.api.client.wfservice.SharkConnection;
49 import org.enhydra.shark.api.client.wfservice.UserGroupAdministration;
50 import org.pentaho.core.session.IPentahoSession;
51 import org.pentaho.core.system.PentahoSystem;
52 import org.pentaho.core.util.DatasourceHelper;
53 import org.pentaho.messages.Messages;
54 import org.pentaho.messages.util.LocaleHelper;
55 import org.pentaho.util.logging.Logger;
56
57 public class SharkManager {
58
59     private boolean sharkConfigured = false;
60
61     private String JavaDoc sessionUser = null;
62
63     private String JavaDoc sessionPwd = null;
64
65     private String JavaDoc sessionGroup = null;
66
67     private String JavaDoc engineName = "pentaho_shark"; //$NON-NLS-1$
68

69     private IPentahoSession session = null;
70
71     private static final boolean debug = PentahoSystem.debug;
72
73     public static final String JavaDoc VARIABLE_TO_PROCESS_UPDATE = "VariableToProcess_UPDATE"; //$NON-NLS-1$
74

75     public static final String JavaDoc VARIABLE_TO_PROCESS_VIEW = "VariableToProcess_VIEW"; //$NON-NLS-1$
76

77     public static final String JavaDoc VARIABLE_TO_PROCESS_ALL = "VariableToProcess_ALL"; //$NON-NLS-1$
78

79     public static final String JavaDoc SHARK_MANAGER = "SharkManager"; //$NON-NLS-1$
80

81     public static String JavaDoc externalRepositoryPath = File.separator + "repository" + File.separator + "external"; //$NON-NLS-1$ //$NON-NLS-2$
82

83     /**
84      *
85      */

86     public SharkManager(IPentahoSession session) {
87         this.session = session;
88         try {
89             init(PentahoSystem.getApplicationContext().getSolutionPath("system/shark")); //$NON-NLS-1$
90
} catch (Exception JavaDoc e) {
91             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0016_INITIALIZING_WORKFLOW_ENGINE"), e); //$NON-NLS-1$
92
}
93     }
94
95     public static SharkManager getInstance(IPentahoSession session) {
96         SharkManager manager = (SharkManager) session.getAttribute(SHARK_MANAGER);
97         if (manager == null) {
98             manager = new SharkManager(session);
99             session.setAttribute(SHARK_MANAGER, manager);
100         }
101         return manager;
102     }
103
104     /**
105      * @param path
106      * canonical path prefix to the Shark configuration file
107      */

108     private void init(String JavaDoc path) throws BaseException {
109
110         if (!sharkConfigured) {
111
112             // TODO: Not where we will get userid and pass in future - JOSSO
113
// goes here...
114
String JavaDoc userId = PentahoSystem.getSystemSetting("shark/shark.xml", "workflow-shark/workflow-shark-user-id", null); //$NON-NLS-1$ //$NON-NLS-2$
115
String JavaDoc password = PentahoSystem.getSystemSetting("shark/shark.xml", "workflow-shark/workflow-shark-password", null); //$NON-NLS-1$ //$NON-NLS-2$
116
String JavaDoc group = PentahoSystem.getSystemSetting("shark/shark.xml", "workflow-shark/workflow-shark-group", null); //$NON-NLS-1$ //$NON-NLS-2$
117

118             if ((null == userId) || (null == password)) {
119                 Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0017_NO_SHARK.XML_FILE")); //$NON-NLS-1$
120
throw new BaseException(Messages.getErrorString("SharkManager.ERROR_0017_NO_SHARK.XML_FILE")); //$NON-NLS-1$
121
}
122             sessionUser = userId;
123             sessionPwd = password;
124             sessionGroup = group;
125
126             Properties JavaDoc p = new Properties JavaDoc();
127
128             try {
129                 p.load(new FileInputStream JavaDoc(path + "/conf/Shark.conf")); //$NON-NLS-1$
130
path = path.replaceAll("\\\\", "/"); //$NON-NLS-1$ //$NON-NLS-2$
131

132             } catch (Exception JavaDoc e) {
133                 Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0001_ERROR_IN_SHARK_CONF_SETTING"), e); //$NON-NLS-1$
134
throw new BaseException(e);
135             }
136
137             // Engine name must be unique per client session...
138
p.setProperty("enginename", new StringBuffer JavaDoc(engineName).append("_").append(session.getId()).toString()); //$NON-NLS-1$ //$NON-NLS-2$
139

140             // Must have absolute paths for the following properties in order
141
// for Shark
142
// to initialize properly - modify on startup to append absolute
143
// path
144
String JavaDoc prop = null;
145             String JavaDoc key = null;
146             Enumeration JavaDoc keys = p.keys();
147
148             // Property values that start with ../ will be replaced with the
149
// absolute path
150
while (keys.hasMoreElements()) {
151                 key = (String JavaDoc) keys.nextElement();
152                 prop = p.getProperty(key);
153                 if (prop.startsWith("..", 0)) { //$NON-NLS-1$
154
prop = prop.replaceFirst("..", path); //$NON-NLS-1$
155
p.setProperty(key, prop);
156                 }
157             }
158
159             key = "DatabaseManager.ConfigurationDir"; //$NON-NLS-1$
160
prop = p.getProperty(key);
161             if (prop != null && prop.equalsIgnoreCase("dods")) { //$NON-NLS-1$
162
p.setProperty(key, path + "/conf/" + prop); //$NON-NLS-1$
163
}
164
165             key = "EXTERNAL_PACKAGES_REPOSITORY"; //$NON-NLS-1$
166
prop = p.getProperty(key);
167             if (prop != null) {
168                 // make sure that this path is canonical, some things wont work
169
// otherwise
170
File JavaDoc tmpFile = new File JavaDoc(prop);
171                 if (tmpFile.exists()) {
172                     try {
173                         prop = tmpFile.getCanonicalPath();
174                     } catch (IOException JavaDoc e) {
175
176                     }
177                 }
178                 externalRepositoryPath = prop; // this will be in the form
179
// c:/shark/external/repository
180
p.setProperty(key, externalRepositoryPath);
181             }
182
183             // Set up the JNDI string appropriately for container
184
String JavaDoc jndiForShark = "java:/Shark"; //$NON-NLS-1$
185
try {
186                 jndiForShark = DatasourceHelper.getDSBoundName("Shark"); //$NON-NLS-1$
187
key = "DatabaseManager.DB.sharkdb.Connection.DataSourceName"; //$NON-NLS-1$
188
if ((p.getProperty(key) != null) && (jndiForShark != null)) {
189                     p.setProperty(key, jndiForShark);
190                 }
191             } catch (Exception JavaDoc e) {
192                 Logger.error(SharkManager.class.getName(), Messages.getString("SharkManager.ERROR_FAILED_TO_SET_JNDI")); //$NON-NLS-1$
193
}
194
195             Shark.configure(p);
196             sharkConfigured = true;
197         }
198         user();
199     }
200
201     public String JavaDoc getExternalRepositoryPath() {
202         return externalRepositoryPath;
203     }
204
205     private void user() {
206         createNewUser(sessionUser, sessionUser, sessionUser, "", sessionPwd, sessionGroup); //$NON-NLS-1$
207
}
208
209     public void createNewUser(String JavaDoc name, String JavaDoc first, String JavaDoc last, String JavaDoc email, String JavaDoc password, String JavaDoc group) {
210         UserGroupAdministration uga = Shark.getInstance().getAdminInterface().getUserGroupAdministration();
211         try {
212             if (!uga.doesGroupExist(group)) {
213                 uga.createGroup(group, group);
214             }
215             if (!uga.doesUserExist(name)) {
216                 uga.createUser(group, name, password, first, last, email);
217             }
218             if (!uga.doesUserBelongToGroup(group, name)) {
219                 uga.addUserToGroup(group, name);
220             }
221         } catch (Throwable JavaDoc t) {
222             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0002_COULD_NOT_CREATE_USER_OR_GROUP", name), t); //$NON-NLS-1$
223
}
224
225     }
226
227     public void MapParticipant(String JavaDoc userName, String JavaDoc packageId, String JavaDoc participantId) {
228         ParticipantMappingAdministration pma = Shark.getInstance().getAdminInterface().getParticipantMappingAdministration();
229         try {
230             ParticipantMap pm = pma.createParticipantMap();
231
232             pm.setPackageId(packageId);
233             pm.setParticipantId(participantId);
234             pm.setUsername(userName);
235
236             pma.addParticipantMapping(pm);
237         } catch (Throwable JavaDoc t) {
238             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0003_COULD_NOT_CREATE_USER_MAPPING", userName), t); //$NON-NLS-1$
239
}
240
241     }
242
243     public String JavaDoc LoadPackage(String JavaDoc xpdlName) throws BaseException {
244
245         if (debug)
246             Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_LOADING_PACKAGE", xpdlName)); //$NON-NLS-1$
247

248         PackageAdministration pa = Shark.getInstance().getAdminInterface().getPackageAdministration();
249         RepositoryMgr rm = Shark.getInstance().getRepositoryManager();
250         String JavaDoc pkgId = rm.getPackageId(xpdlName);
251         // load is only for new packages - use update
252
if (!pa.isPackageOpened(pkgId)) {
253             try {
254                 pa.openPackage(xpdlName);
255             } catch (Throwable JavaDoc e) {
256                 Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0004_COULD_NOT_LOAD_PACKAGE", xpdlName), e); //$NON-NLS-1$
257
throw new BaseException(e);
258             }
259         }
260         return rm.getPackageId(xpdlName);
261     }
262
263     public boolean isPackageLoaded(String JavaDoc xpdlName) {
264         boolean is = false;
265         try {
266
267             PackageAdministration pa = Shark.getInstance().getAdminInterface().getPackageAdministration();
268             RepositoryMgr rm = Shark.getInstance().getRepositoryManager();
269             String JavaDoc pkgId = rm.getPackageId(xpdlName);
270             is = (null != pkgId) && (pa.isPackageOpened(pkgId));
271
272         } catch (Exception JavaDoc e) {
273             // log it, then throw it away
274
Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0005_IS_PACKAGE_LOADED_ERROR", xpdlName), e); //$NON-NLS-1$
275
}
276         return is;
277     }
278
279     public void startProcess(String JavaDoc mgrName, String JavaDoc user, String JavaDoc password, Map JavaDoc processVars) throws BaseException {
280
281         SharkConnection sConn = null;
282         sConn = Shark.getInstance().getSharkConnection();
283
284         try {
285             String JavaDoc pkgId = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrPkgId(mgrName);
286             String JavaDoc pDefId = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrProcDefId(mgrName);
287
288             sConn.connect(user, password, engineName, null);
289             WfProcess process = sConn.createProcess(pkgId, pDefId);
290
291             // get the list of context variables for the process
292
Set JavaDoc parameterNames = process.process_context().keySet();
293             Iterator JavaDoc parameterNameIterator = parameterNames.iterator();
294             // for each variable, see if we can provide a value for it
295
while (parameterNameIterator.hasNext()) {
296                 String JavaDoc parameterName = (String JavaDoc) parameterNameIterator.next();
297                 String JavaDoc value = (String JavaDoc) processVars.get(parameterName);
298                 if (value != null) {
299                     processSetVariable(process, parameterName, value);
300                 }
301             }
302             process.start();
303             sConn.disconnect();
304
305         } catch (Exception JavaDoc e) {
306             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0006_COULD_NOT_START_PROCESS", mgrName), e); //$NON-NLS-1$
307
throw new BaseException(e);
308         }
309     }
310
311     public void startProcess(String JavaDoc mgrName) throws BaseException {
312         SharkConnection sConn = null;
313         sConn = Shark.getInstance().getSharkConnection();
314         try {
315             String JavaDoc pkgId = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrPkgId(mgrName);
316             String JavaDoc pDefId = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrProcDefId(mgrName);
317
318             sConn.connect(sessionUser, sessionPwd, engineName, null);
319             sConn.createProcess(pkgId, pDefId).start();
320             sConn.disconnect();
321         } catch (Exception JavaDoc e) {
322             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0006_COULD_NOT_START_PROCESS", mgrName), e); //$NON-NLS-1$
323
throw new BaseException(e);
324         }
325     }
326
327     public void startProcess(String JavaDoc pkgId, String JavaDoc pDefId) throws BaseException {
328         if (debug)
329             Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_PROCESS_START_2", pkgId, pDefId)); //$NON-NLS-1$
330

331         SharkConnection sConn = null;
332         sConn = Shark.getInstance().getSharkConnection();
333         try {
334             sConn.connect(sessionUser, sessionPwd, engineName, null);
335             sConn.createProcess(pkgId, pDefId).start();
336             sConn.disconnect();
337         } catch (Exception JavaDoc e) {
338             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0007_COULD_NOT_START_PROCESS", pkgId, pDefId), e); //$NON-NLS-1$
339
throw new BaseException(e);
340         }
341     }
342
343     public boolean unloadPackage(String JavaDoc xpdlName) throws PackageHasActiveProcesses, PackageInUse, BaseException {
344         boolean succeeded = false;
345         PackageAdministration pa = Shark.getInstance().getAdminInterface().getPackageAdministration();
346         RepositoryMgr rm = Shark.getInstance().getRepositoryManager();
347         ExecutionAdministration ea = Shark.getInstance().getAdminInterface().getExecutionAdministration();
348         String JavaDoc pkgId = rm.getPackageId(xpdlName);
349
350         if ((null != pkgId) && (pa.isPackageOpened(pkgId))) {
351             if (pa.isPackageReferenced(pkgId)) {
352                 // skip it... we'll try again after deleting the offending
353
// referencer....
354
} else if (packageHasRunningProcesses(pkgId)) {
355                 Logger.warn(SharkManager.class.getName(), Messages.getString("SharkManager.WARN_PACKAGE_NOT_CLOSED", pkgId)); //$NON-NLS-1$
356
} else {
357                 try {
358                     ea.connect(sessionUser, sessionPwd, engineName, null);
359                     ea.deleteClosedProcesses(pkgId);
360                 } catch (Exception JavaDoc e) {
361                     Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0008_COULD_NOT_UNLOAD_PACKAGE", xpdlName), e); //$NON-NLS-1$
362
}
363
364                 pa.closePackage(pkgId);
365                 succeeded = true;
366             }
367         }
368         return succeeded;
369     }
370
371     public boolean deleteCompletedProcesses() {
372         boolean succeeded = false;
373         ExecutionAdministration ea = Shark.getInstance().getAdminInterface().getExecutionAdministration();
374         try {
375             ea.connect(sessionUser, sessionPwd, engineName, null);
376             ea.deleteClosedProcesses();
377             succeeded = true;
378         } catch (Exception JavaDoc e) {
379             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0009_COULD_NOT_DELETE_COMPLETED_PROCESSES"), e); //$NON-NLS-1$
380
} finally {
381             try {
382                 ea.disconnect();
383             } catch (Exception JavaDoc e) {
384             }
385         }
386         return succeeded;
387     }
388
389     public boolean isProcessRunning(String JavaDoc pkgId, String JavaDoc pDefId) throws BaseException {
390         boolean isRunning = false;
391
392         if (debug)
393             Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_IS_PROCESS_RUNNING", pkgId, pDefId)); //$NON-NLS-1$
394
ExecutionAdministration ea = Shark.getInstance().getAdminInterface().getExecutionAdministration();
395
396         try {
397             ea.connect(sessionUser, sessionPwd, engineName, null);
398             WfProcessMgr pMgr = ea.getProcessMgr(pkgId, pDefId);
399             // TODO: need to account for closed processes that have not been
400
// deleted.
401
if (debug)
402                 Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_NUMBER_PROCESSES", pkgId, pDefId, String.valueOf(pMgr.how_many_process()))); //$NON-NLS-1$
403
isRunning = (pMgr.how_many_process() > 0);
404
405             /*
406              * ProcessIteratorExpressionBuilder peb =
407              * Shark.getInstance().getExpressionBuilderManager().getProcessIteratorExpressionBuilder();
408              * peb.addPackageIdEquals(pkgId); //$NON-NLS-1$ //$NON-NLS-2$
409              * WfProcessIterator pit = pMgr.get_iterator_process();
410              * pit.set_query_expression(peb.toExpression());
411              *
412              * if (debug) Logger.debug( SharkManager.class.getName(),
413              * Messages.getString("SharkManager.DEBUG_PROCESS_RUNNING_COUNT",
414              * Integer.toString(pit.how_many()),
415              * Integer.toString(pit.get_next_n_sequence(0).length) ));
416              * //$NON-NLS-1$ if ( pit.get_next_n_sequence(1).length != 0){
417              * isRunning = true; }
418              *
419              */

420         } catch (Exception JavaDoc e) {
421             e.printStackTrace();
422             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0010_IS_PROCESS_RUNNING_ERROR", pkgId, pDefId), e); //$NON-NLS-1$
423
throw new BaseException(e);
424         } finally {
425             try {
426                 ea.disconnect();
427             } catch (Exception JavaDoc e) {
428             }
429         }
430         return isRunning;
431     }
432
433     public void completeActivity(SharkConnection sConn, String JavaDoc activityId) {
434         try {
435             if (null != activityId) {
436                 try {
437                     WfAssignment a = getAssignment(sConn, activityId);
438
439                     if (!isMine(a))
440                         acceptAssignment(a);
441
442                     a.activity().complete();
443
444                 } catch (Exception JavaDoc e) {
445                     Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0011_ACTIVITY_COMPLETE_ERROR", activityId), e); //$NON-NLS-1$
446
throw new BaseException(e);
447                 }
448             }
449         } catch (BaseException e) {
450             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0011_ACTIVITY_COMPLETE_ERROR", activityId), e); //$NON-NLS-1$
451
}
452     }
453
454     public boolean isMine(SharkConnection sConn, String JavaDoc activityId) throws BaseException {
455         WfAssignment a = getAssignment(sConn, activityId);
456         return isMine(a);
457     }
458
459     public boolean isMine(WfAssignment a) throws BaseException {
460         return a.get_accepted_status();
461     }
462
463     public void acceptAssignment(SharkConnection sConn, String JavaDoc activityId) throws CannotAcceptSuspended, BaseException {
464         acceptAssignment(getAssignment(sConn, activityId));
465     }
466
467     private void acceptAssignment(WfAssignment a) throws CannotAcceptSuspended, BaseException {
468         a.set_accepted_status(true);
469     }
470
471     public WfAssignment getAssignment(SharkConnection sConn, String JavaDoc activityId) throws BaseException {
472         try {
473             WfAssignment[] ar = sConn.getResourceObject().get_sequence_work_item(0);
474             for (int i = 0; i < ar.length; ++i) {
475                 if (activityId.equals(ar[i].activity().key())) {
476                     return ar[i];
477                 }
478             }
479             throw new BaseException(Messages.getErrorString("SharkManager.ERROR_00017_ACTIVITY_NOT_IN_WORKLIST", activityId, sConn.getResourceObject().resource_key())); //$NON-NLS-1$
480
} catch (Exception JavaDoc e) {
481             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0012_GET_ASSIGNMENT_ERROR", activityId), e); //$NON-NLS-1$
482
throw new BaseException(e);
483         }
484     }
485
486     public SharkConnection connect() throws ConnectFailed, BaseException {
487         return connect(sessionUser, sessionPwd);
488     }
489
490     public SharkConnection connect(String JavaDoc user, String JavaDoc passwd) throws ConnectFailed, BaseException {
491         if (debug)
492             Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_CONNECT")); //$NON-NLS-1$
493
SharkConnection sConn = Shark.getInstance().getSharkConnection();
494         sConn.connect(user, passwd, engineName, null);
495         return sConn;
496     }
497
498     public void disconnect(SharkConnection sConn) throws NotConnected, BaseException {
499         if (debug)
500             Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_DISCONNECT")); //$NON-NLS-1$
501
sConn.disconnect();
502     }
503
504     public String JavaDoc[] getAllUsers() throws BaseException {
505         UserGroupAdministration uga = Shark.getInstance().getAdminInterface().getUserGroupAdministration();
506         return uga.getAllUsers();
507     }
508
509     public String JavaDoc getUserRealName(String JavaDoc uname) throws BaseException {
510         UserGroupAdministration uga = Shark.getInstance().getAdminInterface().getUserGroupAdministration();
511         return uga.getUserRealName(uname);
512     }
513
514     public String JavaDoc getUserEMailAddress(String JavaDoc uname) throws BaseException {
515         UserGroupAdministration uga = Shark.getInstance().getAdminInterface().getUserGroupAdministration();
516         return uga.getUserEMailAddress(uname);
517     }
518
519     public void setVariable(SharkConnection sConn, String JavaDoc activityId, String JavaDoc vName, String JavaDoc vValue) throws BaseException, InvalidData {
520
521         WfAssignment a = getAssignment(sConn, activityId);
522
523         if (!isMine(a))
524             throw new BaseException(Messages.getErrorString("SharkManager.ERROR_0013_NOT_ACTIVITY_OWNER", activityId)); //$NON-NLS-1$
525
Map JavaDoc _m = new HashMap JavaDoc();
526         Object JavaDoc c = a.activity().process_context().get(vName);
527         if (c instanceof Long JavaDoc) {
528             c = new Long JavaDoc(vValue);
529         } else if (c instanceof Boolean JavaDoc) {
530             c = Boolean.valueOf(vValue);
531         } else if (c instanceof Double JavaDoc) {
532             c = Double.valueOf(vValue);
533         } else {
534             c = vValue;
535         }
536         _m.put(vName, c);
537         a.activity().set_result(_m);
538     }
539
540     public void processSetVariable(WfProcess process, String JavaDoc vName, String JavaDoc vValue) throws BaseException, UpdateNotAllowed, InvalidData {
541
542         Map JavaDoc _m = new HashMap JavaDoc();
543         Object JavaDoc c = process.process_context().get(vName);
544         if (c instanceof Long JavaDoc) {
545             c = new Long JavaDoc(vValue);
546         } else if (c instanceof Boolean JavaDoc) {
547             c = Boolean.valueOf(vValue);
548         } else if (c instanceof Double JavaDoc) {
549             c = Double.valueOf(vValue);
550         } else {
551             c = vValue;
552         }
553         _m.put(vName, c);
554         process.set_process_context(_m);
555     }
556
557     public String JavaDoc[] xpdlsAvailableToLoad() {
558         try {
559             return Shark.getInstance().getRepositoryManager().getPackagePaths();
560         } catch (BaseException e) {
561             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0020_RETRIEVEING_PACKAGE_NAMES"), e); //$NON-NLS-1$
562
return new String JavaDoc[] {};
563         }
564     }
565
566     public String JavaDoc[] processesToStart() {
567         ExecutionAdministration ea = null;
568         try {
569             ea = Shark.getInstance().getAdminInterface().getExecutionAdministration();
570             ea.connect(sessionUser, sessionPwd, engineName, null);
571             WfProcessMgr[] a = ea.get_iterator_processmgr().get_next_n_sequence(0);
572             String JavaDoc[] ret = new String JavaDoc[a.length];
573             for (int i = 0; i < a.length; ++i) {
574                 String JavaDoc n = a[i].name();
575                 if (debug)
576                     Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_PROCESS_TO_START", n)); //$NON-NLS-1$
577
ret[i] = n;
578             }
579             return ret;
580         } catch (Exception JavaDoc e) {
581             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_00014_IN_PROCESS_TO_START"), e); //$NON-NLS-1$
582
} finally {
583             try {
584                 ea.disconnect();
585             } catch (BaseException e) {
586             } catch (NotConnected e) {
587             }
588         }
589         return new String JavaDoc[] {};
590     }
591
592     public boolean packageHasRunningProcesses(String JavaDoc pkgId) {
593         boolean ret = false;
594         ArrayList JavaDoc processes = getProcessesForPackage(pkgId);
595
596         if ((null == processes) || (processes.isEmpty()))
597             return ret;
598
599         for (int i = 0; i < processes.size(); i++) {
600             try {
601                 if (isProcessRunning(pkgId, (String JavaDoc) processes.get(i))) {
602                     if (debug)
603                         Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_RUNNING_PROCESS") + (String JavaDoc) processes.get(i)); //$NON-NLS-1$
604
ret = true;
605                     break;
606                 }
607             } catch (Exception JavaDoc e) {
608                 Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0021_PACKAGE_HAS_RUNNING_PROCESSES"), e); //$NON-NLS-1$
609
}
610         }
611         return ret;
612     }
613
614     public ArrayList JavaDoc getProcessesForPackage(String JavaDoc pkgId) {
615         ExecutionAdministration ea = null;
616         String JavaDoc pkg = null;
617         String JavaDoc def = null;
618         ArrayList JavaDoc ret = new ArrayList JavaDoc();
619
620         try {
621             ea = Shark.getInstance().getAdminInterface().getExecutionAdministration();
622             ea.connect(sessionUser, sessionPwd, engineName, null);
623             WfProcessMgr[] a = ea.get_iterator_processmgr().get_next_n_sequence(0);
624
625             for (int i = 0; i < a.length; ++i) {
626                 String JavaDoc n = a[i].name();
627
628                 pkg = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrPkgId(n);
629                 def = Shark.getInstance().getAdminInterface().getAdminMisc().getProcessMgrProcDefId(n);
630
631                 if (pkg.equalsIgnoreCase(pkgId)) {
632                     if (debug)
633                         Logger.debug(SharkManager.class.getName(), Messages.getString("SharkManager.DEBUG_PROCESSES_FOR_PACKAGE") + pkgId + ", " + def); //$NON-NLS-1$ //$NON-NLS-2$
634
ret.add(def);
635                 }
636
637             }
638         } catch (Exception JavaDoc e) {
639             Logger.error(SharkManager.class.getName(), Messages.getErrorString("SharkManager.ERROR_0022_GET_PROCESSES_FOR_PACKAGE"), e); //$NON-NLS-1$
640
ret = null;
641         } finally {
642             try {
643                 ea.disconnect();
644             } catch (BaseException e) {
645             } catch (NotConnected e) {
646             }
647         }
648         return ret;
649     }
650
651     /**
652      * Gets the context for the given activity that could be updated, viewed by
653      * the user, or all activity context. The context is determined based on
654      * activities extended attributes.
655      */

656     public Map JavaDoc getActivityContext(Map JavaDoc contextToSearch, WfActivity act, String JavaDoc type) {
657         String JavaDoc[][] extAttribs = null;
658         try {
659             extAttribs = Shark.getInstance().getAdminInterface().getAdminMisc().getActivitiesExtendedAttributeNameValuePairs(act.container().key(), act.key());
660         } catch (Exception JavaDoc ex) {
661         }
662
663         Map JavaDoc updateContext = new LinkedHashMap JavaDoc();
664         if (extAttribs != null) {
665             for (int i = 0; i < extAttribs.length; i++) {
666                 String JavaDoc eaName = extAttribs[i][0];
667                 if (type.equals(VARIABLE_TO_PROCESS_ALL)) {
668                     if (eaName.equalsIgnoreCase(VARIABLE_TO_PROCESS_UPDATE) || eaName.equalsIgnoreCase(VARIABLE_TO_PROCESS_VIEW)) {
669                         String JavaDoc variableId = extAttribs[i][1];
670                         if (contextToSearch.containsKey(variableId)) {
671                             updateContext.put(variableId, contextToSearch.get(variableId));
672                         }
673                     }
674                 } else {
675                     if (eaName.equalsIgnoreCase(type)) {
676                         String JavaDoc variableId = extAttribs[i][1];
677                         if (contextToSearch.containsKey(variableId)) {
678                             updateContext.put(variableId, contextToSearch.get(variableId));
679                         }
680                     }
681                 }
682             }
683         }
684
685         return updateContext;
686     }
687
688     /**
689      * Gets pentaho extended attribute XML nodes
690      *
691      */

692     public String JavaDoc getPentahoXML(WfActivity act) {
693
694         String JavaDoc extAttribs = null;
695         StringBuffer JavaDoc b = null;
696         try {
697             extAttribs = Shark.getInstance().getAdminInterface().getAdminMisc().getActivitiesExtendedAttributes(act.container().key(), act.key());
698             b = new StringBuffer JavaDoc().append("<?xml version=\"1.0\" encoding=\"" + LocaleHelper.getSystemEncoding() + "\"?>").append( //$NON-NLS-1$ //$NON-NLS-2$
699
"<pho:snippet xmlns:xf=\"http://www.w3.org/2002/xforms\" xmlns:pho=\"http://www.w3.org/1999/homl\">") //$NON-NLS-1$
700
.append(extAttribs).append("</pho:snippet>"); //$NON-NLS-1$
701
} catch (Exception JavaDoc ex) {
702             b = null;
703         }
704
705         return b != null ? b.toString() : null;
706     }
707 }
708
Popular Tags