private Set<String> outputFoldersForProject(final IJavaProject project) {
    final Set<String> outputFolders = new HashSet<String>();
    final IPath projectLocation = projectLocationPath(project);

    try {
      final IPath defaultOutputLocation = project.getOutputLocation();
      if (defaultOutputLocation != null) {
        final IPath fullPath = appendPathTo(projectLocation, defaultOutputLocation);
        if (fullPath.toFile().exists()) {
          outputFolders.add(fullPath.toOSString());
        }
      }
      for (final IClasspathEntry entry : project.getRawClasspath()) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
          final IPath outputLocation = entry.getOutputLocation();
          if (outputLocation != null) {
            final IPath fullPath = appendPathTo(projectLocation, outputLocation);
            if (fullPath.toFile().exists()) {
              outputFolders.add(fullPath.toOSString());
            }
          }
        }
      }
    } catch (final JavaModelException ex) {
      FeatureEditorPlugin.instance()
          .warn("Could not get output folder location for project " + project.getElementName());
    }

    return outputFolders;
  }
  public static String getLiferayWorkspaceProjectModulesDir(final IProject project) {
    String retval = null;

    if (project != null) {
      final IPath projectLocation = project.getLocation();

      if (projectLocation != null) {
        final IPath gradlePropertiesLocation = projectLocation.append("gradle.properties");

        if (gradlePropertiesLocation.toFile().exists()) {
          try {
            String modulesDir =
                CoreUtil.readPropertyFileValue(
                    gradlePropertiesLocation.toFile(), "liferay.workspace.modules.dir");

            if (modulesDir == null) {
              modulesDir = "modules";
            }

            retval = modulesDir;
          } catch (IOException e) {
            ProjectCore.logError("Can't read gradle properties from workspaceProject. ", e);
          }
        }
      }
    }

    return retval;
  }
  @Override
  public IStatus transferSettings(IPath newWorkspaceRoot) {
    IPath currentWorkspace = Platform.getLocation();

    File srcDir =
        new File(
            currentWorkspace.toFile(), ".metadata/.plugins/org.eclipse.core.runtime/.settings");
    File destDir =
        new File(
            newWorkspaceRoot.toFile(), ".metadata/.plugins/org.eclipse.core.runtime/.settings");

    File[] srcSettings = srcDir.listFiles();

    if (!destDir.exists()) {
      if (!destDir.mkdirs())
        return new Status(IStatus.ERROR, LiferayUIPlugin.PLUGIN_ID, "can't create dirs");
    }

    for (File src : srcSettings) {
      File destSetting = new File(destDir.getAbsolutePath(), src.getName());

      if (destSetting.exists()) {
        if (!destSetting.delete()) {
          return new Status(IStatus.ERROR, LiferayUIPlugin.PLUGIN_ID, "can't delete settings file");
        }
      }

      FileUtil.copyFile(src, destSetting);
    }

    return Status.OK_STATUS;
  }
Esempio n. 4
0
	public static File getDependencyPath(URL resource, boolean isRelativePath) {
		if (resource!=null) {
			IPath path = Activator.getDefault().getStateLocation();
			IPath libFolder = path.append("lib");
			String[] paths = resource.getFile().split("/");
			IPath library = libFolder.append(paths[paths.length - 1]);
			File libraryFile = library.toFile();
			if (!libraryFile.exists()) {
				try {
					writeToFile(libraryFile, resource.openStream());
				} catch (IOException e) {
					log.error(e);
					return null;
				}
			}
			if (isRelativePath) {
				IPath relativePath = EclipseUtils
						.getWorkspaceRelativePath(library);
				relativePath = new Path(Constants.ECLIPSE_WORKSPACE_PATH)
						.append(relativePath);
				return relativePath.toFile();
			} else {
				return library.toFile();
			}
		} else{
			log.error("the requested resource does not exist in library path");
			return null;
		}
	}
