示例#1
0
  private MQBrokerConfigDTO createDTO() {
    if (Strings.isNullOrBlank(username)) {
      username = ShellUtils.retrieveFabricUser(session);
    }
    if (Strings.isNullOrBlank(password)) {
      password = ShellUtils.retrieveFabricUserPassword(session);
    }

    MQBrokerConfigDTO dto = new MQBrokerConfigDTO();
    dto.setConfigUrl(config);
    dto.setData(data);
    if (ports != null && ports.length > 0) {
      for (String port : ports) {
        addConfig(port, dto.getPorts());
      }
    }
    dto.setGroup(group);
    dto.setJvmOpts(jvmOpts);
    dto.setBrokerName(name);
    dto.setProfile(profile);
    dto.setClientProfile(clientProfile);
    dto.setClientParentProfile(clientParentProfile);
    dto.setNetworks(networks);
    dto.setNetworksPassword(networksPassword);
    dto.setNetworksUserName(networksUserName);
    dto.setParentProfile(parentProfile);
    dto.setProperties(properties);
    dto.setVersion(version);
    dto.setMinimumInstances(minimumInstances);
    dto.setReplicas(replicas);
    if (kind != null) {
      dto.setKind(kind);
    }
    return dto;
  }
示例#2
0
  @Override
  protected Object doExecute() throws Exception {
    CreateContainerMetadata[] metadatas = null;
    validateProfileName(profiles);

    // validate input before creating containers
    preCreateContainer(name);

    String jmxUser = username != null ? username : ShellUtils.retrieveFabricUser(session);
    String jmxPassword =
        password != null ? password : ShellUtils.retrieveFabricUserPassword(session);

    // okay create child container
    String url = "child://" + parent;
    CreateChildContainerOptions.Builder builder =
        CreateChildContainerOptions.builder()
            .name(name)
            .parent(parent)
            .bindAddress(bindAddress)
            .resolver(resolver)
            .manualIp(manualIp)
            .ensembleServer(isEnsembleServer)
            .number(number)
            .zookeeperUrl(fabricService.getZookeeperUrl())
            .zookeeperPassword(fabricService.getZookeeperPassword())
            .jvmOpts(jvmOpts)
            .jmxUser(jmxUser)
            .jmxPassword(jmxPassword)
            .version(version)
            .profiles(getProfileNames())
            .dataStoreProperties(getDataStoreProperties())
            .dataStoreType(fabricService.getDataStore().getType());

    try {
      metadatas = fabricService.createContainers(builder.build());
      rethrowAuthenticationErrors(metadatas);
      ShellUtils.storeFabricCredentials(session, jmxUser, jmxPassword);
    } catch (FabricAuthenticationException ex) {
      // If authentication fails, prompts for credentials and try again.
      username = null;
      password = null;
      promptForJmxCredentialsIfNeeded();
      metadatas =
          fabricService.createContainers(builder.jmxUser(username).jmxPassword(password).build());
      ShellUtils.storeFabricCredentials(session, username, password);
    }

    // display containers
    displayContainers(metadatas);
    return null;
  }
