예제 #1
0
 public void start(ResourceContext<PlatformComponent> resourceContext) {
   if (resourceContext.getSystemInformation().isNative()) {
     cpuInformation =
         resourceContext
             .getSystemInformation()
             .getCpu(Integer.parseInt(resourceContext.getResourceKey()));
     cpuCache = new HashMap<String, CpuEntry>();
     startCpuEntry = new CpuEntry(cpuInformation.getCpu());
   }
   return;
 }
예제 #2
0
 /** Start the resource connection */
 @Override
 public void start(ResourceContext<CacheManagerComponent> context) {
   this.context = context;
   this.cacheManagerName = context.getParentResourceComponent().context.getResourceKey();
   this.cacheName = context.getResourceKey();
   if (log.isTraceEnabled())
     log.trace(
         "Start cache component for cache manager "
             + cacheManagerName
             + " with cache key "
             + cacheName);
 }
예제 #3
0
 protected void internalStart() throws Exception {
   Configuration pluginConfig = context.getPluginConfiguration();
   String connectionTypeDescriptorClassName =
       pluginConfig.getSimple(JMXDiscoveryComponent.CONNECTION_TYPE).getStringValue();
   if (JMXDiscoveryComponent.PARENT_TYPE.equals(connectionTypeDescriptorClassName)) {
     // Our parent is itself a JMX component, so just reuse its connection.
     this.connection = ((JMXComponent) context.getParentResourceComponent()).getEmsConnection();
     this.connectionProvider = this.connection.getConnectionProvider();
   } else {
     this.connectionProvider =
         ConnectionProviderFactory.createConnectionProvider(
             pluginConfig, this.context.getNativeProcess(), this.context.getTemporaryDirectory());
     this.connection = this.connectionProvider.connect();
     this.connection.loadSynchronous(false);
   }
 }
예제 #4
0
  public Configuration loadResourceConfiguration() throws Exception {

    ConfigurationDefinition configDef =
        context.getResourceType().getResourceConfigurationDefinition();
    ConfigurationLoadDelegate delegate =
        new ConfigurationLoadDelegate(configDef, connection, address);
    return delegate.loadResourceConfiguration();
  }
예제 #5
0
  public void updateResourceConfiguration(ConfigurationUpdateReport report) {

    ConfigurationDefinition configDef =
        context.getResourceType().getResourceConfigurationDefinition();
    ConfigurationWriteDelegate delegate =
        new ConfigurationWriteDelegate(configDef, connection, address);
    delegate.updateResourceConfiguration(report);
  }
예제 #6
0
  /**
   * Returns an instantiated and loaded versions store access point.
   *
   * @return will not be <code>null</code>
   */
  private org.rhq.core.pluginapi.content.version.PackageVersions loadPackageVersions() {
    if (this.versions == null) {
      ResourceType resourceType = resourceContext.getResourceType();
      String pluginName = resourceType.getPlugin();
      File dataDirectoryFile = resourceContext.getDataDirectory();
      dataDirectoryFile.mkdirs();
      String dataDirectory = dataDirectoryFile.getAbsolutePath();
      log.trace(
          "Creating application versions store with plugin name [" //$NON-NLS-1$
              + pluginName
              + "] and data directory ["
              + dataDirectory //$NON-NLS-1$
              + "]"); //$NON-NLS-1$
      this.versions = new PackageVersions(pluginName, dataDirectory);
      this.versions.loadFromDisk();
    }

    return this.versions;
  }
예제 #7
0
  public AvailabilityType getAvailability() {
    if (connectionProvider == null || !connectionProvider.isConnected()) {
      try {
        internalStart();
      } catch (Exception e) {
        log.debug(
            "Still unable to reconnect to "
                + context.getResourceType()
                + "["
                + context.getResourceKey()
                + "] due to error: "
                + e);
      }
    }

    return ((connectionProvider != null) && connectionProvider.isConnected())
        ? AvailabilityType.UP
        : AvailabilityType.DOWN;
  }