Esempio n. 5
0
  public static File getCurrentWorkspace() {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    IWorkspaceRoot root = workspace.getRoot();

    IPath location = root.getLocation();
    location.toFile();

    return location.toFile();
  }
  public void testMoveProjectWithVirtualFolder() {
    IPath fileLocation = getRandomLocation();
    IPath folderLocation = getRandomLocation();

    IFile file = existingVirtualFolderInExistingProject.getFile(getUniqueString());
    IFolder folder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());
    IFile childFile = folder.getFile(getUniqueString());
    IResource[] oldResources = new IResource[] {existingProject, file, folder, childFile};

    try {
      assertDoesNotExistInWorkspace("1.0", new IResource[] {folder, file, childFile});

      try {
        createFileInFileSystem(fileLocation);
        folderLocation.toFile().mkdir();

        folder.createLink(folderLocation, IResource.NONE, getMonitor());
        file.createLink(fileLocation, IResource.NONE, getMonitor());

        childFile.create(getRandomContents(), true, getMonitor());
      } catch (CoreException e) {
        fail("2.0", e);
      }

      // move the project
      IProject destinationProject = getWorkspace().getRoot().getProject("MoveTargetProject");
      assertDoesNotExistInWorkspace("3.0", destinationProject);

      try {
        existingProject.move(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
      } catch (CoreException e) {
        fail("4.0", e);
      }

      IFile newFile = destinationProject.getFile(file.getProjectRelativePath());
      IFolder newFolder = destinationProject.getFolder(folder.getProjectRelativePath());
      IFile newChildFile = newFolder.getFile(childFile.getName());
      IResource[] newResources =
          new IResource[] {destinationProject, newFile, newFolder, newChildFile};

      assertExistsInWorkspace("5.0", newResources);
      assertDoesNotExistInWorkspace("6.1", oldResources);
      assertTrue("7.0", existingProject.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("8.0", destinationProject.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("9.0", newFile.getParent().isVirtual());
      assertTrue("10.0", newFile.isLinked());

      assertTrue("11.0", newFolder.isLinked());
      assertTrue("12.0", newFolder.getParent().isVirtual());
    } finally {
      Workspace.clear(fileLocation.toFile());
      Workspace.clear(folderLocation.toFile());
    }
  }
  private void publishArchiveModule(
      String jarURI, Properties p, List status, IProgressMonitor monitor) {
    IPath path = server.getModuleDeployDirectory(module[0]);
    boolean moving = false;
    // Get URI used for previous publish, if known
    String oldURI = (String) p.get(module[1].getId());
    if (oldURI != null) {
      // If old URI found, detect if jar is moving or changing its name
      if (jarURI != null) {
        moving = !oldURI.equals(jarURI);
      }
    }
    // If we don't have a jar URI, make a guess so we have one if we need it
    if (jarURI == null) {
      jarURI = "WEB-INF/lib/" + module[1].getName(); // $NON-NLS-1$
    }
    IPath jarPath = path.append(jarURI);
    // Make our best determination of the path to the old jar
    IPath oldJarPath = jarPath;
    if (oldURI != null) {
      oldJarPath = path.append(oldURI);
    }
    // Establish the destination directory
    path = jarPath.removeLastSegments(1);

    // Remove if requested or if previously published and are now serving without publishing
    if (moving
        || kind == IServer.PUBLISH_CLEAN
        || deltaKind == ServerBehaviourDelegate.REMOVED
        || server.getTomcatServer().isServeModulesWithoutPublish()) {
      File file = oldJarPath.toFile();
      if (file.exists()) {
        file.delete();
      }
      p.remove(module[1].getId());

      if (deltaKind == ServerBehaviourDelegate.REMOVED
          || server.getTomcatServer().isServeModulesWithoutPublish()) return;
    }
    if (!moving && kind != IServer.PUBLISH_CLEAN && kind != IServer.PUBLISH_FULL) {
      // avoid changes if no changes to module since last publish
      IModuleResourceDelta[] delta = server.getPublishedResourceDelta(module);
      if (delta == null || delta.length == 0) return;
    }

    // make directory if it doesn't exist
    if (!path.toFile().exists()) path.toFile().mkdirs();

    IModuleResource[] mr = server.getResources(module);
    IStatus[] stat = helper.publishToPath(mr, jarPath, monitor);
    addArrayToList(status, stat);
    p.put(module[1].getId(), jarURI);
  }
Esempio n. 8
0
  public static String[] execute(String args) throws BladeCLIException {
    final IPath bladeCLIPath = getBladeCLIPath();

    if (bladeCLIPath == null || !bladeCLIPath.toFile().exists()) {
      throw new BladeCLIException("Could not get blade cli jar.");
    }

    final Project project = new Project();
    final Java javaTask = new Java();

    javaTask.setProject(project);
    javaTask.setFork(true);
    javaTask.setFailonerror(true);
    javaTask.setJar(bladeCLIPath.toFile());
    javaTask.setArgs(args);

    final DefaultLogger logger = new DefaultLogger();
    project.addBuildListener(logger);

    final StringBufferOutputStream out = new StringBufferOutputStream();

    logger.setOutputPrintStream(new PrintStream(out));
    logger.setMessageOutputLevel(Project.MSG_INFO);

    int returnCode = javaTask.executeJava();

    final List<String> lines = new ArrayList<>();
    final Scanner scanner = new Scanner(out.toString());

    while (scanner.hasNextLine()) {
      lines.add(scanner.nextLine().replaceAll(".*\\[null\\] ", ""));
    }

    scanner.close();

    boolean hasErrors = false;

    final StringBuilder errors = new StringBuilder();

    for (String line : lines) {
      if (line.startsWith("Error")) {
        hasErrors = true;
      } else if (hasErrors) {
        errors.append(line);
      }
    }

    if (returnCode != 0 || hasErrors) {
      throw new BladeCLIException(errors.toString());
    }

    return lines.toArray(new String[0]);
  }
 public String getFrameworkJarPath() {
   IPath installPath = getServer().getRuntime().getLocation();
   IPath plugins = installPath.append("plugins");
   if (plugins.toFile().exists()) {
     File[] files = plugins.toFile().listFiles();
     for (File file : files) {
       if (file.getName().indexOf("org.eclipse.osgi_") > -1) {
         return file.getAbsolutePath();
       }
     }
   }
   return null;
 }
  private void setClassLoader() {
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IJavaProject javaProject = getJavaProject();

    try {
      if (javaProject != null) {
        List<URL> entries = new ArrayList<URL>();
        IPath path = javaProject.getOutputLocation();
        IResource iResource = root.findMember(path);
        path = iResource.getLocation();
        path = path.addTrailingSeparator();
        entries.add(path.toFile().toURL());

        IClasspathEntry[] cpEntries = javaProject.getRawClasspath();
        for (IClasspathEntry cpEntry : cpEntries) {
          switch (cpEntry.getEntryKind()) {
            case IClasspathEntry.CPE_SOURCE:
              path = cpEntry.getOutputLocation();
              if (path != null) {
                iResource = root.findMember(path);
                path = iResource.getLocation();
                path = path.addTrailingSeparator();
                entries.add(path.toFile().toURL());
              }
              break;

            case IClasspathEntry.CPE_LIBRARY:
              iResource = root.findMember(cpEntry.getPath());
              if (iResource == null) {
                // resource is not in workspace, must be an external JAR
                path = cpEntry.getPath();
              } else {
                path = iResource.getLocation();
              }
              entries.add(path.toFile().toURL());
              break;
          }
        }

        ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
        URL[] entryArray = new URL[entries.size()];
        entries.toArray(entryArray);
        ClassLoader newCl = new URLClassLoader(entryArray, oldCl);
        Thread.currentThread().setContextClassLoader(newCl);
        oldClassLoader = oldCl;
      }
    } catch (Exception e) {
      // ignore - something too complex is wrong
      ;
    }
  }
  /**
   * Prints a list of module name, version, path to the given file, to be used by the runtime
   * launcher, because passing it as an argument/environment would easily exceed the OS size limits.
   */
  private void writeModuleInfoFile(File tmpFile, ILaunchConfiguration configuration)
      throws IOException, CoreException {
    FileWriter writer = new FileWriter(tmpFile);
    IJavaProject javaProject = getJavaProject(configuration);
    IProject project = javaProject.getProject();
    Context context = getProjectTypeChecker(project).getContext();

    RepositoryManager provider = context.getRepositoryManager();
    Set<Module> modulesToAdd = context.getModules().getListOfModules();
    boolean seenDefault = false;
    for (Module module : modulesToAdd) {
      String name = module.getNameAsString();
      if (JDKUtils.isJDKModule(name) || JDKUtils.isOracleJDKModule(name)) {
        continue;
      }
      if (module.isDefault()) seenDefault = true;
      IPath modulePath = getModuleArchive(provider, module);
      if (modulePath != null && modulePath.toFile().exists()) {
        String path = modulePath.toOSString();
        System.err.println(
            "Adding module: " + module.getNameAsString() + "/" + module.getVersion() + ": " + path);
        // print module name + NL (+ version + NL)? + path + NL
        writer.append(module.getNameAsString());
        writer.append(System.lineSeparator());
        if (!module.isDefault()) {
          writer.append(module.getVersion());
          writer.append(System.lineSeparator());
        }
        writer.append(path);
        writer.append(System.lineSeparator());
      }
    }
    // for some reason the default module can be missing from the list of modules
    if (!seenDefault) {
      IPath modulesFolder = getCeylonModulesOutputFolder(project).getLocation();
      IPath defaultCar = modulesFolder.append("default").append("default.car");
      if (defaultCar.toFile().exists()) {
        String path = defaultCar.toOSString();
        Module module = context.getModules().getDefaultModule();
        System.err.println("Adding default module: " + module.getNameAsString() + ": " + path);
        // print module name + NL + path + NL
        writer.append(module.getNameAsString());
        writer.append(System.lineSeparator());
        writer.append(path);
        writer.append(System.lineSeparator());
      }
    }
    writer.flush();
    writer.close();
  }
 /** @since 2.4 */
 @Override
 public Pair<URI, URI> getURIMapping(IPackageFragmentRoot root) throws JavaModelException {
   PackageFragmentRootData data = getData(root);
   if (data.uriPrefix == null) return null;
   IPath path = root.isExternal() ? root.getPath() : root.getUnderlyingResource().getLocation();
   URI physical = null;
   if (root.isArchive()) {
     String archiveScheme =
         "zip".equalsIgnoreCase(root.getPath().getFileExtension()) ? "zip" : "jar";
     physical = URI.createURI(archiveScheme + ":file:" + path.toFile().getPath() + "!/");
   } else {
     physical = URI.createFileURI(path.toFile().getPath() + "/");
   }
   return Tuples.create(data.uriPrefix, physical);
 }
 /**
  * Tries to infer a file location from given object, using various strategies
  *
  * @param o an object
  * @return a {@link File} associated to this object, or null.
  */
 public static File toFile(Object o) {
   if (o instanceof File) {
     return (File) o;
   } else if (o instanceof IResource) {
     IPath location = ((IResource) o).getLocation();
     return location == null ? null : location.toFile();
   } else if (o instanceof IAdaptable) {
     IResource resource = ((IAdaptable) o).getAdapter(IResource.class);
     if (resource != null) {
       IPath location = resource.getLocation();
       return location == null ? null : location.toFile();
     }
   }
   return null;
 }
Esempio n. 14
0
  /**
   * Creates new symbolic file system link from file or folder to another filesystem file. The
   * target path has to be present on disk.
   *
   * @param linkPath - filesystem path of the link being created.
   * @param realPath - file or folder on the file system, the target of the link.
   * @throws UnsupportedOperationException on Windows where links are not supported.
   * @throws IOException if execution of the command fails.
   */
  public static void createSymbolicLink(IPath linkPath, IPath realPath) throws IOException {
    if (!isSymbolicLinkSupported()) {
      throw new UnsupportedOperationException("Windows links .lnk are not supported.");
    }

    String command = "ln -s " + realPath.toOSString() + ' ' + linkPath.toOSString();
    Process process = Runtime.getRuntime().exec(command);

    // Wait for up to 2.5s...
    for (int i = 0; i < 5; i++) {
      try {
        Assert.assertTrue("ln process exited with non-zero status", process.waitFor() == 0);
        // If exitValue succeeded, then the process has exitted successfully.
        break;
      } catch (InterruptedException e) {
        // Clear interrupted state, see Java bug http://bugs.sun.com/view_bug.do?bug_id=6420270
        Thread.interrupted();
      }
      // wait for a 500ms before checking again
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        /*don't care*/
      }
    }
    Assert.assertTrue(
        "Symbolic link not created, command=[" + command + "]", linkPath.toFile().exists());
  }
Esempio n. 15
0
 /**
  * Install an extension using linked method
  *
  * @param extensionURL
  * @param extensionID
  * @param dir
  * @return boolean
  */
 public static boolean installLinkedExtension(URL extensionURL, String extensionID, File dir) {
   File file = new File(dir, extensionID);
   if (file.exists() && file.isDirectory()) {
     return true;
   }
   IPath base = CorePlugin.getDefault().getStateLocation().addTrailingSeparator();
   boolean result = installExtension(extensionURL, extensionID, base.toFile());
   if (result) {
     String linkedPath = base.append(extensionID).toOSString();
     FileOutputStream out = null;
     try {
       out = new FileOutputStream(file);
       out.write(linkedPath.getBytes());
     } catch (IOException e) {
       IdeLog.logError(CorePlugin.getDefault(), e.getMessage(), e);
     } finally {
       if (out != null) {
         try {
           out.close();
         } catch (IOException e) {
         }
       }
     }
   }
   return result;
 }
  /** Tests creating a linked folder under a virtual folder */
  public void testCreateLinkedFolderUnderVirtualFolder() {
    // get a non-existing location
    IPath location = getRandomLocation();
    IFolder linkedFolder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());

    try {
      linkedFolder.createLink(location, IResource.ALLOW_MISSING_LOCAL, getMonitor());
    } catch (CoreException e) {
      fail("1.0", e);
    }

    assertTrue("2.0", linkedFolder.exists());
    assertEquals("3.0", location, linkedFolder.getLocation());
    assertTrue("4.0", !location.toFile().exists());

    // getting children should succeed (and be empty)
    try {
      assertEquals("5.0", 0, linkedFolder.members().length);
    } catch (CoreException e) {
      fail("6.0", e);
    }

    // delete should succeed
    try {
      linkedFolder.delete(IResource.NONE, getMonitor());
    } catch (CoreException e) {
      fail("7.0", e);
    }
  }