示例#3
0
  protected Object doExecute() throws Exception {

    // prevent creating fabric if already created
    ServiceReference<FabricService> sref = bundleContext.getServiceReference(FabricService.class);
    FabricService fabricService = sref != null ? bundleContext.getService(sref) : null;
    if (!force
        && (fabricService != null && fabricService.getCurrentContainer().isEnsembleServer())) {
      System.out.println(
          "Current container "
              + fabricService.getCurrentContainerName()
              + " is already in the current fabric ensemble. Cannot create fabric.");
      System.out.println(
          "You can use the --force option, if you want to force re-create the fabric.");
      return null;
    }

    Configuration bootConfiguration =
        configAdmin.getConfiguration(BootstrapConfiguration.COMPONENT_PID, null);
    Dictionary<String, Object> bootProperties = bootConfiguration.getProperties();
    if (bootProperties == null) {
      bootProperties = new Hashtable<>();
    }

    String runtimeIdentity = runtimeProperties.getRuntimeIdentity();
    CreateEnsembleOptions.Builder<?> builder =
        CreateEnsembleOptions.builder()
            .zooKeeperServerTickTime(zooKeeperTickTime)
            .zooKeeperServerInitLimit(zooKeeperInitLimit)
            .zooKeeperServerSyncLimit(zooKeeperSyncLimit)
            .zooKeeperServerDataDir(zooKeeperDataDir)
            .fromRuntimeProperties(runtimeProperties)
            .bootstrapTimeout(bootstrapTimeout)
            .waitForProvision(waitForProvisioning)
            .clean(clean);

    builder.version(version);

    if (containers == null || containers.isEmpty()) {
      containers = Arrays.asList(runtimeIdentity);
    }

    if (!noImport && importDir != null) {
      builder.autoImportEnabled(true);
      builder.importPath(importDir);
    }

    if (globalResolver != null) {
      builder.globalResolver(globalResolver);
      bootProperties.put(ZkDefs.GLOBAL_RESOLVER_PROPERTY, globalResolver);
    }

    if (resolver != null) {
      builder.resolver(resolver);
      bootProperties.put(ZkDefs.LOCAL_RESOLVER_PROPERTY, resolver);
    }

    if (manualIp != null) {
      builder.manualIp(manualIp);
      bootProperties.put(ZkDefs.MANUAL_IP, manualIp);
    }

    if (bindAddress != null) {
      if (!bindAddress.contains(":")) {
        builder.bindAddress(bindAddress);
        bootProperties.put(ZkDefs.BIND_ADDRESS, bindAddress);
      } else {
        String[] parts = bindAddress.split(":");
        builder.bindAddress(parts[0]);
        builder.zooKeeperServerPort(Integer.parseInt(parts[1]));
        bootProperties.put(ZkDefs.BIND_ADDRESS, parts[0]);
      }
    }

    if (zooKeeperServerPort > 0) {
      // --zookeeper-server-port option has higher priority than
      // CreateEnsembleOptions.ZOOKEEPER_SERVER_PORT and
      // CreateEnsembleOptions.ZOOKEEPER_SERVER_CONNECTION_PORT
      // system/runtime properties
      builder.setZooKeeperServerPort(zooKeeperServerPort);
      builder.setZooKeeperServerConnectionPort(zooKeeperServerPort);
    }

    // Configure External Git Repository.
    if (externalGitUrl != null) {
      builder.dataStoreProperty(GIT_REMOTE_URL, externalGitUrl);
    }
    if (externalGitUser != null) {
      builder.dataStoreProperty(GIT_REMOTE_USER, externalGitUser);
    }
    if (externalGitPassword != null) {
      builder.dataStoreProperty(GIT_REMOTE_PASSWORD, externalGitPassword);
    }

    if (profiles != null && profiles.size() > 0) {
      builder.profiles(profiles);
    }

    if (nonManaged) {
      builder.agentEnabled(false);
    } else {
      builder.agentEnabled(true);
    }

    builder.minimumPort(minimumPort);
    builder.minimumPort(maximumPort);
    bootProperties.put(ZkDefs.MINIMUM_PORT, String.valueOf(minimumPort));
    bootProperties.put(ZkDefs.MAXIMUM_PORT, String.valueOf(maximumPort));

    newUser = newUser != null ? newUser : ShellUtils.retrieveFabricUser(session);
    newUserPassword =
        newUserPassword != null ? newUserPassword : ShellUtils.retrieveFabricUserPassword(session);

    Path propsPath = runtimeProperties.getConfPath().resolve("users.properties");
    Properties userProps = new Properties(propsPath.toFile());

    if (userProps.isEmpty()) {
      String[] credentials = promptForNewUser(newUser, newUserPassword);
      newUser = credentials[0];
      newUserPassword = credentials[1];
    } else {
      if (newUser == null || newUserPassword == null) {
        newUser = "" + userProps.keySet().iterator().next();
        newUserPassword = "" + userProps.get(newUser);
        if (newUserPassword.contains(ROLE_DELIMITER)) {
          newUserPassword = newUserPassword.substring(0, newUserPassword.indexOf(ROLE_DELIMITER));
        }
      }
      String passwordWithroles = userProps.get(newUser);
      if (passwordWithroles != null && passwordWithroles.contains(ROLE_DELIMITER)) {
        String[] infos = passwordWithroles.split(",");
        String oldUserRole = newUserRole;
        for (int i = 1; i < infos.length; i++) {
          if (infos[i].trim().startsWith(BackingEngine.GROUP_PREFIX)) {
            // it's a group reference
            String groupInfo = (String) userProps.get(infos[i].trim());
            if (groupInfo != null) {
              String[] roles = groupInfo.split(",");
              for (int j = 1; j < roles.length; j++) {
                if (!roles[j].trim().equals(oldUserRole)) {
                  newUserRole = newUserRole + ROLE_DELIMITER + roles[j].trim();
                }
              }
            }
          } else {
            // it's an user reference
            if (!infos[i].trim().equals(oldUserRole)) {
              newUserRole = newUserRole + ROLE_DELIMITER + infos[i].trim();
            }
          }
        }
      }
    }

    if (Strings.isNullOrEmpty(newUser)) {
      System.out.println("No user specified. Cannot create a new fabric ensemble.");
      return null;
    }

    StringBuilder sb = new StringBuilder();

    // session is unset when this is called from FMC
    if (session != null) {
      ShellUtils.storeFabricCredentials(session, newUser, newUserPassword);
    }

    if (generateZookeeperPassword) {
      // do nothing use the generated password.
    } else if (zookeeperPassword == null) {
      zookeeperPassword =
          PasswordEncoder.decode(
              runtimeProperties.getProperty(
                  CreateEnsembleOptions.ZOOKEEPER_PASSWORD,
                  PasswordEncoder.encode(newUserPassword)));
      builder.zookeeperPassword(zookeeperPassword);
    } else {
      builder.zookeeperPassword(zookeeperPassword);
    }

    bootConfiguration.update(bootProperties);
    CreateEnsembleOptions options =
        builder.users(userProps).withUser(newUser, newUserPassword, newUserRole).build();

    if (containers.size() == 1 && containers.contains(runtimeIdentity)) {
      bootstrap.create(options);
    } else {
      ServiceProxy<ZooKeeperClusterService> serviceProxy =
          ServiceProxy.createServiceProxy(bundleContext, ZooKeeperClusterService.class);
      try {
        serviceProxy.getService().createCluster(containers, options);
      } finally {
        serviceProxy.close();
      }
    }

    ShellUtils.storeZookeeperPassword(session, options.getZookeeperPassword());
    if (zookeeperPassword == null && !generateZookeeperPassword) {
      sb.append("Zookeeper password: (reusing users ")
          .append(newUser)
          .append(" password:"******")\n");
      sb.append(
          "(You can use the --zookeeper-password / --generate-zookeeper-password option to specify one.)\n");
    } else if (generateZookeeperPassword) {
      sb.append("Generated zookeeper password:"******"Using specified zookeeper password:"******"It may take a couple of seconds for the container to provision...");
      System.out.println(
          "You can use the --wait-for-provisioning option, if you want this command to block until the container is provisioned.");
    }

    return null;
  }