예제 #8
0
  public void start(ResourceContext context) throws Exception {
    this.context = context;
    log.debug(
        "Starting connection to "
            + context.getResourceType()
            + "["
            + context.getResourceKey()
            + "]...");

    // If connecting to the EMS fails, log a warning but still succeed in starting. getAvailablity()
    // will keep
    // trying to connect each time it is called.
    try {
      internalStart();
    } catch (Exception e) {
      log.warn(
          "Failed to connect to "
              + context.getResourceType()
              + "["
              + context.getResourceKey()
              + "].",
          e);
    }

    if (connection == null) {
      log.warn(
          "Unable to connect to "
              + context.getResourceType()
              + "["
              + context.getResourceKey()
              + "].");
    }
  }
예제 #9
0
  /**
   * The plugin container will call this method when it has a new configuration for your managed
   * resource. Your plugin will re-configure the managed resource in your own custom way, setting
   * its configuration based on the new values of the given configuration.
   *
   * @see ConfigurationFacet#updateResourceConfiguration(ConfigurationUpdateReport)
   */
  public void updateResourceConfiguration(ConfigurationUpdateReport report) {

    resourceConfiguration = report.getConfiguration().deepCopy();

    Configuration resourceConfig = report.getConfiguration();

    ManagementView managementView = null;
    ComponentType componentType = null;
    if (this.getComponentType().equals(PluginConstants.ComponentType.VDB.NAME)) {
      componentType =
          new ComponentType(
              PluginConstants.ComponentType.VDB.TYPE, PluginConstants.ComponentType.VDB.SUBTYPE);
    } else {
      report.setStatus(ConfigurationUpdateStatus.FAILURE);
      report.setErrorMessage("Update not implemented for the component type."); // $NON-NLS-1$
    }

    ManagedComponent managedComponent = null;
    report.setStatus(ConfigurationUpdateStatus.SUCCESS);
    try {

      managementView = getConnection().getManagementView();
      managedComponent = managementView.getComponent(this.name, componentType);
      Map<String, ManagedProperty> managedProperties = managedComponent.getProperties();

      ProfileServiceUtil.convertConfigurationToManagedProperties(
          managedProperties, resourceConfig, resourceContext.getResourceType(), null);

      try {
        managementView.updateComponent(managedComponent);
      } catch (Exception e) {
        LOG.error(
            "Unable to update component [" //$NON-NLS-1$
                + managedComponent.getName()
                + "] of type " //$NON-NLS-1$
                + componentType
                + ".",
            e); //$NON-NLS-1$
        report.setStatus(ConfigurationUpdateStatus.FAILURE);
        report.setErrorMessageFromThrowable(e);
      }
    } catch (Exception e) {
      LOG.error("Unable to process update request", e); // $NON-NLS-1$
      report.setStatus(ConfigurationUpdateStatus.FAILURE);
      report.setErrorMessageFromThrowable(e);
    }
  }
예제 #10
0
  /**
   * Deploy content to the remote server - this is one half of #createResource
   *
   * @param report Create resource report that tells us what to do
   * @return report that tells us what has been done.
   */
  protected CreateResourceReport deployContent(CreateResourceReport report) {
    ContentContext cctx = context.getContentContext();
    ResourcePackageDetails details = report.getPackageDetails();

    ContentServices contentServices = cctx.getContentServices();
    String resourceTypeName = report.getResourceType().getName();

    ASUploadConnection uploadConnection = new ASUploadConnection(host, port);
    OutputStream out = uploadConnection.getOutputStream(details.getFileName());
    contentServices.downloadPackageBitsForChildResource(
        cctx, resourceTypeName, details.getKey(), out);

    JsonNode uploadResult = uploadConnection.finishUpload();
    if (verbose) log.info(uploadResult);

    if (ASUploadConnection.isErrorReply(uploadResult)) {
      report.setStatus(CreateResourceStatus.FAILURE);
      report.setErrorMessage(ASUploadConnection.getFailureDescription(uploadResult));

      return report;
    }

    String fileName = details.getFileName();

    if (fileName.startsWith(
        "C:\\fakepath\\")) { // TODO this is a hack as the server adds the fake path somehow
      fileName = fileName.substring("C:\\fakepath\\".length());
    }

    String tmpName = fileName; // TODO figure out the tmp-name biz with the AS guys

    JsonNode resultNode = uploadResult.get("result");
    String hash = resultNode.get("BYTES_VALUE").getTextValue();

    return runDeploymentMagicOnServer(report, fileName, tmpName, hash);
  }