Esempio n. 17
0
 /**
  * Returns the location of the Javadoc.
  *
  * @param element whose Javadoc location has to be found
  * @param isBinary <code>true</code> if the Java element is from a binary container
  * @return the location URL of the Javadoc or <code>null</code> if the location cannot be found
  * @throws JavaModelException thrown when the Java element cannot be accessed
  * @since 3.9
  */
 public static String getBaseURL(IJavaElement element, boolean isBinary)
     throws JavaModelException {
   if (isBinary) {
     // Source attachment usually does not include Javadoc resources
     // => Always use the Javadoc location as base:
     URL baseURL = JavaUI.getJavadocLocation(element, false);
     if (baseURL != null) {
       if (baseURL.getProtocol().equals(JAR_PROTOCOL)) {
         // It's a JarURLConnection, which is not known to the browser widget.
         // Let's start the help web server:
         URL baseURL2 =
             PlatformUI.getWorkbench().getHelpSystem().resolve(baseURL.toExternalForm(), true);
         if (baseURL2 != null) { // can be null if org.eclipse.help.ui is not available
           baseURL = baseURL2;
         }
       }
       return baseURL.toExternalForm();
     }
   } else {
     IResource resource = element.getResource();
     if (resource != null) {
       /*
        * Too bad: Browser widget knows nothing about EFS and custom URL handlers,
        * so IResource#getLocationURI() does not work in all cases.
        * We only support the local file system for now.
        * A solution could be https://bugs.eclipse.org/bugs/show_bug.cgi?id=149022 .
        */
       IPath location = resource.getLocation();
       if (location != null) return location.toFile().toURI().toString();
     }
   }
   return null;
 }
  private void saveConfigInfoIntoCache(String configType, String configInfo, IPath portalDir) {
    IPath versionsInfoPath = null;

    if (configType.equals(CONFIG_TYPE_VERSION)) {
      versionsInfoPath =
          LiferayServerCore.getDefault().getStateLocation().append("version.properties");
    } else if (configType.equals(CONFIG_TYPE_SERVER)) {
      versionsInfoPath =
          LiferayServerCore.getDefault().getStateLocation().append("serverInfos.properties");
    }

    if (versionsInfoPath != null) {
      File versionInfoFile = versionsInfoPath.toFile();

      if (configInfo != null) {
        String portalDirKey = CoreUtil.createStringDigest(portalDir.toPortableString());
        Properties properties = new Properties();

        try (FileInputStream fileInput = new FileInputStream(versionInfoFile)) {
          properties.load(fileInput);
        } catch (Exception e) {
        }

        try (FileOutputStream fileOutput = new FileOutputStream(versionInfoFile)) {
          properties.put(portalDirKey, configInfo);
          properties.store(fileOutput, StringPool.EMPTY);
        } catch (Exception e) {
          LiferayServerCore.logError(e);
        }
      }
    }
  }
