use of io.fabric8.common.util.Filter in project fabric8 by jboss-fuse.
the class ArchetypeGenerateAction method doExecute.
@Override
protected Object doExecute() throws Exception {
// if no directory then use workspace
if (directory == null) {
// must have a workspace location configured
Preferences preferences = Preferences.userNodeForPackage(getClass());
String location = preferences.get(ArchetypeWorkspace.PREFERENCE_WORKSPACE, null);
if (location == null) {
System.out.println("No workspace location has been set.");
System.out.println("Use the archetype-workspace command to set a workspace first.");
System.out.println("");
return null;
} else {
System.out.println("Using current workspace: " + location);
directory = location;
}
} else {
System.out.println("Using directory as workspace: " + directory);
}
File target = new File(directory);
// make sure the directory exists, auto-creating if missing
if (!target.exists()) {
target.mkdirs();
}
if (!target.exists() || !target.isDirectory()) {
System.err.println("Workspace does not exists or is not a directory: " + directory);
return null;
}
Archetype archetype = null;
// try artifact first
if (!isNullOrBlank(archetypeOrFilter)) {
archetype = archetypeService.getArchetypeByArtifact(archetypeOrFilter);
if (archetype == null) {
// then by coordinate
archetype = archetypeService.getArchetype(archetypeOrFilter);
}
}
// no archetype yet so present a list where the user can select
while (archetype == null) {
List<Archetype> archetypes = archetypeService.listArchetypes(archetypeOrFilter, true);
System.out.println("Choose archetype:");
Iterator<Archetype> it = archetypes.iterator();
int i = 0;
while (it.hasNext()) {
Archetype select = it.next();
System.out.println(String.format("%4d: -> %-50s %s", ++i, select.artifactId, select.description));
}
boolean choosing = true;
while (choosing) {
// default select last
String choose = ShellUtils.readLine(session, String.format("Choose a number or apply filter (case insensitive): %d: ", i), false);
if (Strings.isNullOrBlank(choose)) {
// user pressed enter so we select the last
choose = "" + i;
}
try {
int no = Integer.valueOf(choose);
// is the number within range
if (no >= 1 && no <= archetypes.size()) {
archetype = archetypes.get(no - 1);
break;
} else {
System.out.println("Number " + no + " out of range. Please try again!");
continue;
}
} catch (NumberFormatException e) {
// no its a filter, so we use this as filter, and show the list again
archetypeOrFilter = choose;
choosing = false;
archetype = null;
}
}
}
// okay we have selected an archetype now
File archetypeFile = fetchArchetype(archetype);
if (archetypeFile == null || !archetypeFile.exists()) {
System.err.println("No archetype found for \"" + archetypeOrFilter + "\" coordinates");
return null;
}
System.out.println("----------------------------------------------------------------------------");
System.out.println("Using archetype: " + archetype.artifactId);
String defaultGroupId = "io.fabric8";
String defaultArtifactId = archetype.artifactId + "-example";
String defaultVersion = "1.0-SNAPSHOT";
String defaultName = archetype.name;
String defaultDescription = isNotBlank(archetype.description) ? archetype.description : "";
System.out.println("----- Configure archetype -----");
String groupId = ShellUtils.readLine(session, String.format("Define value for property 'groupId' (%s): ", defaultGroupId), false);
String artifactId = ShellUtils.readLine(session, String.format("Define value for property 'artifactId' (%s): ", defaultArtifactId), false);
String version = ShellUtils.readLine(session, String.format("Define value for property 'version' (%s): ", defaultVersion), false);
groupId = isNullOrBlank(groupId) ? defaultGroupId : groupId;
artifactId = isNullOrBlank(artifactId) ? defaultArtifactId : artifactId;
version = isNullOrBlank(version) ? defaultVersion : version;
String defaultPackageName = (groupId + "." + artifactId).replaceAll("-", ".");
String packageName = ShellUtils.readLine(session, String.format("Define value for property 'package' (%s): ", defaultPackageName), false);
// use artifact id as default directory name (maven does this also)
String defaultDirectoryName = isNullOrBlank(artifactId) ? defaultArtifactId : artifactId;
directory = ShellUtils.readLine(session, String.format("Define value for property 'directoryName' (%s): ", defaultDirectoryName), false);
packageName = isNullOrBlank(packageName) ? defaultPackageName : packageName;
directory = isNullOrBlank(directory) ? artifactId : directory;
String name = ShellUtils.readLine(session, String.format("Define value for property 'name' (%s): ", defaultName), false);
String description = ShellUtils.readLine(session, String.format("Define value for property 'description' (%s): ", defaultDescription), false);
// use null to indicate we want out of the box description
name = isNullOrBlank(name) ? null : name;
description = isNullOrBlank(description) ? null : description;
File childDir = new File(target, directory);
ArchetypeHelper helper = new ArchetypeHelper(archetypeFile, childDir, groupId, artifactId, version, name, description);
helper.setPackageName(packageName);
Map<String, String> properties = helper.parseProperties();
// if we have fabric8.profile as a property then lets configured it now, as its mandatory
// and use artifactId as its default suggested value
String profile = null;
if (properties.containsKey("fabric8-profile")) {
profile = properties.remove("fabric8-profile");
String defaultProfile = isNullOrBlank(profile) ? artifactId : profile;
String p = ShellUtils.readLine(session, String.format("Define value for property 'fabric8.profile' (%s): ", defaultProfile), false);
profile = isNullOrBlank(p) ? defaultProfile : p;
}
// show additional properties and ask to use them as-is
boolean mustChoose = false;
if (!properties.isEmpty()) {
// check if we must choose if there is an empty value or a value that has a ${ } token so we dont have a default value
for (String value : properties.values()) {
if (isNullOrBlank(value) || value.contains("$")) {
mustChoose = true;
break;
}
}
if (!mustChoose) {
System.out.println("----- Additional properties -----");
for (String key : properties.keySet()) {
System.out.println(String.format("Using property '%s' (%s): ", key, properties.get(key)));
}
}
boolean choosing = true;
while (mustChoose || choosing) {
String confirm = null;
if (!mustChoose) {
confirm = ShellUtils.readLine(session, "Confirm additional properties configuration: (Y): ", false);
confirm = isNullOrBlank(confirm) ? "Y" : confirm;
}
if (mustChoose || !"Y".equalsIgnoreCase(confirm)) {
// ask for replacement properties suggesting the defaults
if (!properties.isEmpty()) {
System.out.println("----- Configure additional properties -----");
for (String key : properties.keySet()) {
String value = properties.get(key);
// if the value is empty or a token, then do not show any default value
if (isNullOrBlank(value) || value.contains("$")) {
value = "";
}
String p = ShellUtils.readLine(session, String.format("Define value for property '%s' (%s): ", key, value), false);
p = isNullOrBlank(p) ? value : p;
properties.put(key, p);
}
}
mustChoose = false;
} else {
choosing = false;
}
}
}
// remover to include the profile back into properties
if (profile != null) {
properties.put("fabric8-profile", profile);
}
if (!properties.isEmpty()) {
// set override properties
helper.setOverrideProperties(properties);
}
String confirm = ShellUtils.readLine(session, "Create project: (Y): ", false);
confirm = confirm == null || confirm.trim().equals("") ? "Y" : confirm;
if ("Y".equalsIgnoreCase(confirm)) {
System.out.println("----------------------------------------------------------------------------");
System.out.println(String.format("Creating project in directory: %s", childDir.getCanonicalPath()));
helper.execute();
System.out.println("Project created successfully");
System.out.println("");
} else {
System.out.println("----------------------------------------------------------------------------");
System.out.println("Creating project aborted!");
System.out.println("");
}
return null;
}
use of io.fabric8.common.util.Filter in project halyard by spinnaker.
the class LocalDebianServiceProvider method getInstallCommand.
@Override
public String getInstallCommand(DeploymentDetails deploymentDetails, GenerateService.ResolvedConfiguration resolvedConfiguration, Map<String, String> installCommands) {
Map<String, Object> bindings = new HashMap<>();
List<SpinnakerService.Type> serviceTypes = new ArrayList<>(installCommands.keySet()).stream().map(SpinnakerService.Type::fromCanonicalName).collect(Collectors.toList());
List<String> upstartNames = getLocalServices(serviceTypes).stream().filter(i -> resolvedConfiguration.getServiceSettings(i.getService()).getEnabled()).map(i -> ((LocalDebianService) i).getUpstartServiceName()).filter(Objects::nonNull).collect(Collectors.toList());
List<String> systemdServiceConfigs = upstartNames.stream().map(n -> n + ".service").collect(Collectors.toList());
List<String> serviceInstalls = serviceTypes.stream().map(t -> installCommands.get(t.getCanonicalName())).collect(Collectors.toList());
TemplatedResource resource = new StringReplaceJarResource("/debian/init.sh");
bindings.put("services", Strings.join(upstartNames, " "));
bindings.put("systemd-service-configs", Strings.join(systemdServiceConfigs, " "));
String upstartInit = resource.setBindings(bindings).toString();
BillOfMaterials.ArtifactSources artifactSources = artifactService.getArtifactSources(deploymentDetails.getDeploymentName());
resource = new StringReplaceJarResource("/debian/install.sh");
bindings = new HashMap<>();
bindings.put("prepare-environment", "true");
bindings.put("install-redis", "true");
bindings.put("debian-repository", artifactSourcesConfig.mergeWithBomSources(artifactSources).getDebianRepository());
bindings.put("install-commands", String.join("\n", serviceInstalls));
bindings.put("service-action", "restart");
bindings.put("upstart-init", upstartInit);
return resource.setBindings(bindings).toString();
}
use of io.fabric8.common.util.Filter in project fabric8-maven-plugin by fabric8io.
the class ResourceMojo method getResolvedImages.
private List<ImageConfiguration> getResolvedImages(List<ImageConfiguration> images, final Logger log) throws MojoExecutionException {
List<ImageConfiguration> ret;
ret = ConfigHelper.resolveImages(log, images, new ConfigHelper.Resolver() {
@Override
public List<ImageConfiguration> resolve(ImageConfiguration image) {
return imageConfigResolver.resolve(image, project, session);
}
}, // no filter on image name yet (TODO: Maybe add this, too ?)
null, new ConfigHelper.Customizer() {
@Override
public List<ImageConfiguration> customizeConfig(List<ImageConfiguration> configs) {
try {
GeneratorContext ctx = new GeneratorContext.Builder().config(extractGeneratorConfig()).project(project).session(session).goalFinder(goalFinder).goalName("fabric8:resource").logger(log).mode(mode).strategy(buildStrategy).useProjectClasspath(useProjectClasspath).build();
return GeneratorManager.generate(configs, ctx, true);
} catch (Exception e) {
throw new IllegalArgumentException("Cannot extract generator: " + e, e);
}
}
});
Date now = getBuildReferenceDate();
storeReferenceDateInPluginContext(now);
String minimalApiVersion = ConfigHelper.initAndValidate(ret, null, /* no minimal api version */
new ImageNameFormatter(project, now), log);
return ret;
}
use of io.fabric8.common.util.Filter in project strimzi by strimzi.
the class ControllerIT method waitForEvent.
private void waitForEvent(TestContext context, ConfigMap cm, String expectedMessage, Controller.EventType expectedType) {
waitFor(context, () -> {
List<Event> items = kubeClient.events().inNamespace(NAMESPACE).withLabels(cmPredicate.labels()).list().getItems();
List<Event> filtered = items.stream().filter(evt -> !preExistingEvents.contains(evt.getMetadata().getUid()) && "ConfigMap".equals(evt.getInvolvedObject().getKind()) && cm.getMetadata().getName().equals(evt.getInvolvedObject().getName())).collect(Collectors.toList());
LOGGER.debug("Waiting for events: {}", filtered.stream().map(evt -> evt.getMessage()).collect(Collectors.toList()));
if (!filtered.isEmpty()) {
assertEquals(1, filtered.size());
Event event = filtered.get(0);
assertEquals(expectedMessage, event.getMessage());
assertEquals(expectedType.name, event.getType());
assertNotNull(event.getInvolvedObject());
assertEquals("ConfigMap", event.getInvolvedObject().getKind());
assertEquals(cm.getMetadata().getName(), event.getInvolvedObject().getName());
return true;
} else {
return false;
}
}, timeout, "Expected an error event");
}
use of io.fabric8.common.util.Filter in project vertx-openshift-it by cescoffier.
the class Deployment method deployIfNeeded.
public static String deployIfNeeded(KubernetesClient client, String name, String path) {
if (oc(client).deploymentConfigs().withName(name).get() != null) {
System.out.println("Skipping the creation of dc/" + name);
return name;
}
ImageStream stream = findImageStream(client, name);
ensureThat("the image stream " + name + " exists in the namespace " + client.getNamespace(), () -> assertThat(stream).isNotNull());
File file = filter(Objects.requireNonNull(path), ImmutableMap.of("image", stream.getStatus().getDockerImageRepository()));
String name2 = deployIfNeeded(client, file);
assertThat(name).isEqualTo(name2);
return name;
}
Aggregations