예제 #11
0
  /**
   * Start the resource connection
   *
   * @see
   *     org.rhq.core.pluginapi.inventory.ResourceComponent#start(org.rhq.core.pluginapi.inventory.ResourceContext)
   */
  public void start(ResourceContext context) throws InvalidPluginConfigurationException, Exception {
    this.context = context;
    pluginConfiguration = context.getPluginConfiguration();

    if (!(context.getParentResourceComponent() instanceof BaseComponent)) {
      host = pluginConfiguration.getSimpleValue("hostname", LOCALHOST);
      String portString = pluginConfiguration.getSimpleValue("port", DEFAULT_HTTP_MANAGEMENT_PORT);
      port = Integer.parseInt(portString);
      connection = new ASConnection(host, port);
    } else {
      connection = ((BaseComponent) context.getParentResourceComponent()).getASConnection();
    }

    path = pluginConfiguration.getSimpleValue("path", null);
    address = new Address(path);
    key = context.getResourceKey();

    myServerName =
        context.getResourceKey().substring(context.getResourceKey().lastIndexOf("/") + 1);
  }
예제 #12
0
  @Override
  public OperationResult invokeOperation(String name, Configuration parameters)
      throws InterruptedException, Exception {

    if (!name.contains(":")) {
      OperationResult badName = new OperationResult("Operation name did not contain a ':'");
      badName.setErrorMessage("Operation name did not contain a ':'");
      return badName;
    }

    int colonPos = name.indexOf(':');
    String what = name.substring(0, colonPos);
    String op = name.substring(colonPos + 1);
    Operation operation = null;

    Address theAddress = new Address();

    if (what.equals("server-group")) {
      String groupName = parameters.getSimpleValue("name", "");
      String profile = parameters.getSimpleValue("profile", "default");

      theAddress.add("server-group", groupName);

      operation = new Operation(op, theAddress);
      operation.addAdditionalProperty("profile", profile);
    } else if (what.equals("server")) {
      if (context.getResourceType().getName().equals("JBossAS-Managed")) {
        String host = pluginConfiguration.getSimpleValue("domainHost", "local");
        theAddress.add("host", host);
        theAddress.add("server-config", myServerName);
        operation = new Operation(op, theAddress);
      } else if (context.getResourceType().getName().equals("Host")) {
        theAddress.add(address);
        String serverName = parameters.getSimpleValue("name", null);
        theAddress.add("server-config", serverName);
        Map<String, Object> props = new HashMap<String, Object>();
        String serverGroup = parameters.getSimpleValue("group", null);
        props.put("group", serverGroup);
        if (op.equals("add")) {
          props.put("name", serverName);
          boolean autoStart = parameters.getSimple("auto-start").getBooleanValue();
          props.put("auto-start", autoStart);
          // TODO put more properties in
        }

        operation = new Operation(op, theAddress, props);
      } else {
        operation = new Operation(op, theAddress);
      }
    } else if (what.equals("destination")) {
      theAddress.add(address);
      String newName = parameters.getSimpleValue("name", "");
      String type = parameters.getSimpleValue("type", "jms-queue").toLowerCase();
      theAddress.add(type, newName);
      PropertyList jndiNamesProp = parameters.getList("entries");
      if (jndiNamesProp == null || jndiNamesProp.getList().isEmpty()) {
        OperationResult fail = new OperationResult();
        fail.setErrorMessage("No jndi bindings given");
        return fail;
      }
      List<String> jndiNames = new ArrayList<String>();
      for (Property p : jndiNamesProp.getList()) {
        PropertySimple ps = (PropertySimple) p;
        jndiNames.add(ps.getStringValue());
      }

      operation = new Operation(op, theAddress);
      operation.addAdditionalProperty("entries", jndiNames);
      if (type.equals("jms-queue")) {
        PropertySimple ps = (PropertySimple) parameters.get("durable");
        if (ps != null) {
          boolean durable = ps.getBooleanValue();
          operation.addAdditionalProperty("durable", durable);
        }
        String selector = parameters.getSimpleValue("selector", "");
        if (!selector.isEmpty()) operation.addAdditionalProperty("selector", selector);
      }

    } else if (what.equals("managed-server")) {
      String chost = parameters.getSimpleValue("hostname", "");
      String serverName = parameters.getSimpleValue("servername", "");
      String serverGroup = parameters.getSimpleValue("server-group", "");
      String socketBindings = parameters.getSimpleValue("socket-bindings", "");
      String portS = parameters.getSimpleValue("port-offset", "0");
      int port = Integer.parseInt(portS);
      String autostartS = parameters.getSimpleValue("auto-start", "false");
      boolean autoStart = Boolean.getBoolean(autostartS);

      theAddress.add("host", chost);
      theAddress.add("server-config", serverName);
      Map<String, Object> props = new HashMap<String, Object>();
      props.put("name", serverName);
      props.put("group", serverGroup);
      props.put("socket-binding-group", socketBindings);
      props.put("socket-binding-port-offset", port);
      props.put("auto-start", autoStart);

      operation = new Operation(op, theAddress, props);
    } else if (what.equals("domain")) {
      operation = new Operation(op, new Address());
    } else if (what.equals("domain-deployment")) {
      if (op.equals("promote")) {
        String serverGroup = parameters.getSimpleValue("server-group", "-not set-");
        List<String> serverGroups = new ArrayList<String>();
        if (serverGroup.equals("__all")) {
          serverGroups.addAll(getServerGroups());
        } else {
          serverGroups.add(serverGroup);
        }
        String resourceKey = context.getResourceKey();
        resourceKey = resourceKey.substring(resourceKey.indexOf("=") + 1);

        log.info(
            "Promoting ["
                + resourceKey
                + "] to server group(s) ["
                + Arrays.asList(serverGroups)
                + "]");

        PropertySimple simple = parameters.getSimple("enabled");
        Boolean enabled = false;
        if (simple != null && simple.getBooleanValue() != null) enabled = simple.getBooleanValue();

        operation = new CompositeOperation();
        for (String theGroup : serverGroups) {
          theAddress = new Address();
          theAddress.add("server-group", theGroup);

          theAddress.add("deployment", resourceKey);
          Operation step = new Operation("add", theAddress);
          step.addAdditionalProperty("enabled", enabled);
          ((CompositeOperation) operation).addStep(step);
        }
      }
    } else if (what.equals("naming")) {
      if (op.equals("jndi-view")) {
        theAddress.add(address);
        operation = new Operation("jndi-view", theAddress);
      }
    }

    OperationResult operationResult = new OperationResult();
    if (operation != null) {
      Result result = connection.execute(operation);

      if (!result.isSuccess()) {
        operationResult.setErrorMessage(result.getFailureDescription());
      } else {
        String tmp;
        if (result.getResult() == null) tmp = "-none provided by the server-";
        else tmp = result.getResult().toString();
        operationResult.setSimpleResult(tmp);
      }
    } else {
      operationResult.setErrorMessage("No valid operation was given for input [" + name + "]");
    }
    return operationResult;
  }