Esempio n. 19
0
  /**
   * Search in plugin folder in .metadata and zip all files
   *
   * @throws ArchiveException
   */
  private static File createZip() throws ArchiveException {
    // Get all log xml files
    IPath pluginSaveFolder = FeedbackUtils.getFeedbackSaveFolder();
    java.io.File source = pluginSaveFolder.toFile();
    List<java.io.File> fileList = FileHelper.listAll(source);

    List<File> logFiles = new ArrayList<File>();
    for (java.io.File f : fileList) {
      if (f.getName().endsWith(FeedbackUtils.END_FILE_NAME)) {
        logFiles.add(new File(f));
      }
    }

    // Zip creation
    File zipFile = new File(source, FeedbackActivator.ZIP_FILE_NAME);
    zipFile.mkdir();
    // Add them to the zip
    for (File f : logFiles) {
      File zipEntry = new File(zipFile, f.getName(), ArchiveDetector.NULL);
      f.copyTo(zipEntry);
      if (zipFile.archiveCopyAllFrom(f)) {
        System.err.println("Copied " + f.getName());
      } else {
        System.err.println("Error in copy " + f.getName());
      }
    }
    File.update();
    return zipFile;
  }
Esempio n. 20
0
 /**
  * Returns a status for this library describing any error states
  *
  * @return
  */
 IStatus validate() {
   if (!getSystemLibraryPath().toFile().exists()) {
     return new Status(
         IStatus.ERROR,
         IJavaDebugUIConstants.PLUGIN_ID,
         IJavaDebugUIConstants.INTERNAL_ERROR,
         "System library does not exist: " + getSystemLibraryPath().toOSString(),
         null); //$NON-NLS-1$
   }
   IPath path = getSystemLibrarySourcePath();
   if (!path.isEmpty()) {
     if (!path.toFile().exists()) {
       // check for workspace resource
       IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
       if (resource == null || !resource.exists()) {
         return new Status(
             IStatus.ERROR,
             IJavaDebugUIConstants.PLUGIN_ID,
             IJavaDebugUIConstants.INTERNAL_ERROR,
             "Source attachment does not exist: " + path.toOSString(),
             null); //$NON-NLS-1$
       }
     }
   }
   return Status.OK_STATUS;
 }
