public void testSingleModuleUpdateExternalCreation() throws Exception {

    String prefix = "testSingleModuleUpdateExternalCreation";
    String appName = harness.getDefaultWebAppName(prefix);

    // After deployment the module must exist and be mapped to an existing
    // CloudApplication
    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(appName);
    assertNull(appModule);

    appModule = serverBehavior.updateCloudModule(appName, new NullProgressMonitor());
    assertNull(appModule);

    // Create separate external client
    CloudFoundryOperations client = harness.createExternalClient();
    client.login();

    List<String> urls = new ArrayList<String>();
    urls.add(harness.getExpectedDefaultURL(prefix));
    client.createApplication(
        appName, new Staging(), CloudUtil.DEFAULT_MEMORY, urls, new ArrayList<String>());

    appModule = serverBehavior.updateCloudModule(appName, new NullProgressMonitor());

    assertEquals(appName, appModule.getDeployedApplicationName());
    assertEquals(appModule.getDeployedApplicationName(), appModule.getApplication().getName());
    assertEquals(CloudUtil.DEFAULT_MEMORY, appModule.getApplication().getMemory());
    assertEquals(appModule.getDeploymentInfo().getMemory(), appModule.getApplication().getMemory());
  }
  public void testUpdateModulesServerBehaviourWrongCloudApp() throws Exception {
    // Update modules API in behaviour will return a
    // CloudFoundryApplicationModule for an existing Cloud application in
    // the Cloud Space. This associated update modules for the Cloud Foundry
    // Server
    // which the behaviour uses is tested separately in a different test
    // case
    String prefix = "testUpdateModulesServerBehaviourWrongCloudApp";
    String expectedAppName = harness.getDefaultWebAppName(prefix);

    // Create the app externally AFTER the server connects in the setup to
    // ensure the tools did not pick up the Cloud application during refresh
    CloudFoundryOperations client = harness.createExternalClient();
    client.login();

    List<String> urls = new ArrayList<String>();
    urls.add(harness.getExpectedDefaultURL(prefix));
    client.createApplication(
        expectedAppName, new Staging(), CloudUtil.DEFAULT_MEMORY, urls, new ArrayList<String>());

    // The tool has not refreshed after the app was created with an external
    // client, so there should be no module
    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(expectedAppName);
    assertNull(appModule);

    CloudFoundryApplicationModule wrongModule =
        serverBehavior.updateCloudModule("wrongApp", new NullProgressMonitor());
    assertNull(wrongModule);

    wrongModule =
        serverBehavior.updateCloudModuleWithInstances("wrongApp", new NullProgressMonitor());
    assertNull(wrongModule);
  }
  public void testUpdateModuleInstances() throws Exception {
    // Update modules API in behaviour will return a
    // CloudFoundryApplicationModule for an existing Cloud application in
    // the Cloud Space. This associated update modules for the Cloud Foundry
    // Server
    // which the behaviour uses is tested separately in a different test
    // case

    String prefix = "testUpdateModuleInstances";
    String expectedAppName = harness.getDefaultWebAppName(prefix);

    // Create the app externally AFTER the server connects in the setup to
    // ensure the tools did not pick up the Cloud application during refresh
    CloudFoundryOperations client = harness.createExternalClient();
    client.login();

    List<String> urls = new ArrayList<String>();
    urls.add(harness.getExpectedDefaultURL(prefix));
    client.createApplication(
        expectedAppName, new Staging(), CloudUtil.DEFAULT_MEMORY, urls, new ArrayList<String>());

    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(expectedAppName);
    // Tooling has not yet been updated so there is no corresponding
    // appModule even though the app exists in the Cloud space
    assertNull(appModule);

    // This will tell the behaviour to fetch the Cloud application from the
    // Cloud space and generate a module
    CloudFoundryApplicationModule updateModule =
        serverBehavior.updateCloudModuleWithInstances(expectedAppName, new NullProgressMonitor());
    assertEquals(expectedAppName, updateModule.getDeployedApplicationName());
    assertEquals(
        updateModule.getDeployedApplicationName(), updateModule.getApplication().getName());

    // Check the mapping is correct
    assertEquals(updateModule.getName(), updateModule.getApplication().getName());
    assertEquals(CloudUtil.DEFAULT_MEMORY, updateModule.getApplication().getMemory());
    assertEquals(
        updateModule.getDeploymentInfo().getMemory(), updateModule.getApplication().getMemory());
    assertEquals(1, updateModule.getInstanceCount());

    // There is one instance, but since the app was created EXTERNALLY and
    // not started, there should
    // be no instance info
    assertEquals(0, updateModule.getApplicationStats().getRecords().size());
    assertNull(updateModule.getInstancesInfo());

    updateModule =
        serverBehavior.updateCloudModuleWithInstances((String) null, new NullProgressMonitor());
    assertNull(updateModule);

    updateModule =
        serverBehavior.updateCloudModuleWithInstances("wrongName", new NullProgressMonitor());
    assertNull(updateModule);

    updateModule =
        serverBehavior.updateCloudModuleWithInstances((IModule) null, new NullProgressMonitor());
    assertNull(updateModule);
  }
  public void testAllModuleUpdateExternalAppDeletion() throws Exception {

    String prefix = "testAllModuleUpdateExternalAppDeletion";
    String appName = harness.getDefaultWebAppName(prefix);
    IProject project = createWebApplicationProject();

    boolean stopMode = false;

    // Configure the test fixture for deployment.
    // This step is a substitute for the Application deployment wizard
    getTestFixture().configureForApplicationDeployment(appName, CloudUtil.DEFAULT_MEMORY, stopMode);

    IModule module = getModule(project.getName());

    // Push the application.
    cloudServer
        .getBehaviour()
        .operations()
        .applicationDeployment(new IModule[] {module}, ApplicationAction.PUSH)
        .run(new NullProgressMonitor());

    // After deployment the module must exist and be mapped to an existing
    // CloudApplication
    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(appName);

    // Verify the module exists
    assertEquals(appModule.getDeployedApplicationName(), appModule.getApplication().getName());

    // Delete module externally and verify that module refresh picks up the
    // change

    // Create separate external client
    CloudFoundryOperations client = harness.createExternalClient();
    client.login();
    client.deleteApplication(appName);

    // Update through all-modules update, and also verify existing modules
    // matches results
    Map<String, CloudApplication> allApps = new HashMap<String, CloudApplication>();
    cloudServer.updateModules(allApps);

    appModule = cloudServer.getExistingCloudModule(appName);
    assertNull(appModule);

    // Update through single-module update, and also verify that existing
    // modules matches the results
    appModule = serverBehavior.updateCloudModule(appName, new NullProgressMonitor());
    assertNull(appModule);

    appModule = cloudServer.getExistingCloudModule(appName);
    assertNull(appModule);
  }
  public void testModuleRefreshDuringServerConnect2() throws Exception {
    // Deploy and start an application.
    // Disconnect through the server behaviour. Verify through an external
    // client that the app
    // remains deployed and in started mode.
    // Reconnect, and verify that the application is still running (i.e.
    // disconnecting
    // the server should not stop the application).

    String appPrefix = "testModuleRefreshDuringServerConnect2";
    String expectedAppName = harness.getDefaultWebAppName(appPrefix);

    createWebApplicationProject();

    // Note that deploying application fires off an app change event AFTER
    // the deployment is
    // successful. To make sure that the second event listener further down
    // does not accidentally receive the app
    // change event,
    // wait for the app change event from the deploy first, and then
    // schedule the second listener to
    // listen to the expected refresh event
    deployAndWaitForDeploymentEvent(appPrefix);

    // Cloud module should have been created.
    Collection<CloudFoundryApplicationModule> appModules = cloudServer.getExistingCloudModules();
    assertEquals(
        harness.getDefaultWebAppName(appPrefix),
        appModules.iterator().next().getDeployedApplicationName());

    // Disconnect and verify that there are no cloud foundry application
    // modules
    serverBehavior.disconnect(new NullProgressMonitor());
    appModules = cloudServer.getExistingCloudModules();
    assertTrue(
        "Expected empty list of cloud application modules after server disconnect",
        appModules.isEmpty());

    // Now create an external client to independently check that the
    // application remains deployed and in started mode

    CloudFoundryOperations client = harness.createExternalClient();
    client.login();
    List<CloudApplication> deployedApplications = client.getApplications();
    assertEquals(
        "Expected 1 Cloud application in Cloud space after server disconnect",
        1,
        deployedApplications.size());
    assertEquals(expectedAppName, deployedApplications.get(0).getName());
    assertTrue(deployedApplications.get(0).getState() == AppState.STARTED);

    // Register a module refresh listener before connecting again to be
    // notified when
    // modules are refreshed
    ModulesRefreshListener listener =
        getModulesRefreshListener(null, cloudServer, CloudServerEvent.EVENT_SERVER_REFRESHED);

    serverBehavior.connect(new NullProgressMonitor());

    assertModuleRefreshedAndDispose(listener, CloudServerEvent.EVENT_SERVER_REFRESHED);

    appModules = cloudServer.getExistingCloudModules();
    CloudFoundryApplicationModule appModule = appModules.iterator().next();

    assertEquals(expectedAppName, appModule.getDeployedApplicationName());

    assertApplicationIsRunning(appModule);
  }
  public void testModuleUpdatesExternalChanges() throws Exception {

    // Tests various module update scenarios due to external changes.
    // This is performed in one test to avoid multiple application creations
    // and deployments during junit setups which are slow
    // Tests the following cases:
    // 1. Push application for the first time - Module should be created and
    // mapped to a CloudApplication
    // 2. Update the application externally and update through behaviour API
    // - Module and mapping to CloudApplication should be updated
    // 3. Update the application externally and refresh all Modules - Module
    // and mapping to CloudApplication should be updated.

    String prefix = "testModuleUpdatesExternalChanges";
    String appName = harness.getDefaultWebAppName(prefix);
    IProject project = createWebApplicationProject();

    boolean stopMode = false;

    // Configure the test fixture for deployment.
    // This step is a substitute for the Application deployment wizard
    getTestFixture().configureForApplicationDeployment(appName, CloudUtil.DEFAULT_MEMORY, stopMode);

    IModule module = getModule(project.getName());

    // Push the application
    cloudServer
        .getBehaviour()
        .operations()
        .applicationDeployment(new IModule[] {module}, ApplicationAction.PUSH)
        .run(new NullProgressMonitor());

    // After deployment the module must exist and be mapped to an existing
    // CloudApplication
    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(appName);

    assertNotNull(appModule);
    // Test that the mapping to the actual application in the Cloud space is
    // present. Since a
    // CloudApplication is not created by the underlying client unless it
    // exists, this also
    // indirectly tests that the CloudApplication was successfully created
    // indicating the application
    // exists in the Cloud space.
    assertNotNull(appModule.getApplication());
    assertEquals(appModule.getDeployedApplicationName(), appModule.getApplication().getName());

    // To test update on external changes, verify the current memory
    assertEquals(CloudUtil.DEFAULT_MEMORY, appModule.getDeploymentInfo().getMemory());

    // Verify that the CloudApplication in the Cloud space exists through
    // the list of all CloudApplications
    List<CloudApplication> applications = serverBehavior.getApplications(new NullProgressMonitor());
    boolean found = false;

    for (CloudApplication application : applications) {
      if (application.getName().equals(appName)) {
        found = true;
        break;
      }
    }
    assertTrue("Expected CloudApplication for " + appName + " to exist in the Cloud space", found);

    // Now modify the application externally and verify that when performing
    // a module update
    // that the new changes are picked up by the tooling

    // Create separate external client
    CloudFoundryOperations externalClient = harness.createExternalClient();
    externalClient.login();

    // Refresh Module through behaviour to check if it picks up changes

    // 1. Test via single-module update
    externalClient.updateApplicationMemory(appName, 737);
    CloudApplication updatedCloudApplicationFromClient = externalClient.getApplication(appName);

    appModule = serverBehavior.updateCloudModule(appName, new NullProgressMonitor());

    assertEquals(appName, appModule.getDeployedApplicationName());
    assertEquals(
        appModule.getDeployedApplicationName(), updatedCloudApplicationFromClient.getName());
    assertEquals(737, updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getApplication().getMemory(), updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getDeploymentInfo().getMemory(), updatedCloudApplicationFromClient.getMemory());

    // 2. Test via single-module update and it's instances
    externalClient.updateApplicationMemory(appName, 555);

    updatedCloudApplicationFromClient = externalClient.getApplication(appName);
    appModule = serverBehavior.updateCloudModuleWithInstances(appName, new NullProgressMonitor());

    assertEquals(appName, appModule.getDeployedApplicationName());
    assertEquals(
        appModule.getDeployedApplicationName(), updatedCloudApplicationFromClient.getName());

    assertEquals(
        appModule.getDeployedApplicationName(), updatedCloudApplicationFromClient.getName());
    assertEquals(555, updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getApplication().getMemory(), updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getDeploymentInfo().getMemory(), updatedCloudApplicationFromClient.getMemory());

    // 3. Test via module refresh of all modules
    externalClient.updateApplicationMemory(appName, 345);
    updatedCloudApplicationFromClient = externalClient.getApplication(appName);
    Map<String, CloudApplication> allApps = new HashMap<String, CloudApplication>();
    allApps.put(updatedCloudApplicationFromClient.getName(), updatedCloudApplicationFromClient);

    cloudServer.updateModules(allApps);

    appModule = cloudServer.getExistingCloudModule(appName);

    assertEquals(appName, appModule.getDeployedApplicationName());
    assertEquals(
        appModule.getDeployedApplicationName(), updatedCloudApplicationFromClient.getName());

    assertEquals(
        appModule.getDeployedApplicationName(), updatedCloudApplicationFromClient.getName());
    assertEquals(345, updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getApplication().getMemory(), updatedCloudApplicationFromClient.getMemory());
    assertEquals(
        appModule.getDeploymentInfo().getMemory(), updatedCloudApplicationFromClient.getMemory());
  }
  public void testUpdateModulesCloudServer() throws Exception {

    // Tests the Update modules API in the server that will CREATE or return
    // an existing
    // CloudFoundryApplicationModule ONLY if it is given a CloudApplication.

    String prefix = "testUpdateModulesCloudServer";
    String expectedAppName = harness.getDefaultWebAppName(prefix);

    // Create the app externally AFTER the server connects in the setup to
    // ensure the tools did not pick up the Cloud application during refresh
    CloudFoundryOperations client = harness.createExternalClient();
    client.login();

    List<String> urls = new ArrayList<String>();
    urls.add(harness.getExpectedDefaultURL(prefix));
    client.createApplication(
        expectedAppName, new Staging(), CloudUtil.DEFAULT_MEMORY, urls, new ArrayList<String>());

    CloudFoundryApplicationModule appModule = cloudServer.getExistingCloudModule(expectedAppName);
    // Tooling has not yet been updated so there is no corresponding
    // appModule even though the app exists in the Cloud space
    assertNull(appModule);

    // No actual cloud application passed to update therefore no associated
    // CloudFoundryApplicationModule should be found
    appModule = cloudServer.updateModule(null, expectedAppName, new NullProgressMonitor());
    assertNull(appModule);

    appModule = cloudServer.updateModule(null, null, new NullProgressMonitor());
    assertNull(appModule);

    assertTrue(cloudServer.getExistingCloudModules().isEmpty());

    // Get the actual cloud app directly from the Cloud space
    CloudApplication actualApp = client.getApplications().get(0);

    // Now create the CloudFoundryApplicationModule
    appModule = cloudServer.updateModule(actualApp, expectedAppName, new NullProgressMonitor());

    assertEquals(expectedAppName, appModule.getDeployedApplicationName());
    assertEquals(appModule.getDeployedApplicationName(), appModule.getApplication().getName());

    // Check the mapping is correct
    assertEquals(actualApp.getName(), appModule.getApplication().getName());

    assertEquals(CloudUtil.DEFAULT_MEMORY, appModule.getApplication().getMemory());
    assertEquals(appModule.getDeploymentInfo().getMemory(), appModule.getApplication().getMemory());

    // It should match what is obtained through getExisting API
    CloudFoundryApplicationModule existingCloudMod =
        cloudServer.getExistingCloudModule(expectedAppName);

    assertEquals(expectedAppName, existingCloudMod.getDeployedApplicationName());
    assertEquals(
        existingCloudMod.getDeployedApplicationName(), existingCloudMod.getApplication().getName());

    // Check the mapping is correct
    assertEquals(actualApp.getName(), existingCloudMod.getApplication().getName());

    assertEquals(CloudUtil.DEFAULT_MEMORY, existingCloudMod.getApplication().getMemory());
    assertEquals(
        existingCloudMod.getDeploymentInfo().getMemory(),
        existingCloudMod.getApplication().getMemory());

    // Check the other existing Modules API
    CloudFoundryApplicationModule sameExistingApp =
        cloudServer.getExistingCloudModules().iterator().next();
    assertEquals(expectedAppName, sameExistingApp.getDeployedApplicationName());
    assertEquals(
        sameExistingApp.getDeployedApplicationName(), sameExistingApp.getApplication().getName());

    // Check the mapping is correct
    assertEquals(actualApp.getName(), sameExistingApp.getApplication().getName());

    assertEquals(CloudUtil.DEFAULT_MEMORY, sameExistingApp.getApplication().getMemory());
    assertEquals(
        sameExistingApp.getDeploymentInfo().getMemory(),
        sameExistingApp.getApplication().getMemory());
  }
