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; }
/** Arguments for creating a new container via SSH */ public class CreateSshContainerOptions extends CreateContainerBasicOptions<CreateSshContainerOptions> implements CreateRemoteContainerOptions { private static final long serialVersionUID = -1171578973712670970L; public static final String DEFAULT_PRIVATE_KEY_FILE = System.getProperty("user.home") + File.separatorChar + ".ssh" + File.separatorChar + "id_rsa"; static final Integer DEFAULT_SSH_RETRIES = 1; static final Integer DEFAULT_SSH_PORT = 22; private String username; private String password; private String host; private Integer port = DEFAULT_SSH_PORT; private String path = "/usr/local/fusesource/container"; private Integer sshRetries = DEFAULT_SSH_RETRIES; private Integer retryDelay = 1; private String privateKeyFile = DEFAULT_PRIVATE_KEY_FILE; private String passPhrase; private CreateEnsembleOptions createEnsembleOptions = CreateEnsembleOptions.build(); public CreateSshContainerOptions() { this.providerType = "ssh"; } @Override public String toString() { return "createSshContainer(" + getUsername() + "@" + getHost() + ":" + getPort() + " " + getPath() + ")"; } public CreateSshContainerOptions username(final String username) { this.username = username; return this; } public CreateSshContainerOptions password(final String password) { this.password = password; return this; } public CreateSshContainerOptions host(final String host) { this.host = host; return this; } public CreateSshContainerOptions port(final Integer port) { this.port = port; return this; } public CreateSshContainerOptions path(final String path) { this.path = path; return this; } public CreateSshContainerOptions sshRetries(final Integer sshRetries) { this.sshRetries = sshRetries; return this; } public CreateSshContainerOptions retryDelay(final Integer retryDelay) { this.retryDelay = retryDelay; return this; } public CreateSshContainerOptions privateKeyFile(final String privateKeyFile) { this.privateKeyFile = privateKeyFile; return this; } public CreateSshContainerOptions passPhrase(final String passPhrase) { this.passPhrase = passPhrase; return this; } public CreateSshContainerOptions createEnsembleOptions( final CreateEnsembleOptions createEnsembleOptions) { this.createEnsembleOptions = createEnsembleOptions; return this; } public String getUsername() { try { return username != null && !username.isEmpty() ? username : getProviderURI().getUserInfo().split(":")[0]; } catch (Exception ex) { throw new IllegalStateException("Username should be part of the url or explicitly specified"); } } public void setUsername(String username) { this.username = username; } public String getPassword() { if (password != null && !password.isEmpty()) { return password; } else if (getProviderURI() != null && getProviderURI().getUserInfo() != null && getProviderURI().getUserInfo().contains(":")) { return getProviderURI().getUserInfo().split(":")[1]; } else { return null; } } public void setPassword(String password) { this.password = password; } public String getHost() { return host != null && !host.isEmpty() ? host : getProviderURI().getHost(); } public void setHost(String host) { this.host = host; } public Integer getPort() { return port != null && port != 0 ? port : (getProviderURI() != null && getProviderURI().getPort() != 0 ? getProviderURI().getPort() : DEFAULT_SSH_PORT); } public void setPort(Integer port) { this.port = port; } public Integer getSshRetries() { return sshRetries != null ? sshRetries : DEFAULT_SSH_RETRIES; } public void setSshRetries(Integer sshRetries) { this.sshRetries = sshRetries; } public String getPath() { return path; } public void setPath(String path) { this.path = path; } public Integer getRetryDelay() { return retryDelay; } public void setRetryDelay(Integer retryDelay) { this.retryDelay = retryDelay; } public String getPrivateKeyFile() { // We check for a parameter first as the privateKeyFile has a default value assigned. return getParameters().get("privateKeyFile") != null ? getParameters().get("privateKeyFile") : privateKeyFile; } public void setPrivateKeyFile(String privateKeyFile) { this.privateKeyFile = privateKeyFile; } public String getPassPhrase() { return passPhrase; } public void setPassPhrase(String passPhrase) { this.passPhrase = passPhrase; } public CreateEnsembleOptions getCreateEnsembleOptions() { return createEnsembleOptions; } public void setCreateEnsembleOptions(CreateEnsembleOptions createEnsembleOptions) { this.createEnsembleOptions = createEnsembleOptions; } }