예제 #13
0
  /**
   * Do the actual fumbling with the domain api to deploy the uploaded content
   *
   * @param report CreateResourceReport to report the result
   * @param runtimeName File name to use as runtime name
   * @param deploymentName Name of the deployment
   * @param hash Hash of the content bytes
   * @return the passed report with success or failure settings
   */
  public CreateResourceReport runDeploymentMagicOnServer(
      CreateResourceReport report, String runtimeName, String deploymentName, String hash) {

    boolean toServerGroup = context.getResourceKey().contains("server-group=");
    log.info("Deploying [" + runtimeName + "] to domain only= " + !toServerGroup + " ...");

    ASConnection connection = getASConnection();

    Operation step1 = new Operation("add", "deployment", deploymentName);
    //        step1.addAdditionalProperty("hash", new PROPERTY_VALUE("BYTES_VALUE", hash));
    List<Object> content = new ArrayList<Object>(1);
    Map<String, Object> contentValues = new HashMap<String, Object>();
    contentValues.put("hash", new PROPERTY_VALUE("BYTES_VALUE", hash));
    content.add(contentValues);
    step1.addAdditionalProperty("content", content);

    step1.addAdditionalProperty("name", deploymentName);
    step1.addAdditionalProperty("runtime-name", runtimeName);

    String resourceKey;
    Result result;

    CompositeOperation cop = new CompositeOperation();
    cop.addStep(step1);
    /*
     * We need to check here if this is an upload to /deployment only
     * or if this should be deployed to a server group too
     */

    if (!toServerGroup) {

      // if standalone, then :deploy the deployment anyway
      if (context.getResourceType().getName().contains("Standalone")) {
        Operation step2 = new Operation("deploy", step1.getAddress());
        cop.addStep(step2);
      }

      result = connection.execute(cop);
      resourceKey = step1.getAddress().getPath();

    } else {

      Address serverGroupAddress = new Address(context.getResourceKey());
      serverGroupAddress.add("deployment", deploymentName);
      Operation step2 = new Operation("add", serverGroupAddress);

      cop.addStep(step2);

      Operation step3 = new Operation("deploy", serverGroupAddress);
      cop.addStep(step3);

      resourceKey = serverGroupAddress.getPath();

      if (verbose) log.info("Deploy operation: " + cop);

      result = connection.execute(cop);
    }

    if ((!result.isSuccess())) {
      String failureDescription = result.getFailureDescription();
      report.setErrorMessage(failureDescription);
      report.setStatus(CreateResourceStatus.FAILURE);
      log.warn(" ... done with failure: " + failureDescription);
    } else {
      report.setStatus(CreateResourceStatus.SUCCESS);
      report.setResourceName(runtimeName);
      report.setResourceKey(resourceKey);
      log.info(" ... with success and key [" + resourceKey + "]");
    }

    return report;
  }
