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;
}
private void promptForJmxCredentialsIfNeeded() throws IOException {
// If the username was not configured via cli, then prompt the user for the values
if (username == null) {
log.debug("Prompting user for jmx login");
username = ShellUtils.readLine(session, "Jmx Login for " + parent + ": ", false);
}
if (password == null) {
password = ShellUtils.readLine(session, "Jmx Password for " + parent + ": ", true);
}
}
@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;
}
@Override
protected Object doExecute() throws Exception {
MQBrokerConfigDTO dto = createDTO();
Profile profile = MQManager.createOrUpdateProfile(dto, fabricService);
String profileId = profile.getId();
System.out.println("MQ profile " + profileId + " ready");
// assign profile to existing containers
if (assign != null) {
String[] assignContainers = assign.split(",");
MQManager.assignProfileToContainers(fabricService, profile, assignContainers);
}
// create containers
if (create != null) {
String[] createContainers = create.split(",");
List<CreateContainerBasicOptions.Builder> builderList =
MQManager.createContainerBuilders(
dto, fabricService, "child", profileId, dto.version(), createContainers);
for (CreateContainerBasicOptions.Builder builder : builderList) {
CreateContainerMetadata[] metadatas = null;
try {
if (builder instanceof CreateChildContainerOptions.Builder) {
CreateChildContainerOptions.Builder childBuilder =
(CreateChildContainerOptions.Builder) builder;
builder = childBuilder.jmxUser(username).jmxPassword(password);
}
metadatas = fabricService.createContainers(builder.build());
ShellUtils.storeFabricCredentials(session, username, password);
} catch (FabricAuthenticationException fae) {
// If authentication fails, prompts for credentials and try again.
if (builder instanceof CreateChildContainerOptions.Builder) {
CreateChildContainerOptions.Builder childBuilder =
(CreateChildContainerOptions.Builder) builder;
promptForJmxCredentialsIfNeeded();
metadatas =
fabricService.createContainers(
childBuilder.jmxUser(username).jmxPassword(password).build());
ShellUtils.storeFabricCredentials(session, username, password);
}
}
}
}
return null;
}
private String[] promptForNewUser(String user, String password) throws IOException {
String[] response = new String[2];
// If the username was not configured via cli, then prompt the user for the values
if (user == null || password == null) {
System.out.println(
"No user found in etc/users.properties or specified as an option. Please specify one ...");
}
while (user == null || user.isEmpty()) {
user = ShellUtils.readLine(session, "New user name: ", false);
if (user == null) {
break;
}
}
if (user != null && password == null) {
String password1 = null;
String password2 = null;
while (password1 == null || !password1.equals(password2)) {
password1 = ShellUtils.readLine(session, "Password for " + user + ": ", true);
password2 = ShellUtils.readLine(session, "Verify password for " + user + ": ", true);
if (password1 == null || password2 == null) {
break;
}
if (password1 != null && password1.equals(password2)) {
password = password1;
} else {
System.out.println("Passwords did not match. Please try again!");
}
}
}
response[0] = user;
response[1] = password;
return response;
}
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;
}