001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018 package org.apache.oozie.service;
019
020 import java.io.File;
021 import java.io.IOException;
022 import java.net.URI;
023 import java.net.URL;
024 import java.net.URLDecoder;
025 import java.text.ParseException;
026 import java.text.SimpleDateFormat;
027 import java.util.ArrayList;
028 import java.util.Arrays;
029 import java.util.Calendar;
030 import java.util.Comparator;
031 import java.util.Date;
032 import java.util.Enumeration;
033 import java.util.HashMap;
034 import java.util.HashSet;
035 import java.util.List;
036 import java.util.Map;
037 import java.util.Properties;
038 import java.util.Set;
039 import java.util.TimeZone;
040
041 import org.apache.commons.lang.StringUtils;
042 import org.apache.hadoop.fs.FileStatus;
043 import org.apache.hadoop.fs.FileSystem;
044 import org.apache.hadoop.fs.Path;
045 import org.apache.hadoop.fs.PathFilter;
046 import org.apache.hadoop.fs.permission.FsPermission;
047 import org.apache.oozie.action.ActionExecutor;
048 import org.apache.oozie.action.hadoop.JavaActionExecutor;
049 import org.apache.oozie.client.rest.JsonUtils;
050 import org.apache.oozie.util.Instrumentable;
051 import org.apache.oozie.util.Instrumentation;
052 import org.apache.oozie.util.XLog;
053
054 import com.google.common.annotations.VisibleForTesting;
055
056 import org.apache.oozie.ErrorCode;
057
058 public class ShareLibService implements Service, Instrumentable {
059
060 public static final String LAUNCHERJAR_LIB_RETENTION = CONF_PREFIX + "ShareLibService.temp.sharelib.retention.days";
061
062 public static final String SHARELIB_MAPPING_FILE = CONF_PREFIX + "ShareLibService.mapping.file";
063
064 public static final String SHIP_LAUNCHER_JAR = "oozie.action.ship.launcher.jar";
065
066 public static final String PURGE_INTERVAL = CONF_PREFIX + "ShareLibService.purge.interval";
067
068 public static final String FAIL_FAST_ON_STARTUP = CONF_PREFIX + "ShareLibService.fail.fast.on.startup";
069
070 private static final String PERMISSION_STRING = "-rwxr-xr-x";
071
072 public static final String LAUNCHER_PREFIX = "launcher_";
073
074 public static final String SHARED_LIB_PREFIX = "lib_";
075
076 public static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
077
078 private Services services;
079
080 private Map<String, List<Path>> shareLibMap = new HashMap<String, List<Path>>();
081
082 private Map<String, List<Path>> launcherLibMap = new HashMap<String, List<Path>>();
083
084 private static XLog LOG = XLog.getLog(ShareLibService.class);
085
086 private String sharelibMappingFile;
087
088 private boolean isShipLauncherEnabled = false;
089
090 public static String SHARE_LIB_CONF_PREFIX = "oozie";
091
092 private boolean shareLibLoadAttempted = false;
093
094 private String sharelibMetaFileOldTimeStamp;
095
096 private String sharelibDirOld;
097
098 FileSystem fs;
099
100 final long retentionTime = 1000 * 60 * 60 * 24 * Services.get().getConf().getInt(LAUNCHERJAR_LIB_RETENTION, 7);
101
102 @Override
103 public void init(Services services) throws ServiceException {
104 this.services = services;
105 sharelibMappingFile = services.getConf().get(SHARELIB_MAPPING_FILE, "");
106 isShipLauncherEnabled = services.getConf().getBoolean(SHIP_LAUNCHER_JAR, false);
107 boolean failOnfailure = services.getConf().getBoolean(FAIL_FAST_ON_STARTUP, false);
108 Path launcherlibPath = getLauncherlibPath();
109 HadoopAccessorService has = Services.get().get(HadoopAccessorService.class);
110 URI uri = launcherlibPath.toUri();
111 try {
112 fs = FileSystem.get(has.createJobConf(uri.getAuthority()));
113 updateLauncherLib();
114 updateShareLib();
115 } catch(Throwable e) {
116 if (failOnfailure) {
117 LOG.error("Sharelib initialization fails", e);
118 throw new ServiceException(ErrorCode.E0104, getClass().getName(), "Sharelib initialization fails. ", e);
119 }
120 else {
121 // We don't want to actually fail init by throwing an Exception, so only create the ServiceException and
122 // log it
123 ServiceException se = new ServiceException(ErrorCode.E0104, getClass().getName(),
124 "Not able to cache sharelib. An Admin needs to install the sharelib with oozie-setup.sh and issue the "
125 + "'oozie admin' CLI command to update the sharelib", e);
126 LOG.error(se);
127 }
128 }
129 Runnable purgeLibsRunnable = new Runnable() {
130 @Override
131 public void run() {
132 System.out.flush();
133 try {
134 //Only one server should purge sharelib
135 if (Services.get().get(JobsConcurrencyService.class).isLeader()) {
136 final Date current = Calendar.getInstance(TimeZone.getTimeZone("GMT")).getTime();
137 purgeLibs(fs, LAUNCHER_PREFIX, current);
138 purgeLibs(fs, SHARED_LIB_PREFIX, current);
139 }
140 }
141 catch (IOException e) {
142 LOG.error("There was an issue purging the sharelib", e);
143 }
144 }
145 };
146 services.get(SchedulerService.class).schedule(purgeLibsRunnable, 10,
147 services.getConf().getInt(PURGE_INTERVAL, 1) * 60 * 60 * 24, SchedulerService.Unit.SEC);
148 }
149
150 /**
151 * Recursively change permissions.
152 *
153 * @throws IOException Signals that an I/O exception has occurred.
154 * @throws ClassNotFoundException the class not found exception
155 */
156
157 private void updateLauncherLib() throws IOException {
158 if (isShipLauncherEnabled) {
159 if (fs == null) {
160 Path launcherlibPath = getLauncherlibPath();
161 HadoopAccessorService has = Services.get().get(HadoopAccessorService.class);
162 URI uri = launcherlibPath.toUri();
163 fs = FileSystem.get(has.createJobConf(uri.getAuthority()));
164 }
165 Path launcherlibPath = getLauncherlibPath();
166 setupLauncherLibPath(fs, launcherlibPath);
167 recursiveChangePermissions(fs, launcherlibPath, FsPermission.valueOf(PERMISSION_STRING));
168 }
169
170 }
171
172 /**
173 * Copy launcher jars to Temp directory
174 *
175 * @param fs the FileSystem
176 * @param tmpShareLibPath destination path
177 * @throws IOException Signals that an I/O exception has occurred.
178 * @throws ClassNotFoundException the class not found exception
179 */
180 private void setupLauncherLibPath(FileSystem fs, Path tmpLauncherLibPath) throws IOException {
181
182 ActionService actionService = Services.get().get(ActionService.class);
183 List<Class> classes = JavaActionExecutor.getCommonLauncherClasses();
184 Path baseDir = new Path(tmpLauncherLibPath, JavaActionExecutor.OOZIE_COMMON_LIBDIR);
185 copyJarContainingClasses(classes, fs, baseDir, JavaActionExecutor.OOZIE_COMMON_LIBDIR);
186 Set<String> actionTypes = actionService.getActionTypes();
187 for (String key : actionTypes) {
188 ActionExecutor executor = actionService.getExecutor(key);
189 if (executor instanceof JavaActionExecutor) {
190 JavaActionExecutor jexecutor = (JavaActionExecutor) executor;
191 classes = jexecutor.getLauncherClasses();
192 if (classes != null) {
193 String type = executor.getType();
194 Path executorDir = new Path(tmpLauncherLibPath, type);
195 copyJarContainingClasses(classes, fs, executorDir, type);
196 }
197 }
198 }
199 }
200
201 /**
202 * Recursive change permissions.
203 *
204 * @param fs the FileSystem
205 * @param path the Path
206 * @param perm is permission
207 * @throws IOException Signals that an I/O exception has occurred.
208 */
209 private void recursiveChangePermissions(FileSystem fs, Path path, FsPermission fsPerm) throws IOException {
210 fs.setPermission(path, fsPerm);
211 FileStatus[] filesStatus = fs.listStatus(path);
212 for (int i = 0; i < filesStatus.length; i++) {
213 Path p = filesStatus[i].getPath();
214 if (filesStatus[i].isDir()) {
215 recursiveChangePermissions(fs, p, fsPerm);
216 }
217 else {
218 fs.setPermission(p, fsPerm);
219 }
220 }
221 }
222
223 /**
224 * Copy jar containing classes.
225 *
226 * @param classes the classes
227 * @param fs the FileSystem
228 * @param executorDir is Path
229 * @param type is actionKey
230 * @throws IOException Signals that an I/O exception has occurred.
231 */
232 private void copyJarContainingClasses(List<Class> classes, FileSystem fs, Path executorDir, String type)
233 throws IOException {
234 fs.mkdirs(executorDir);
235 Set<String> localJarSet = new HashSet<String>();
236 for (Class c : classes) {
237 String localJar = findContainingJar(c);
238 if (localJar != null) {
239 localJarSet.add(localJar);
240 }
241 else {
242 throw new IOException("No jar containing " + c + " found");
243 }
244 }
245 List<Path> listOfPaths = new ArrayList<Path>();
246 for (String localJarStr : localJarSet) {
247 File localJar = new File(localJarStr);
248 fs.copyFromLocalFile(new Path(localJar.getPath()), executorDir);
249 Path path = new Path(executorDir, localJar.getName());
250 listOfPaths.add(path);
251 LOG.info(localJar.getName() + " uploaded to " + executorDir.toString());
252 }
253 launcherLibMap.put(type, listOfPaths);
254
255 }
256
257 /**
258 * Gets the path recursively.
259 *
260 * @param fs the FileSystem
261 * @param rootDir the root directory
262 * @param listOfPaths the list of paths
263 * @return the path recursively
264 * @throws IOException Signals that an I/O exception has occurred.
265 */
266 private void getPathRecursively(FileSystem fs, Path rootDir, List<Path> listOfPaths) throws IOException {
267 if (rootDir == null) {
268 return;
269 }
270
271 FileStatus[] status = fs.listStatus(rootDir);
272 if (status == null) {
273 LOG.info("Shared lib " + rootDir + " doesn't exist, not adding to cache");
274 return;
275 }
276
277 for (FileStatus file : status) {
278 if (file.isDir()) {
279 getPathRecursively(fs, file.getPath(), listOfPaths);
280 }
281 else {
282 listOfPaths.add(file.getPath());
283 }
284 }
285 }
286
287 public Map<String, List<Path>> getShareLib() {
288 return shareLibMap;
289 }
290
291 /**
292 * Gets the action system lib common jars.
293 *
294 * @param actionKey the action key
295 * @return List of paths
296 * @throws IOException
297 */
298 public List<Path> getShareLibJars(String actionKey) throws IOException {
299 // Sharelib map is empty means that on previous or startup attempt of
300 // caching sharelib has failed.Trying to reload
301 if (shareLibMap.isEmpty() && !shareLibLoadAttempted) {
302 synchronized (ShareLibService.class) {
303 if (shareLibMap.isEmpty()) {
304 updateShareLib();
305 shareLibLoadAttempted = true;
306 }
307 }
308 }
309 return shareLibMap.get(actionKey);
310 }
311
312 /**
313 * Gets the launcher jars.
314 *
315 * @param actionKey the action key
316 * @return launcher jars paths
317 * @throws ClassNotFoundException
318 * @throws IOException
319 */
320 public List<Path> getSystemLibJars(String actionKey) throws IOException {
321 List<Path> returnList = new ArrayList<Path>();
322 // Sharelib map is empty means that on previous or startup attempt of
323 // caching launcher jars has failed.Trying to reload
324 if (isShipLauncherEnabled) {
325 if (launcherLibMap.isEmpty()) {
326 synchronized (ShareLibService.class) {
327 if (launcherLibMap.isEmpty()) {
328 updateLauncherLib();
329 }
330 }
331 }
332 if (launcherLibMap.get(actionKey) != null) {
333 returnList.addAll(launcherLibMap.get(actionKey));
334 }
335 }
336 if (actionKey.equals(JavaActionExecutor.OOZIE_COMMON_LIBDIR)) {
337 List<Path> sharelibList = getShareLibJars(actionKey);
338 if (sharelibList != null) {
339 returnList.addAll(sharelibList);
340 }
341 }
342 return returnList;
343 }
344
345 /**
346 * Find containing jar containing.
347 *
348 * @param clazz the clazz
349 * @return the string
350 */
351 @VisibleForTesting
352 protected String findContainingJar(Class clazz) {
353 ClassLoader loader = clazz.getClassLoader();
354 String classFile = clazz.getName().replaceAll("\\.", "/") + ".class";
355 try {
356 for (Enumeration itr = loader.getResources(classFile); itr.hasMoreElements();) {
357 URL url = (URL) itr.nextElement();
358 if ("jar".equals(url.getProtocol())) {
359 String toReturn = url.getPath();
360 if (toReturn.startsWith("file:")) {
361 toReturn = toReturn.substring("file:".length());
362 // URLDecoder is a misnamed class, since it actually
363 // decodes
364 // x-www-form-urlencoded MIME type rather than actual
365 // URL encoding (which the file path has). Therefore it
366 // would
367 // decode +s to ' 's which is incorrect (spaces are
368 // actually
369 // either unencoded or encoded as "%20"). Replace +s
370 // first, so
371 // that they are kept sacred during the decoding
372 // process.
373 toReturn = toReturn.replaceAll("\\+", "%2B");
374 toReturn = URLDecoder.decode(toReturn, "UTF-8");
375 toReturn = toReturn.replaceAll("!.*$", "");
376 return toReturn;
377 }
378 }
379 }
380 }
381 catch (IOException ioe) {
382 throw new RuntimeException(ioe);
383 }
384 return null;
385 }
386
387 /**
388 * Purge libs.
389 *
390 * @param fs the fs
391 * @param prefix the prefix
392 * @throws IOException Signals that an I/O exception has occurred.
393 */
394 private void purgeLibs(FileSystem fs, final String prefix, final Date current) throws IOException {
395 Path executorLibBasePath = services.get(WorkflowAppService.class).getSystemLibPath();
396 PathFilter directoryFilter = new PathFilter() {
397 @Override
398 public boolean accept(Path path) {
399 if (path.getName().startsWith(prefix)) {
400 String name = path.getName();
401 String time = name.substring(prefix.length());
402 Date d = null;
403 try {
404 d = dateFormat.parse(time);
405 }
406 catch (ParseException e) {
407 return false;
408 }
409 return (current.getTime() - d.getTime()) > retentionTime;
410 }
411 else {
412 return false;
413 }
414 }
415 };
416 FileStatus[] dirList = fs.listStatus(executorLibBasePath, directoryFilter);
417 Arrays.sort(dirList, new Comparator<FileStatus>() {
418 // sort in desc order
419 @Override
420 public int compare(FileStatus o1, FileStatus o2) {
421 return o2.getPath().getName().compareTo(o1.getPath().getName());
422 }
423 });
424
425 //Logic is to keep all share-lib between current timestamp and 7days old + 1 latest sharelib older than 7 days.
426 // refer OOZIE-1761
427 for (int i = 1; i < dirList.length; i++) {
428 Path dirPath = dirList[i].getPath();
429 fs.delete(dirPath, true);
430 LOG.info("Deleted old launcher jar lib directory {0}", dirPath.getName());
431 }
432 }
433
434 @Override
435 public void destroy() {
436 shareLibMap.clear();
437 launcherLibMap.clear();
438
439 }
440
441 @Override
442 public Class<? extends Service> getInterface() {
443 return ShareLibService.class;
444 }
445
446 /**
447 * Update share lib cache.
448 *
449 * @return the map
450 * @throws IOException Signals that an I/O exception has occurred.
451 */
452 public Map<String, String> updateShareLib() throws IOException {
453 Map<String, String> status = new HashMap<String, String>();
454
455 if (fs == null) {
456 Path launcherlibPath = getLauncherlibPath();
457 HadoopAccessorService has = Services.get().get(HadoopAccessorService.class);
458 URI uri = launcherlibPath.toUri();
459 fs = FileSystem.get(has.createJobConf(uri.getAuthority()));
460 }
461
462 Map<String, List<Path>> tempShareLibMap = new HashMap<String, List<Path>>();
463
464 if (!StringUtils.isEmpty(sharelibMappingFile)) {
465 String sharelibMetaFileNewTimeStamp = JsonUtils.formatDateRfc822(new Date(fs.getFileStatus(
466 new Path(sharelibMappingFile)).getModificationTime()),"GMT");
467 loadShareLibMetaFile(tempShareLibMap, sharelibMappingFile);
468 status.put("sharelibMetaFile", sharelibMappingFile);
469 status.put("sharelibMetaFileNewTimeStamp", sharelibMetaFileNewTimeStamp);
470 status.put("sharelibMetaFileOldTimeStamp", sharelibMetaFileOldTimeStamp);
471 sharelibMetaFileOldTimeStamp = sharelibMetaFileNewTimeStamp;
472 }
473 else {
474 Path shareLibpath = getLatestLibPath(services.get(WorkflowAppService.class).getSystemLibPath(),
475 SHARED_LIB_PREFIX);
476 loadShareLibfromDFS(tempShareLibMap, shareLibpath);
477
478 if (shareLibpath != null) {
479 status.put("sharelibDirNew", shareLibpath.toString());
480 status.put("sharelibDirOld", sharelibDirOld);
481 sharelibDirOld = shareLibpath.toString();
482 }
483
484 }
485 shareLibMap = tempShareLibMap;
486 return status;
487 }
488
489 /**
490 * Update share lib cache. Parse the share lib directory and each sub
491 * directory is a action key
492 *
493 * @param shareLibMap the share lib jar map
494 * @param shareLibpath the share libpath
495 * @throws IOException Signals that an I/O exception has occurred.
496 */
497 private void loadShareLibfromDFS(Map<String, List<Path>> shareLibMap, Path shareLibpath) throws IOException {
498
499 if (shareLibpath == null) {
500 LOG.info("No share lib directory found");
501 return;
502
503 }
504
505 FileStatus[] dirList = fs.listStatus(shareLibpath);
506
507 if (dirList == null) {
508 return;
509 }
510
511 for (FileStatus dir : dirList) {
512 if (!dir.isDir()) {
513 continue;
514 }
515 List<Path> listOfPaths = new ArrayList<Path>();
516 getPathRecursively(fs, dir.getPath(), listOfPaths);
517 shareLibMap.put(dir.getPath().getName(), listOfPaths);
518 LOG.info("Share lib for " + dir.getPath().getName() + ":" + listOfPaths);
519
520 }
521
522 }
523
524 /**
525 * Load share lib text file. Sharelib mapping files contains list of
526 * key=value. where key is the action key and value is the DFS location of
527 * sharelib files.
528 *
529 * @param shareLibMap the share lib jar map
530 * @param sharelipFileMapping the sharelip file mapping
531 * @throws IOException Signals that an I/O exception has occurred.
532 */
533 @SuppressWarnings("unchecked")
534 private void loadShareLibMetaFile(Map<String, List<Path>> shareLibMap, String sharelibFileMapping)
535 throws IOException {
536
537 Path shareFileMappingPath = new Path(sharelibFileMapping);
538 HadoopAccessorService has = Services.get().get(HadoopAccessorService.class);
539 FileSystem filesystem = FileSystem.get(has.createJobConf(shareFileMappingPath.toUri().getAuthority()));
540 Properties prop = new Properties();
541 prop.load(filesystem.open(new Path(sharelibFileMapping)));
542
543 for (Object keyObject : prop.keySet()) {
544 String key = (String) keyObject;
545 if (key.toLowerCase().startsWith(SHARE_LIB_CONF_PREFIX)) {
546 String mapKey = key.substring(SHARE_LIB_CONF_PREFIX.length() + 1);
547 String pathList[] = ((String) prop.get(key)).split(",");
548 List<Path> listOfPaths = new ArrayList<Path>();
549 for (String dfsPath : pathList) {
550 getPathRecursively(fs, new Path(dfsPath), listOfPaths);
551 }
552 shareLibMap.put(mapKey, listOfPaths);
553 LOG.info("Share lib for " + mapKey + ":" + listOfPaths);
554
555 }
556 else {
557 LOG.info(" Not adding " + key + " to sharelib, not prefix with " + SHARE_LIB_CONF_PREFIX);
558 }
559
560 }
561 }
562
563 /**
564 * Gets the launcherlib path.
565 *
566 * @return the launcherlib path
567 */
568 private Path getLauncherlibPath() {
569 String formattedDate = dateFormat.format(Calendar.getInstance(TimeZone.getTimeZone("GMT")).getTime());
570 Path tmpLauncherLibPath = new Path(services.get(WorkflowAppService.class).getSystemLibPath(), LAUNCHER_PREFIX
571 + formattedDate);
572 return tmpLauncherLibPath;
573 }
574
575 /**
576 * Gets the Latest lib path.
577 *
578 * @param rootDir the root dir
579 * @param prefix the prefix
580 * @return latest lib path
581 * @throws IOException Signals that an I/O exception has occurred.
582 */
583 public Path getLatestLibPath(Path rootDir, final String prefix) throws IOException {
584 Date max = new Date(0L);
585 Path path = null;
586 PathFilter directoryFilter = new PathFilter() {
587 @Override
588 public boolean accept(Path path) {
589 return path.getName().startsWith(prefix);
590 }
591 };
592
593 FileStatus[] files = fs.listStatus(rootDir, directoryFilter);
594 for (FileStatus file : files) {
595 String name = file.getPath().getName().toString();
596 String time = name.substring(prefix.length());
597 Date d = null;
598 try {
599 d = dateFormat.parse(time);
600 }
601 catch (ParseException e) {
602 continue;
603 }
604 if (d.compareTo(max) > 0) {
605 path = file.getPath();
606 max = d;
607 }
608 }
609 //If there are no timestamped directories, fall back to root directory
610 if (path == null) {
611 path = rootDir;
612 }
613 return path;
614 }
615
616 /**
617 * Instruments the log service.
618 * <p/>
619 * It sets instrumentation variables indicating the location of the sharelib and launcherlib
620 *
621 * @param instr instrumentation to use.
622 */
623 @Override
624 public void instrument(Instrumentation instr) {
625 instr.addVariable("libs", "sharelib.source", new Instrumentation.Variable<String>() {
626 @Override
627 public String getValue() {
628 if (!StringUtils.isEmpty(sharelibMappingFile)) {
629 return SHARELIB_MAPPING_FILE;
630 }
631 return WorkflowAppService.SYSTEM_LIB_PATH;
632 }
633 });
634 instr.addVariable("libs", "sharelib.mapping.file", new Instrumentation.Variable<String>() {
635 @Override
636 public String getValue() {
637 if (!StringUtils.isEmpty(sharelibMappingFile)) {
638 return sharelibMappingFile;
639 }
640 return "(none)";
641 }
642 });
643 instr.addVariable("libs", "sharelib.system.libpath", new Instrumentation.Variable<String>() {
644 @Override
645 public String getValue() {
646 String sharelibPath = "(unavailable)";
647 try {
648 Path libPath = getLatestLibPath(services.get(WorkflowAppService.class).getSystemLibPath(),
649 SHARED_LIB_PREFIX);
650 if (libPath != null) {
651 sharelibPath = libPath.toUri().toString();
652 }
653 }
654 catch (IOException ioe) {
655 // ignore exception because we're just doing instrumentation
656 }
657 return sharelibPath;
658 }
659 });
660 instr.addVariable("libs", "sharelib.mapping.file.timestamp", new Instrumentation.Variable<String>() {
661 @Override
662 public String getValue() {
663 if (!StringUtils.isEmpty(sharelibMetaFileOldTimeStamp)) {
664 return sharelibMetaFileOldTimeStamp;
665 }
666 return "(none)";
667 }
668 });
669 instr.addVariable("libs", "sharelib.keys", new Instrumentation.Variable<String>() {
670 @Override
671 public String getValue() {
672 Map<String, List<Path>> shareLib = getShareLib();
673 if (shareLib != null && !shareLib.isEmpty()) {
674 Set<String> keySet = shareLib.keySet();
675 return keySet.toString();
676 }
677 return "(unavailable)";
678 }
679 });
680 instr.addVariable("libs", "launcherlib.system.libpath", new Instrumentation.Variable<String>() {
681 @Override
682 public String getValue() {
683 return getLauncherlibPath().toUri().toString();
684 }
685 });
686 }
687
688 /**
689 * Returns file system for shared libraries.
690 * <p/>
691 * If WorkflowAppService#getSystemLibPath doesn't have authority then a default one assumed
692 *
693 * @return file system for shared libraries
694 */
695 public FileSystem getFileSystem() {
696 return fs;
697 }
698 }