예제 #14
0
 /**
  * This is called when your component has been started with the given context. You normally
  * initialize some internal state of your component as well as attempt to make a stateful
  * connection to your managed resource.
  *
  * @see ResourceComponent#start(ResourceContext)
  */
 public void start(ResourceContext context) {
   resourceContext = context;
   deploymentName = context.getResourceKey();
 }
예제 #15
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  @Test
  public void updateResourceConfigurationWithName() throws Exception {
    // tell the method story as it happens: mock or create dependencies and configure
    // those dependencies to get the method under test to completion.
    ResourceContext mockResourceContext = mock(ResourceContext.class);

    ResourceType mockResourceType = mock(ResourceType.class);
    when(mockResourceContext.getResourceType()).thenReturn(mockResourceType);

    ConfigurationDefinition mockConfigurationDefinition = mock(ConfigurationDefinition.class);
    when(mockResourceType.getResourceConfigurationDefinition())
        .thenReturn(mockConfigurationDefinition);

    ConfigurationDefinition mockConfigurationDefinitionCopy = mock(ConfigurationDefinition.class);
    when(mockConfigurationDefinition.copy()).thenReturn(mockConfigurationDefinitionCopy);

    ConfigurationTemplate mockConfigurationTemplate = mock(ConfigurationTemplate.class);
    when(mockConfigurationDefinitionCopy.getDefaultTemplate())
        .thenReturn(mockConfigurationTemplate);

    Configuration mockConfiguration = mock(Configuration.class);
    when(mockConfigurationTemplate.getConfiguration()).thenReturn(mockConfiguration);

    Property mockProperty = mock(Property.class);
    when(mockConfiguration.get(eq("__type"))).thenReturn(null);
    when(mockConfiguration.get(eq("__name"))).thenReturn(mockProperty);

    Map<String, PropertyDefinition> mockMap = (Map<String, PropertyDefinition>) mock(Map.class);
    when(mockConfigurationDefinitionCopy.getPropertyDefinitions()).thenReturn(mockMap);

    ConfigurationUpdateReport mockReport = mock(ConfigurationUpdateReport.class);
    when(mockReport.getConfiguration()).thenReturn(mockConfiguration);

    ConfigurationWriteDelegate mockConfigurationWriteDelegate =
        mock(ConfigurationWriteDelegate.class);
    PowerMockito.whenNew(ConfigurationWriteDelegate.class)
        .withParameterTypes(ConfigurationDefinition.class, ASConnection.class, Address.class)
        .withArguments(
            any(ConfigurationDefinition.class), any(ASConnection.class), any(Address.class))
        .thenReturn(mockConfigurationWriteDelegate);

    ASConnection mockASConnection = mock(ASConnection.class);
    when(mockASConnection.execute(any(ReadResource.class))).thenReturn(new Result());

    // create object to test and inject required dependencies
    TemplatedComponent objectUnderTest = new TemplatedComponent();

    objectUnderTest.context = mockResourceContext;
    objectUnderTest.testConnection = mockASConnection;

    // run code under test
    objectUnderTest.updateResourceConfiguration(mockReport);

    // verify the results (Assert and mock verification)
    verify(mockMap, times(1)).remove(eq("__name"));
    verify(mockConfiguration, times(1)).get(eq("__type"));
    verify(mockConfiguration, times(1)).get(eq("__name"));
    verify(mockConfiguration, times(1)).remove(eq("__name"));

    PowerMockito.verifyNew(ConfigurationWriteDelegate.class)
        .withArguments(
            any(ConfigurationDefinition.class), eq(mockASConnection), any(Address.class));
  }