Esempio n. 21
0
 @SuppressWarnings({"rawtypes", "unchecked", "resource"})
 @Override
 public Object createExecutableExtension(String propertyName) throws CoreException {
   try {
     String className = attributes.get(propertyName);
     IProject project = getProject();
     IJavaProject javaProject = JavaCore.create(project);
     String[] classPathEntries = JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
     List<URL> urlList = new ArrayList<URL>();
     for (int i = 0; i < classPathEntries.length; i++) {
       String entry = classPathEntries[i];
       IPath path = new Path(entry);
       URL url = path.toFile().toURI().toURL();
       urlList.add(url);
     }
     ClassLoader parentClassLoader = javaProject.getClass().getClassLoader();
     URL[] urls = (URL[]) urlList.toArray(new URL[urlList.size()]);
     URLClassLoader classLoader = new URLClassLoader(urls, parentClassLoader);
     ClassLoader cl = classLoader.getParent();
     Class clazz = classLoader.loadClass(className);
     return clazz.getConstructor().newInstance();
   } catch (Exception ex) {
     ex.printStackTrace();
     throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage()));
   }
 }
  @Override
  @SuppressWarnings("rawtypes")
  protected void publishModules(
      int kind, List modules, List deltaKind2, MultiStatus multi, IProgressMonitor monitor) {

    @SuppressWarnings("unchecked")
    final List<IModule[]> myModules = modules;

    IPath confDir = getBaseDirectory();

    FrameworkInstanceConfiguration jonasConfiguration;

    try {
      jonasConfiguration = getJonasRuntimeInstance().getJonasConfiguration();
      IPath deployDir = confDir.append("/jonasbase/tmp");
      IPath installDir = confDir.append("/jonasbase/deploy");
      File deployPath = deployDir.toFile();
      if (!deployPath.exists()) {
        deployPath.mkdir();
      }

      publishHelper.exportBundles(myModules, jonasConfiguration, installDir, deployDir);
      getJonasVersionHandler()
          .prepareFrameworkConfigurationFile(
              deployDir,
              publishHelper.getServerModules(myModules, "reference:file:", " "),
              publishHelper.getTargetBundles(jonasConfiguration, "reference:file:", " "));

    } catch (CoreException e) {
      Trace.trace(Trace.SEVERE, "Publishing failed", e);
    }
  }