コード例 #8
0
  @Override
  protected void pushApplication(
      CloudFoundryOperations client,
      final CloudFoundryApplicationModule appModule,
      ApplicationArchive applicationArchive,
      final IProgressMonitor monitor)
      throws CoreException {
    String appName = appModule.getDeploymentInfo().getDeploymentName();

    CloudApplication existingApp = null;

    try {
      existingApp = getBehaviour().getCloudApplication(appName, monitor);
    } catch (CoreException ce) {
      if (!CloudErrorUtil.isNotFoundException(ce)) {
        throw ce;
      }
    }

    // Create the application if it doesn't already exist
    if (existingApp == null) {
      String creatingAppLabel = NLS.bind(Messages.CONSOLE_APP_CREATION, appName);
      getBehaviour().printlnToConsole(appModule, creatingAppLabel);

      // BUG - [87862532]: Fetch all the information BEFORE
      // creating the application. The reason for this
      // is to prevent any other operation that updates the module from
      // clearing the deploymentinfo after the application is created
      // but before other properties are updated like environment
      // variables
      // and instances
      Staging staging = appModule.getDeploymentInfo().getStaging();
      List<String> uris =
          appModule.getDeploymentInfo().getUris() != null
              ? appModule.getDeploymentInfo().getUris()
              : new ArrayList<String>(0);
      List<String> services = appModule.getDeploymentInfo().asServiceBindingList();
      List<EnvironmentVariable> variables = appModule.getDeploymentInfo().getEnvVariables();
      int instances = appModule.getDeploymentInfo().getInstances();

      if (staging == null) {
        // For v2, a non-null staging is required.
        staging = new Staging();
      }
      CoreException cloudAppCreationClientError = null;

      // Guard against host taken errors and other errors that may
      // create the app but
      // prevent further deployment. If the app was still created
      // attempt to set env vars and instaces
      SubMonitor subMonitor = SubMonitor.convert(monitor, 50);
      subMonitor.subTask(creatingAppLabel);
      try {
        client.createApplication(
            appName, staging, appModule.getDeploymentInfo().getMemory(), uris, services);
      } catch (Exception e) {
        String hostTaken = CloudErrorUtil.getHostTakenError(e);
        if (hostTaken != null) {
          cloudAppCreationClientError = CloudErrorUtil.toCoreException(hostTaken);
        } else {
          cloudAppCreationClientError = CloudErrorUtil.toCoreException(e);
        }
      }

      subMonitor.worked(30);

      // [87881946] - Try setting the env vars and instances even if an
      // error was thrown while creating the application
      // as the application may still have been created in the Cloud space
      // in spite of the error
      try {
        CloudApplication actualApp =
            getBehaviour().getCloudApplication(appName, subMonitor.newChild(20));

        if (actualApp != null) {
          SubMonitor updateMonitor = SubMonitor.convert(subMonitor, 100);
          getBehaviour()
              .getRequestFactory()
              .getUpdateEnvVarRequest(appName, variables)
              .run(updateMonitor.newChild(50));

          // Update instances if it is more than 1. By default, app
          // starts
          // with 1 instance.

          if (instances > 1) {
            getBehaviour()
                .updateApplicationInstances(appName, instances, updateMonitor.newChild(50));
          } else {
            updateMonitor.worked(50);
          }
        }
      } catch (CoreException ce) {
        if (cloudAppCreationClientError == null) {
          throw ce;
        }
      }

      // Even if application was created in the Cloud space, and env vars
      // and instances set, if an exception
      // was thrown while creating the client, throw it
      if (cloudAppCreationClientError != null) {
        throw cloudAppCreationClientError;
      }
    }
    super.pushApplication(client, appModule, applicationArchive, monitor);
  }