use of io.aklivity.zilla.runtime.engine.EngineConfiguration in project zilla by aklivity.
the class ZillaStartCommand method run.
@Override
public void run() {
Runtime runtime = getRuntime();
Properties props = new Properties();
props.setProperty(ENGINE_DIRECTORY.name(), ".zilla/engine");
Path path = Paths.get(properties != null ? properties : OPTION_PROPERTIES_DEFAULT);
if (Files.exists(path) || properties != null) {
try {
props.load(Files.newInputStream(path));
} catch (IOException ex) {
System.out.println("Failed to load properties: " + path);
rethrowUnchecked(ex);
}
}
if (workers >= 0) {
props.setProperty(ENGINE_WORKERS.name(), Integer.toString(workers));
}
if (verbose) {
props.setProperty(ENGINE_VERBOSE.name(), Boolean.toString(verbose));
}
EngineConfiguration config = new EngineConfiguration(props);
Consumer<Throwable> report = exceptions ? e -> e.printStackTrace(System.err) : e -> System.err.println(e.getMessage());
try (Engine engine = Engine.builder().config(config).configURL(configURL.toURL()).errorHandler(this::onError).build()) {
engine.start().get();
System.out.println("started");
runtime.addShutdownHook(new Thread(this::onShutdown));
stop.await();
errors.forEach(report);
System.out.println("stopped");
stopped.countDown();
} catch (Throwable ex) {
System.out.println("error");
rethrowUnchecked(ex);
}
}
use of io.aklivity.zilla.runtime.engine.EngineConfiguration in project zilla by aklivity.
the class EngineRule method apply.
@Override
public Statement apply(Statement base, Description description) {
Class<?> testClass = description.getTestClass();
final String testMethod = description.getMethodName().replaceAll("\\[.*\\]", "");
try {
Configure[] configures = testClass.getDeclaredMethod(testMethod).getAnnotationsByType(Configure.class);
Arrays.stream(configures).forEach(p -> properties.setProperty(p.name(), p.value()));
Configuration config = description.getAnnotation(Configuration.class);
if (config != null) {
if (configurationRoot != null) {
String resourceName = String.format("%s/%s", configurationRoot, config.value());
configURL = testClass.getClassLoader().getResource(resourceName);
} else {
String resourceName = String.format("%s-%s", testClass.getSimpleName(), config.value());
configURL = testClass.getResource(resourceName);
}
}
cleanup();
} catch (Exception e) {
LangUtil.rethrowUnchecked(e);
}
return new Statement() {
@Override
public void evaluate() throws Throwable {
EngineConfiguration config = configuration();
final Thread baseThread = Thread.currentThread();
final List<Throwable> errors = new ArrayList<>();
final ErrorHandler errorHandler = ex -> {
errors.add(ex);
baseThread.interrupt();
};
engine = builder.config(config).configURL(configURL).errorHandler(errorHandler).build();
try {
engine.start().get();
base.evaluate();
} catch (Throwable t) {
errors.add(t);
} finally {
try {
engine.close();
} catch (Throwable t) {
errors.add(t);
} finally {
assertEmpty(errors);
}
}
}
};
}
use of io.aklivity.zilla.runtime.engine.EngineConfiguration in project zilla by aklivity.
the class EngineTest method initConfig.
@Before
public void initConfig() {
Properties properties = new Properties();
properties.put(ENGINE_DIRECTORY.name(), "target/zilla-itests");
properties.put(ENGINE_WORKERS.name(), "1");
config = new EngineConfiguration(properties);
}
use of io.aklivity.zilla.runtime.engine.EngineConfiguration in project zilla by aklivity.
the class LogCommand method main.
public static void main(String[] args) throws Exception {
final CommandLineParser parser = new DefaultParser();
Options options = new Options();
options.addOption(builder("h").longOpt("help").desc("print this message").build());
options.addOption(builder().longOpt("version").build());
options.addOption(builder("t").hasArg().required(false).longOpt("type").desc("streams* | streams-[nowait|zero|head|tail] | counters | queues | routes").build());
options.addOption(builder("f").hasArgs().required(false).longOpt("frameTypes").desc("log specific frame types only, e.g BEGIN").build());
options.addOption(builder("d").longOpt("directory").hasArg().desc("configuration directory").build());
options.addOption(builder("v").longOpt("verbose").desc("verbose").build());
options.addOption(builder("e").hasArgs().required(false).longOpt("extensionTypes").desc("log specific extension types only, e.g. tcp").build());
options.addOption(builder("i").hasArg().longOpt("interval").desc("run command continuously at interval").build());
options.addOption(builder("s").longOpt("separator").desc("include thousands separator in integer values").build());
options.addOption(builder("a").hasArg().longOpt("affinity").desc("affinity mask").build());
final CommandLine cmdline = parser.parse(options, args);
final Logger out = System.out::printf;
final boolean hasVersion = cmdline.hasOption("version");
final boolean hasDirectory = cmdline.hasOption("directory");
final boolean hasHelp = cmdline.hasOption("help");
if (hasVersion) {
out.printf("version: %s\n", LogCommand.class.getPackage().getSpecificationVersion());
}
if (hasHelp || !hasDirectory) {
if (hasHelp || !hasVersion) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("log", options);
}
} else {
String directory = cmdline.getOptionValue("directory");
boolean verbose = cmdline.hasOption("verbose");
boolean separator = cmdline.hasOption("separator");
String type = cmdline.getOptionValue("type", "streams");
final int interval = Integer.parseInt(cmdline.getOptionValue("interval", "0"));
final long affinity = Long.parseLong(cmdline.getOptionValue("affinity", Long.toString(0xffff_ffff_ffff_ffffL)));
Properties properties = new Properties();
properties.setProperty(ENGINE_DIRECTORY.name(), directory);
final EngineConfiguration config = new EngineConfiguration(new Configuration(), properties);
Runnable command = null;
final Matcher matcher = Pattern.compile("streams(?:-(?<option>[a-z]+))?").matcher(type);
if (matcher.matches()) {
final String option = matcher.group("option");
final boolean continuous = !"nowait".equals(option);
final SpyPosition position = continuous && option != null ? SpyPosition.valueOf(option.toUpperCase()) : SpyPosition.ZERO;
final String[] frameTypes = cmdline.getOptionValues("frameTypes");
final String[] extensionTypes = cmdline.getOptionValues("extensionTypes");
final Predicate<String> hasExtensionType = extensionTypes == null && !verbose ? t -> false : s -> verbose || Arrays.asList(extensionTypes).contains(s);
final Predicate<String> hasFrameTypes = frameTypes == null ? t -> true : Arrays.asList(frameTypes)::contains;
command = new LogStreamsCommand(config, out, hasFrameTypes, hasExtensionType, verbose, continuous, affinity, position);
} else if ("buffers".equals(type)) {
command = new LogBuffersCommand(config, out, verbose);
} else if ("budgets".equals(type)) {
command = new LogBudgetsCommand(config, out, verbose, affinity);
} else if ("counters".equals(type)) {
command = new LogCountersCommand(config, out, verbose, separator);
} else if ("queues".equals(type)) {
command = new LogQueueDepthCommand(config, out, verbose, separator);
}
do {
command.run();
Thread.sleep(TimeUnit.SECONDS.toMillis(interval));
} while (interval > 0);
}
}
use of io.aklivity.zilla.runtime.engine.EngineConfiguration in project zilla by aklivity.
the class EngineRule method cleanup.
private void cleanup() throws IOException {
EngineConfiguration config = configuration();
Path directory = config.directory();
Path cacheDirectory = config.cacheDirectory();
if (clean && exists(directory)) {
Files.walk(directory, FOLLOW_LINKS).filter(this::shouldDeletePath).map(Path::toFile).forEach(File::delete);
}
if (clean && exists(cacheDirectory)) {
Files.walk(cacheDirectory).map(Path::toFile).forEach(File::delete);
}
}
Aggregations