Esempio n. 23
0
 public static void openFile(IWorkbenchPage page, IFile destinationFile, byte[] initialContent) {
   try {
     if (destinationFile != null) {
       // TODO: prompt to create the file ?  I say no, why would you try the shortcut if you didn't
       // want it created
       if (!destinationFile.exists()) {
         IPath fullPath = destinationFile.getLocation();
         if (fullPath.toFile().getParentFile().mkdirs()) {
           // create Eclipse resource so that the create file doesn't blow chunks
           destinationFile
               .getProject()
               .getFile(destinationFile.getParent().getProjectRelativePath())
               .refreshLocal(IFile.DEPTH_ZERO, null);
         }
         destinationFile.create(new ByteArrayInputStream(initialContent), false, null);
       }
       if (destinationFile.exists()) {
         IDE.openEditor(page, destinationFile);
       }
     }
   } catch (CoreException e) {
     String clazz = destinationFile.getName();
     System.err.println("OpenCakeFile can not open file: " + clazz);
     e.printStackTrace();
   }
 }
Esempio n. 24
0
 /** Initialize this index with information from the user libraries. */
 private boolean indexUserLibraries() {
   boolean librariesIndexed = true;
   try {
     AnalysisServer analysisServer = PackageLibraryManagerProvider.getDefaultAnalysisServer();
     SavedContext savedContext = analysisServer.getSavedContext();
     DartModel model = DartCore.create(ResourcesPlugin.getWorkspace().getRoot());
     for (DartProject project : model.getDartProjects()) {
       for (DartLibrary library : project.getDartLibraries()) {
         CompilationUnit compilationUnit = library.getDefiningCompilationUnit();
         if (compilationUnit == null) {
           continue;
         }
         IResource libraryResource = compilationUnit.getResource();
         if (libraryResource == null) {
           continue;
         }
         IPath libraryLocation = libraryResource.getLocation();
         if (libraryLocation == null) {
           continue;
         }
         File libraryFile = libraryLocation.toFile();
         savedContext.resolve(libraryFile, null);
       }
     }
   } catch (Exception exception) {
     librariesIndexed = false;
     DartCore.logError("Could not index user libraries", exception);
   }
   return librariesIndexed;
 }
  private void searchForRuntimes(
      List<RuntimeDefinition> runtimeCollector, IPath path, IProgressMonitor monitor) {

    File[] files = null;
    if (path != null) {
      File root = path.toFile();
      if (root.isDirectory()) files = new File[] {root};
      else return;
    } else files = File.listRoots();

    if (files != null) {
      int size = files.length;
      monitor.beginTask("Searching " + path.toOSString(), size * 100);
      int work = 100 / size;
      for (int i = 0; i < size; i++) {
        if (monitor.isCanceled()) return;
        if (files[i] != null && files[i].isDirectory())
          searchDirectory(files[i], runtimeCollector, DEPTH, new SubProgressMonitor(monitor, 80));
        monitor.worked(20);
      }
      monitor.done();
    } else {
      monitor.beginTask("Searching " + path.toOSString(), 1);
      monitor.worked(1);
      monitor.done();
    }
  }
