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;
}
}