예제 #16
0
 private EmsConnection getConnection() {
   return context.getParentResourceComponent().getEmsConnection();
 }
예제 #17
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  @Test
  public void loadResourceConfigurationWithType() throws Exception {
    // tell the method story as it happens: mock or create dependencies and configure
    // those dependencies to get the method under test to completion.
    ResourceContext mockResourceContext = mock(ResourceContext.class);

    ResourceType mockResourceType = mock(ResourceType.class);
    when(mockResourceContext.getResourceType()).thenReturn(mockResourceType);

    ConfigurationDefinition mockConfigurationDefinition = mock(ConfigurationDefinition.class);
    when(mockResourceType.getResourceConfigurationDefinition())
        .thenReturn(mockConfigurationDefinition);

    ConfigurationTemplate mockConfigurationTemplate = mock(ConfigurationTemplate.class);
    when(mockConfigurationDefinition.getDefaultTemplate()).thenReturn(mockConfigurationTemplate);

    Configuration mockConfiguration = mock(Configuration.class);
    when(mockConfigurationTemplate.getConfiguration()).thenReturn(mockConfiguration);

    Property mockProperty = mock(Property.class);
    when(mockConfiguration.get(eq("__type"))).thenReturn(mockProperty);

    Map<String, PropertyDefinition> mockMap = (Map<String, PropertyDefinition>) mock(Map.class);
    when(mockConfigurationDefinition.getPropertyDefinitions()).thenReturn(mockMap);

    ConfigurationLoadDelegate mockConfigurationLoadDelegate = mock(ConfigurationLoadDelegate.class);
    PowerMockito.whenNew(ConfigurationLoadDelegate.class)
        .withParameterTypes(ConfigurationDefinition.class, ASConnection.class, Address.class)
        .withArguments(
            any(ConfigurationDefinition.class), any(ASConnection.class), any(Address.class))
        .thenReturn(mockConfigurationLoadDelegate);

    when(mockConfigurationLoadDelegate.loadResourceConfiguration()).thenReturn(mockConfiguration);

    PropertySimple pathPropertySimple = new PropertySimple("path", "abc=def,xyz=test1");
    when(mockConfiguration.get(eq("path"))).thenReturn(pathPropertySimple);
    when(mockResourceContext.getPluginConfiguration()).thenReturn(mockConfiguration);

    ASConnection mockASConnection = mock(ASConnection.class);

    PropertySimple typePropertySimple = new PropertySimple("__type", "xyz");
    PowerMockito.whenNew(PropertySimple.class)
        .withParameterTypes(String.class, Object.class)
        .withArguments(eq("__type"), eq("xyz"))
        .thenReturn(typePropertySimple);

    // create object to test and inject required dependencies
    TemplatedComponent objectUnderTest = new TemplatedComponent();

    objectUnderTest.context = mockResourceContext;
    objectUnderTest.testConnection = mockASConnection;

    // run code under test
    Configuration result = objectUnderTest.loadResourceConfiguration();

    // verify the results (Assert and mock verification)
    Assert.assertEquals(result, mockConfiguration);

    verify(mockMap, times(1)).remove(eq("__type"));
    verify(mockConfiguration, times(1)).get(eq("__type"));
    verify(mockConfiguration, never()).get(eq("__name"));
    verify(mockConfiguration, times(1)).get(eq("path"));
    verify(mockConfiguration, times(1)).put(eq(typePropertySimple));

    PowerMockito.verifyNew(PropertySimple.class).withArguments(eq("__type"), eq("xyz"));
    PowerMockito.verifyNew(ConfigurationLoadDelegate.class)
        .withArguments(
            any(ConfigurationDefinition.class), eq(mockASConnection), any(Address.class));
  }