Esempio n. 26
0
 /**
  * Copy the content in the directory with the given name located in the <code>test_data</code>
  * directory in the plug-in with the given id into the specified target directory.
  *
  * @param pluginId the id of the plug-in containing the project
  * @param projectName the name of the directory containing the project
  * @param targetDirectory the directory into which the content is copied. This directory is
  *     created if it does not already exist
  * @throws IOException if a required file cannot be accessed
  */
 public static void copyPluginRelativeContent(
     String pluginId, String projectName, File targetDirectory) throws IOException {
   URL pluginInstallUri = PluginUtilities.getInstallUrl(pluginId);
   URL sourceUrl = new URL(pluginInstallUri, PROJECT_DIRECTORY_NAME + "/" + projectName);
   IPath sourcePath = new Path(FileLocator.toFileURL(sourceUrl).getPath());
   FileUtilities.copyDirectoryContents(sourcePath.toFile(), targetDirectory);
 }
 /**
  * Test sample project with a virtual folder that points to configure scripts. Tests Bug 434275 -
  * Autotools configuration in subfolder not found
  *
  * @throws Exception
  */
 @Test
 public void testAutotoolsVirtualFolder() throws Exception {
   Path p = new Path("zip/project2.zip");
   IWorkspaceRoot root = ProjectTools.getWorkspaceRoot();
   IPath rootPath = root.getLocation();
   IPath configPath = rootPath.append("config");
   File configDir = configPath.toFile();
   configDir.deleteOnExit();
   assertTrue(configDir.mkdir());
   ProjectTools.createLinkedFolder(
       testProject, "src", URIUtil.append(root.getLocationURI(), "config"));
   ProjectTools.addSourceContainerWithImport(testProject, "src", p);
   assertTrue(testProject.hasNature(AutotoolsNewProjectNature.AUTOTOOLS_NATURE_ID));
   assertTrue(exists("src/ChangeLog"));
   ProjectTools.setConfigDir(testProject, "src");
   ProjectTools.markExecutable(testProject, "src/autogen.sh");
   assertFalse(exists("src/configure"));
   assertFalse(exists("src/Makefile.in"));
   assertFalse(exists("src/sample/Makefile.in"));
   assertFalse(exists("src/aclocal.m4"));
   assertTrue(ProjectTools.build());
   assertTrue(exists("src/configure"));
   assertTrue(exists("src/Makefile.in"));
   assertTrue(exists("src/sample/Makefile.in"));
   assertTrue(exists("src/aclocal.m4"));
   assertTrue(exists("config.status"));
   assertTrue(exists("Makefile"));
   String extension = Platform.getOS().equals(Platform.OS_WIN32) ? ".exe" : "";
   assertTrue(exists("sample/a.out" + extension));
   assertTrue(exists("sample/Makefile"));
 }
  public static IWorkbench getMockWorkbench(String file) {

    IWorkbench workbench = mock(IWorkbench.class);
    IWorkbenchWindow window = mock(IWorkbenchWindow.class);
    IWorkbenchPage page = mock(IWorkbenchPage.class);

    ITextEditor editor = mock(ITextEditor.class);

    IDocumentProvider docProvider = mock(IDocumentProvider.class);
    IDocument doc = mock(IDocument.class);

    IPath ipath = mock(IPath.class);
    File afile = mock(File.class);
    IFile inputFile = mock(IFile.class);

    IFileEditorInput editorInput = mock(IFileEditorInput.class);

    when(workbench.getWorkbenchWindows()).thenReturn(new IWorkbenchWindow[] {window});
    when(window.getActivePage()).thenReturn(page);
    when(page.getActiveEditor()).thenReturn(editor);

    when(editor.getEditorInput()).thenReturn(editorInput);
    when(editor.getDocumentProvider()).thenReturn(docProvider);

    when(editorInput.getFile()).thenReturn(inputFile);
    when(docProvider.getDocument(any())).thenReturn(doc);

    when(inputFile.getLocation()).thenReturn(ipath);
    when(inputFile.getName()).thenReturn(file);

    when(ipath.toFile()).thenReturn(afile);
    when(afile.length()).thenReturn(33l);

    return workbench;
  }
  /**
   * ************************************************************************ Get the database path
   * for this project
   *
   * @return ***********************************************************************
   */
  @SuppressWarnings("unchecked")
  public String getDatabasePath() {
    HashMap<QualifiedName, Object> properties = null;
    try {
      properties = new HashMap<QualifiedName, Object>(m_project.getPersistentProperties());
    } catch (CoreException e1) {
      System.err.println(
          "Cannot retrieve persistent properties for project " + m_project.getName());
      return null;
    }
    if (!properties.containsKey(ProjectDatabaseProperty.GCS_DATABASE.getKey())) {
      restoreProjectProperties(ProjectDatabaseProperty.GCS_DATABASE);
    }

    try {
      String path = m_project.getPersistentProperty(ProjectDatabaseProperty.GCS_DATABASE.getKey());
      // Relative path
      boolean absolute = true;
      if (!path.isEmpty()) {
        absolute = new File(path).isAbsolute();
      }
      if (!path.isEmpty() && !absolute) {
        IPath projAbsolute = m_project.getLocation();
        String projectPath = projAbsolute.toFile().getAbsolutePath();
        path = projectPath + File.separator + path;
      }
      return path;
    } catch (CoreException e) {
      return null;
    }
  }
Esempio n. 30
0
  /**
   * Remove xml files and zipFile.
   *
   * @param zipFile
   */
  private static void removeSendedFiles(File zipFile) {
    IPath pluginSaveFolder = FeedbackUtils.getFeedbackSaveFolder();
    java.io.File source = pluginSaveFolder.toFile();
    List<java.io.File> fileList = FileHelper.listAll(source);
    for (java.io.File f : fileList) {
      if (f.getName().endsWith(FeedbackUtils.END_FILE_NAME)) {
        f.delete();
      }
    }

    try {
      File.umount(true);
    } catch (ArchiveException e) {
      e.printStackTrace();
    }

    // Delete with trueZip function doesn't work
    java.io.File testFile = new java.io.File(source, FeedbackActivator.ZIP_FILE_NAME);
    if (testFile.exists()) {
      try {
        testFile.delete();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }