public String[] getServerIds() {
   List<String> list = new ArrayList<String>();
   for (IServer server : getServers()) {
     list.add(server.getId());
   }
   return list.toArray(new String[] {});
 }
  public void serverChanged(ServerEvent event) {
    final IServer server = event.getServer();
    JBossServer jbs =
        (JBossServer) server.loadAdapter(JBossServer.class, new NullProgressMonitor());
    if (jbs != null && serverSwitchesToState(event, IServer.STATE_STARTING)) {
      // do not launch console for remotes, for now
      String type = ServerProfileModel.getProfile(server);
      if (!ServerProfileModel.DEFAULT_SERVER_PROFILE.equals(type)) return;

      new Thread() {
        public void run() {
          try {
            // delay to insure the server gets a chance to actually launch
            Thread.sleep(3000);
          } catch (InterruptedException ie) {
          }
          Display.getDefault()
              .asyncExec(
                  new Runnable() {
                    public void run() {
                      ILaunch launch = server.getLaunch();
                      if (launch != null && launch.getProcesses().length > 0)
                        new ShowInConsoleAction(getNullSelectionProvider()).perform(server);
                    }
                  });
        }
      }.start();
    }
  }
Exemple #3
0
  /**
   * retrieve all needed information to connect to JMX server
   *
   * @param server
   * @return
   */
  public static String getJMXConnectionURL(IServer server) {
    String retVal = "";
    BaseConfigPropertyProvider manProv =
        new BaseConfigPropertyProvider(
            server
                .getRuntime()
                .getLocation()
                .append("etc")
                .append("org.apache.karaf.management.cfg")
                .toFile());
    BaseConfigPropertyProvider sysProv =
        new BaseConfigPropertyProvider(
            server.getRuntime().getLocation().append("etc").append("system.properties").toFile());

    String url = manProv.getConfigurationProperty("serviceUrl");
    if (url == null) return null;
    url = url.trim();
    int pos = -1;
    while ((pos = url.indexOf("${")) != -1) {
      retVal += url.substring(0, pos);
      String placeHolder = url.substring(url.indexOf("${") + 2, url.indexOf("}")).trim();
      String replacement = manProv.getConfigurationProperty(placeHolder);
      if (replacement == null) {
        replacement = sysProv.getConfigurationProperty(placeHolder);
      }
      if (replacement == null) {
        return null;
      } else {
        retVal += replacement.trim();
        url = url.substring(pos + placeHolder.length() + 3);
      }
    }
    return retVal;
  }
 public static DeployableServerBehavior getServerBehavior(ILaunchConfiguration configuration)
     throws CoreException {
   IServer server = ServerUtil.getServer(configuration);
   DeployableServerBehavior jbossServerBehavior =
       (DeployableServerBehavior) server.getAdapter(DeployableServerBehavior.class);
   return jbossServerBehavior;
 }
 public boolean stopServer(String serverId) {
   IServer server = getServer(serverId);
   if (server == null) return false;
   else {
     server.stop(false);
     return true;
   }
 }
 public static String[] getServerIdForProject(IProject project) {
   List<String> serverIds = new ArrayList<String>();
   IServer[] serversForProject = getServersForProject(project);
   for (IServer server : serversForProject) {
     serverIds.add(server.getId());
   }
   return serverIds.toArray(new String[] {});
 }
 private boolean hasURL() {
   IServer server = getServer();
   ServerExtendedProperties props =
       (ServerExtendedProperties)
           server.loadAdapter(ServerExtendedProperties.class, new NullProgressMonitor());
   if (props != null) return props.hasWelcomePage();
   return false;
 }
 public static ICarbonOperationManager getServerOperationManager(String serverId) {
   IServer server = getServer(serverId);
   if (getServerPlugin().containsKey(server.getServerType().getId()))
     return getServerPlugin().get(server.getServerType().getId());
   else {
     return null;
   }
 }
Exemple #9
0
 /**
  * @param server that associates to a {@link CloudFoundryServer}
  * @return non-null {@link CloudFoundryServer}
  * @throws CoreException if server is not a {@link CloudFoundryServer} or error occurred while
  *     resolving Cloud server
  */
 public static CloudFoundryServer getCloudServer(IServer server) throws CoreException {
   CloudFoundryServer cfServer = (CloudFoundryServer) server.getAdapter(CloudFoundryServer.class);
   if (cfServer == null) {
     throw CloudErrorUtil.toCoreException(
         NLS.bind(
             Messages.CloudServerUtil_NOT_CLOUD_SERVER_ERROR, server.getName(), server.getId()));
   }
   return cfServer;
 }
 public static IServer getRunningServer() {
   IServer server = null;
   for (IServer s : getServers()) {
     if (s.getServerState() == IServer.STATE_STARTED) {
       server = s;
       break;
     }
   }
   return server;
 }
  public void configureLaunch(final ILaunch launch) throws CoreException {
    final IServer server = ServerUtil.getServer(configuration);

    server.addServerListener(
        new IServerListener() {
          IModule[] modules = server.getModules();

          private boolean modulesChanged(IModule[] modules, IModule[] modules2) {
            if (CoreUtil.isNullOrEmpty(modules) && CoreUtil.isNullOrEmpty(modules2)) {
              return true;
            }

            if (CoreUtil.isNullOrEmpty(modules) || CoreUtil.isNullOrEmpty(modules2)) {
              return true;
            }

            if (modules.length != modules2.length) {
              return true;
            }

            for (int i = 0; i < modules.length; i++) {
              if (!modules[i].equals(modules2[i])) {
                return true;
              }
            }

            return false;
          }

          public synchronized void serverChanged(ServerEvent event) {
            if ((event.getKind() & ServerEvent.MODULE_CHANGE) > 0) {
              IModule[] newModules = event.getServer().getModules();

              if (modulesChanged(modules, newModules)) {
                try {
                  final PortalSourceLookupDirector director =
                      (PortalSourceLookupDirector) launch.getSourceLocator();
                  director.initializeDefaults(configuration);
                } catch (Exception e) {
                  LiferayServerCore.logError(
                      "Unable to update source containers for server", e); // $NON-NLS-1$
                }

                modules = newModules;
              }
            }
          }
        });

    final ISourcePathComputer sourcePathComputer =
        getLaunchManager().getSourcePathComputer(this.sourceComputerId);
    this.setSourcePathComputer(sourcePathComputer);
    this.initializeDefaults(configuration);
    launch.setSourceLocator(this);
  }
 public static IServer[] getServersForProject(IProject project) {
   List<IServer> serverIds = new ArrayList<IServer>();
   for (IServer server : getServers()) {
     for (IModule module : server.getModules()) {
       if (module.getProject() == project) {
         serverIds.add(server);
       }
     }
   }
   return serverIds.toArray(new IServer[] {});
 }
 @Test
 public void shouldStopRunningServerWhenStoppingBundler() throws Exception {
   // pre-condition: create a first server (no need for script injection)
   createAndLaunchLiveReloadServer("Server 1", false);
   assertThat(liveReloadServer.getServerState()).isEqualTo(IServer.STATE_STARTED);
   // operation: stop the core bundle
   JBossLiveReloadCoreActivator.getDefault()
       .stop(JBossLiveReloadCoreActivator.getDefault().getBundle().getBundleContext());
   // verification
   assertThat(liveReloadServer.getServerState()).isEqualTo(IServer.STATE_STOPPED);
 }
 public void serverChanged(ServerEvent event) {
   IServer s = event.getServer();
   JBossExtendedProperties props =
       (JBossExtendedProperties) s.loadAdapter(JBossExtendedProperties.class, null);
   if (props != null
       && props.getMultipleDeployFolderSupport()
           == ServerExtendedProperties.DEPLOYMENT_SCANNER_AS7_MANAGEMENT_SUPPORT) {
     if (serverSwitchesToState(event, IServer.STATE_STARTED)) {
       // Don't do any potentially long-running tasks here.
       launchJob(s);
     }
   }
 }
  public void waitModuleStarted(IServer server, IModule[] module, IProgressMonitor monitor) {
    if (module.length == 0 || module[0] == null) return;

    try {
      String deploymentName = getDeploymentName(server, module[0]);
      boolean waitedOnce = false;

      while (!monitor.isCanceled()) {
        boolean done = isRootModuleStarted(server, module[0], deploymentName, monitor);
        if (done) {
          return;
        }
        if (!waitedOnce) {
          String info = "Module {0} on {1} not yet fully deployed. Waiting..."; // $NON-NLS-1$
          IStatus s =
              new Status(
                  IStatus.INFO,
                  JBossServerCorePlugin.PLUGIN_ID,
                  NLS.bind(info, module[0].getName(), server.getName()),
                  null);
          ServerLogger.getDefault().log(server, s);
        }
        waitedOnce = true;
        try {
          Thread.sleep(2000);
        } catch (InterruptedException ie) {
          // Ignore, intentional
        }
      }

      String warning =
          "Module {0} on {1} still not ready to be shown in browser. Aborting delay."; //$NON-NLS-1$
      IStatus s =
          new Status(
              IStatus.WARNING,
              JBossServerCorePlugin.PLUGIN_ID,
              NLS.bind(warning, module[0].getName(), server.getName()),
              null);
      ServerLogger.getDefault().log(server, s);
    } catch (Exception e) {
      String er = "Error occurred while waiting for {0} to start on server {1}"; // $NON-NLS-1$
      IStatus s =
          new Status(
              IStatus.WARNING,
              JBossServerCorePlugin.PLUGIN_ID,
              NLS.bind(er, module[0].getName(), server.getName()),
              e);
      ServerLogger.getDefault().log(server, s);
    }
  }
 @Test
 public void testMetadata() {
   try {
     IServer s = ServerCreationTestUtils.createMockServerWithRuntime(serverType, serverType);
     IServerWorkingCopy wc = s.createWorkingCopy();
     wc.setAttribute(IDeployableServer.DEPLOY_DIRECTORY_TYPE, IDeployableServer.DEPLOY_METADATA);
     s = wc.save(true, null);
     String[] folders = getAdditions().getDeployLocationFolders(s);
     assertEquals(1, folders.length);
     assertTrue(folders[0].contains("metadata"));
   } catch (CoreException ce) {
     fail("Unable to save changes to server");
   }
 }
Exemple #17
0
 public SshConnector(IServer server) {
   super();
   this.server = server;
   this.behaviorDelegate =
       (IControllableServerBehavior)
           server.loadAdapter(IControllableServerBehavior.class, new NullProgressMonitor());
   IKarafServerDelegate config =
       (IKarafServerDelegate)
           server.loadAdapter(IKarafServerDelegate.class, new NullProgressMonitor());
   this.host = server.getHost();
   this.port = config.getPortNumber();
   this.userName = config.getUserName();
   this.passwd = config.getPassword();
 }
  @Test
  public void testMetadataWithCustomModule() {
    try {
      // Create the server
      IServer s = ServerCreationTestUtils.createMockServerWithRuntime(serverType, serverType);
      IServerWorkingCopy wc = s.createWorkingCopy();
      wc.setAttribute(IDeployableServer.DEPLOY_DIRECTORY_TYPE, IDeployableServer.DEPLOY_METADATA);
      s = wc.save(true, null);

      // Create the project
      projNum++;
      String projName = "Project" + projNum;
      IDataModel dm =
          CreateProjectOperationsUtility.getWebDataModel(
              projName, null, null, null, null, JavaEEFacetConstants.WEB_24, false);
      try {
        OperationTestCase.runAndVerify(dm);
      } catch (Exception e) {
        fail("Unable to create test web project: " + e.getMessage());
      }
      IProject p = ResourceUtils.findProject(projName);
      assertTrue(p.exists());
      IModule projMod = ServerUtil.getModule(p);

      // Set the custom setting. For now, just override output name
      wc = s.createWorkingCopy();
      AbstractPublishingTest.setCustomDeployOverride(wc, projMod, "newName.war", null, null);
      s = wc.save(true, null);

      // verify no change vs standard metadata
      String[] folders = getAdditions().getDeployLocationFolders(s);
      assertEquals(1, folders.length);
      assertTrue(folders[0].contains("metadata"));

      // Change it to now make some other output folder
      wc = s.createWorkingCopy();
      AbstractPublishingTest.setCustomDeployOverride(
          wc, projMod, "newName.war", "/home/user/deploy", null);
      s = wc.save(true, null);
      folders = getAdditions().getDeployLocationFolders(s);
      assertEquals(2, folders.length);
      assertTrue(folders[0].contains("metadata"));
      assertTrue(folders[1].equals("/home/user/deploy"));

    } catch (CoreException ce) {
      fail("Unable to save changes to server");
    }
  }
Exemple #19
0
  /**
   * Returns list of cloud foundry server instances. May be emtpy, but not null.
   *
   * @return returns a non-null list of cloud foundry server instances. May be empty.
   */
  public static List<CloudFoundryServer> getCloudServers() {
    IServer[] servers = ServerCore.getServers();
    Set<CloudFoundryServer> matchedServers = new HashSet<CloudFoundryServer>();

    if (servers != null) {
      for (IServer server : servers) {
        CloudFoundryServer cfServer =
            (CloudFoundryServer) server.loadAdapter(CloudFoundryServer.class, null);
        if (cfServer != null) {
          matchedServers.add(cfServer);
        }
      }
    }

    return new ArrayList<CloudFoundryServer>(matchedServers);
  }
  public static ILiferayRuntime getLiferayRuntime(IServer server) {
    if (server != null) {
      return getLiferayRuntime(server.getRuntime());
    }

    return null;
  }
Exemple #21
0
  public static IRemoteServer getRemoteServer(IServer server) {
    if (server != null) {
      return (IRemoteServer) server.loadAdapter(IRemoteServer.class, null);
    }

    return null;
  }
  private boolean hasParentInServer(IProject project, IServer server, IProgressMonitor pm) {
    IModule[] modules = ServerUtil.getModules(project);
    if (modules == null || modules.length == 0) {
      return false;
    }
    IModule[] parents = null;
    boolean parentFound = false;
    for (IModule module : modules) {
      try {
        parents = server.getRootModules(module, pm);
      } catch (CoreException e) {
        org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
      }

      if (parents == null || parents.length == 0) {
        return false;
      }
      for (IModule parent : parents) {
        if (!parent.equals(module) && ServerUtil.containsModule(server, parent, pm)) {
          parentFound = true;
          break;
        }
      }
    }
    return parentFound;
  }
Exemple #23
0
  /**
   * @param serverID unique ID of the server. This should not just be the name of the server, but
   *     the full id (e.g. for V2, it should include the space name)
   * @return CloudFoundry server that corresponds to the given ID, or null if not found
   */
  public static CloudFoundryServer getCloudServer(String serverID) {
    IServer[] servers = ServerCore.getServers();
    if (servers == null) {
      return null;
    }
    CloudFoundryServer cfServer = null;

    for (IServer server : servers) {
      cfServer = (CloudFoundryServer) server.loadAdapter(CloudFoundryServer.class, null);

      if (cfServer != null && cfServer.getServerId().equals(serverID)) {
        break;
      }
    }
    return cfServer;
  }
 private void startProxy(final IServer startedServer) {
   // re-start exiting proxy id already exist
   if (proxyServers.containsKey(startedServer)) {
     final LiveReloadProxyServer proxyServer = proxyServers.get(startedServer);
     try {
       proxyServer.start();
     } catch (Exception e) {
       Logger.error(
           "Failed to start LiveReload Proxy on port "
               + proxyServer.getConnectors()[0].getPort()
               + " for server "
               + startedServer.getName(),
           e);
     }
   }
   // create a new proxy
   else {
     final int targetPort = WSTUtils.getWebPort(startedServer);
     if (targetPort != -1) {
       try {
         // now, let's init and start the embedded jetty proxy server
         // from the
         // server attributes
         final boolean allowRemoteConnections = isRemoteConnectionsAllowed();
         final boolean enableScriptInjection = isScriptInjectionEnabled();
         final String proxyHost = getProxyHost();
         final int proxyPort = getProxyPort(startedServer);
         final LiveReloadProxyServer proxyServer =
             new LiveReloadProxyServer(
                 proxyHost,
                 proxyPort,
                 startedServer.getHost(),
                 targetPort,
                 websocketPort,
                 allowRemoteConnections,
                 enableScriptInjection);
         proxyServers.put(startedServer, proxyServer);
         final JettyServerRunner proxyRunner = JettyServerRunner.start(proxyServer);
         proxyRunners.put(startedServer, proxyRunner);
       } catch (Exception e) {
         Logger.error(
             "Failed to create or start LiveReload proxy for server " + startedServer.getName(),
             e);
       }
     }
   }
 }
 public void execute() throws BuildException {
   IWorkspace workspace = ResourcesPlugin.getWorkspace();
   final IProject project = workspace.getRoot().getProject(projectname);
   try {
     IServer server = WebDSLProjectBuilder.getProjectServer(project, null);
     if (server == null) {
       System.out.println("module is currently not in server, cannot remove it");
     } else {
       System.out.println("Removing server module for project: " + projectname);
       removeProjectModuleFromServer(project, server, null);
       System.out.println("Stop server.");
       server.stop(true);
     }
   } catch (CoreException e) {
     e.printStackTrace();
   }
 }
  private IProject getProject(IServer server) {
    IModule[] modules = server.getModules();
    if (modules == null || modules.length == 0) {
      return null;
    }

    return modules[0].getProject();
  }
  public static IServer[] getServersForRuntime(IRuntime runtime) {
    List<IServer> serverList = new ArrayList<IServer>();

    if (runtime != null) {
      IServer[] servers = ServerCore.getServers();

      if (!CoreUtil.isNullOrEmpty(servers)) {
        for (IServer server : servers) {
          if (runtime.equals(server.getRuntime())) {
            serverList.add(server);
          }
        }
      }
    }

    return serverList.toArray(new IServer[0]);
  }
  @Override
  public Object execute(ExecutionEvent event) throws ExecutionException {
    try {
      Liferay7UpgradeAssistantSettings settings =
          UpgradeAssistantSettingsUtil.getObjectFromStore(Liferay7UpgradeAssistantSettings.class);

      final String portalName = settings.getPortalSettings().getNewName();

      IServer server = ServerCore.findServer(portalName);

      server.start("run", new NullProgressMonitor());
    } catch (IOException | CoreException e) {
      e.printStackTrace();
    }

    return null;
  }
 private IModule getWebModule(IModule[] m) {
   if (m.length > 0) {
     IModule module = m[m.length - 1];
     if (isWebModule(module)) {
       return module;
     } else {
       IServer s = getServer();
       IModule[] mms = s.getChildModules(m, null);
       for (IModule child : mms) {
         if (isWebModule(child)) {
           return child;
         }
       }
     }
   }
   return null;
 }
 public static boolean waitUntilTheServerStarts(IServer server, Shell shell) {
   return waitForServerToChangeState(
       server,
       shell,
       IServer.STATE_STOPPED,
       IServer.STATE_STARTED,
       "Starting WSAS Server " + server.getId() + "...");
 }