IntenseFinance/nosqlbench
3
0
Fork 0
mirror of https://github.com/nosqlbench/nosqlbench.git synced 2025-02-25 18:55:28 -06:00
Code Issues Packages Projects Releases Wiki Activity

change all references of context to container

Browse Source
This commit is contained in:
Jonathan Shook 2023-12-07 09:40:40 -06:00
parent 2f34a6e44d
commit e1f9545abd
100 changed files with 412 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adapter-cqld4/pom.xml
View File

@ -113,7 +113,7 @@
<plugin>
<groupId>org.antlr</groupId>
<artifactId>antlr4-maven-plugin</artifactId>
<version>4.13.0</version>
<version>4.13.1</version>
<configuration>
<sourceDirectory>src/main/java/io/nosqlbench/cqlgen/grammars
</sourceDirectory>

3
adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java
View File

@ -20,7 +20,8 @@ import com.codahale.metrics.Timer;
import groovy.lang.Binding;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.evalcontext.*;
import io.nosqlbench.adapters.api.evalctx.*;
import io.nosqlbench.adapters.api.evalctx.*;
import io.nosqlbench.adapters.api.metrics.ThreadLocalNamedTimers;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.nb.api.labels.NBLabels;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/OpDispenser.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.adapters.api.activityimpl;
import io.nosqlbench.adapters.api.evalcontext.CycleFunction;
import io.nosqlbench.adapters.api.evalctx.CycleFunction;
import java.util.function.LongFunction;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/CompoundCycleFunction.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/CompoundCycleFunction.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import java.util.ArrayList;
import java.util.Arrays;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/CycleFunction.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/CycleFunction.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import java.util.function.LongFunction;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/CycleFunctions.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/CycleFunctions.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import java.util.List;
import java.util.function.BinaryOperator;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/ExpressionDetails.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/ExpressionDetails.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
public interface ExpressionDetails {
String getExpressionDetails();

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/GroovyBooleanCycleFunction.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/GroovyBooleanCycleFunction.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import groovy.lang.Binding;
import io.nosqlbench.virtdata.core.templates.ParsedTemplateString;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/GroovyCycleFunction.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/GroovyCycleFunction.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/GroovyObjectEqualityFunction.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/GroovyObjectEqualityFunction.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import groovy.lang.Binding;
import io.nosqlbench.virtdata.core.templates.ParsedTemplateString;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/ResultMismatchError.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/ResultMismatchError.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import java.io.Serializable;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/ResultVerificationError.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/ResultVerificationError.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
import java.io.Serializable;

2
adapters-api/src/main/java/io/nosqlbench/adapters/api/evalcontext/VariableInjectable.java → adapters-api/src/main/java/io/nosqlbench/adapters/api/evalctx/VariableInjectable.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.adapters.api.evalcontext;
package io.nosqlbench.adapters.api.evalctx;
/**
* Implementors of this type can have variables set on them for later use.

2
adapters-api/src/test/java/io/nosqlbench/adapters/api/evalcontext/CompoundCycleFunctionTest.java
View File

@ -16,6 +16,8 @@
package io.nosqlbench.adapters.api.evalcontext;
import io.nosqlbench.adapters.api.evalctx.CompoundCycleFunction;
import io.nosqlbench.adapters.api.evalctx.GroovyCycleFunction;
import org.junit.jupiter.api.Test;
import java.util.List;

2
adapters-api/src/test/java/io/nosqlbench/adapters/api/evalcontext/GroovyBooleanCycleFunctionTest.java
View File

@ -17,6 +17,8 @@
package io.nosqlbench.adapters.api.evalcontext;
import groovy.lang.MissingPropertyException;
import io.nosqlbench.adapters.api.evalctx.GroovyBooleanCycleFunction;
import io.nosqlbench.adapters.api.evalctx.GroovyCycleFunction;
import io.nosqlbench.virtdata.core.templates.ParsedTemplateString;
import org.junit.jupiter.api.Test;

8
engine-cli/src/main/java/io/nosqlbench/engine/cli/NBJavaNativeResolver.java
View File

@ -19,19 +19,15 @@ package io.nosqlbench.engine.cli;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.cmdstream.CmdType;
import io.nosqlbench.engine.cmdstream.NBJavaCommandLoader;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.engine.core.lifecycle.session.NBInvokableResolver;
import io.nosqlbench.nb.annotations.Service;
import io.nosqlbench.nb.api.components.NBComponent;
import java.util.List;
@Service(value= NBInvokableResolver.class,selector = "java")
public class NBJavaNativeResolver implements NBInvokableResolver {
@Override
public NBInvokableCommand resolve(Cmd cmd, NBBufferedCommandContext parent, String phaseName) {
public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) {
return switch (cmd.getCmdType()) {
case CmdType.indirect -> NBJavaCommandLoader.init(cmd.getArgValue("_impl"), parent, phaseName, cmd.getTargetContext());
case CmdType.java -> NBJavaCommandLoader.init(cmd.getArgValue("class"), parent, phaseName, cmd.getTargetContext());

6
engine-cli/src/test/java/io/nosqlbench/engine/cli/NBCLIScenarioPreprocessorTest.java
View File

@ -106,7 +106,7 @@ public class NBCLIScenarioPreprocessorTest {
assertThat(cmds.size()).isEqualTo(1);
assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of(
"alias", "with_template",
"context", "template_test",
"container", "template_test",
"cycles", "20",
"cycles-test", "20",
"driver", "stdout",
@ -123,7 +123,7 @@ public class NBCLIScenarioPreprocessorTest {
assertThat(cmds.size()).isEqualTo(1);
assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of(
"alias", "schema",
"context", "schema_only",
"container", "schema_only",
"cycles-test", "20",
"driver", "stdout",
"labels", "workload:scenario_test,scenario:schema_only",
@ -177,7 +177,7 @@ public class NBCLIScenarioPreprocessorTest {
assertThat(cmds.size()).isEqualTo(1);
assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of(
"alias", "schema",
"context", "schema_only",
"container", "schema_only",
"cycles-test", "20",
"driver", "stdout",
"labels", "workload:scenario_test,scenario:schema_only",

4
engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/Activity.java
View File

@ -108,7 +108,7 @@ public interface Activity extends Comparable<Activity>, ActivityDefObserver, Pro
/**
* Set the cycle rate limiter for this activity. This method should only
* be used in a non-concurrent context. Otherwise, the supplier version
* be used non-concurrently. Otherwise, the supplier version
* {@link #getCycleRateLimiter(Supplier)} should be used.
* @param rateLimiter The cycle {@link RateLimiter} for this activity
*/
@ -133,7 +133,7 @@ public interface Activity extends Comparable<Activity>, ActivityDefObserver, Pro
/**
* Set the stride rate limiter for this activity. This method should only
* be used in a non-concurrent context. Otherwise, the supplier version
* be used non-concurrently. Otherwise, the supplier version
* {@link #getStrideRateLimiter(Supplier)}} should be used.
* @param rateLimiter The stride {@link RateLimiter} for this activity.
*/

2
engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/AsyncAction.java
View File

@ -56,7 +56,7 @@ public interface AsyncAction<D> extends Action {
* be started (according to the configured concurrency limits),
* then it can signal such by returning true from this method.
*
* @param opc The op context that holds state for this operation
* @param opc The op ctx that holds state for this operation
* @return true, if the action is ready immediately for another operation
*/
boolean enqueue(TrackedOp<D> opc);

2
engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java
View File

@ -20,7 +20,7 @@ import com.codahale.metrics.Histogram;
import com.codahale.metrics.Timer;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*;
import io.nosqlbench.adapters.api.evalcontext.CycleFunction;
import io.nosqlbench.adapters.api.evalctx.CycleFunction;
import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef;
import io.nosqlbench.nb.api.errors.ResultVerificationError;
import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver;

4
engine-core/src/main/java/io/nosqlbench/engine/api/scenarios/NBCLIScenarioPreprocessor.java
View File

@ -204,8 +204,8 @@ public class NBCLIScenarioPreprocessor {
buildingCmd.put("alias", "alias=" + WORKLOAD_SCENARIO_STEP);
}
if (!buildingCmd.containsKey("context")) {
buildingCmd.put("context","context="+scenarioName);
if (!buildingCmd.containsKey("container")) {
buildingCmd.put("container","container="+scenarioName);
}
if (!buildingCmd.containsKey("step")) {
buildingCmd.put("step","step="+stepName);

14
engine-core/src/main/java/io/nosqlbench/engine/api/scripting/GraalJsEvaluator.java
View File

@ -21,15 +21,15 @@ import org.graalvm.polyglot.*;
public class GraalJsEvaluator<T> implements ExprEvaluator<T> {
private final Class<T> resultType;
private Context context;
private Context ctx;
private Source script;
public GraalJsEvaluator(Class<T> resultType) {
this.resultType = resultType;
}
private Context getContext() {
if (context == null) {
private Context getCtx() {
if (ctx == null) {
Context.Builder contextSettings = Context.newBuilder("js")
.allowHostAccess(HostAccess.ALL)
.allowNativeAccess(true)
@ -43,14 +43,14 @@ public class GraalJsEvaluator<T> implements ExprEvaluator<T> {
.allowPolyglotAccess(PolyglotAccess.ALL)
.option("js.ecmascript-version", "2020")
.option("js.nashorn-compat", "true");
context = contextSettings.build();
ctx = contextSettings.build();
}
return context;
return ctx;
}
@Override
public T eval() {
Value result = getContext().eval(this.script);
Value result = getCtx().eval(this.script);
T asType = result.as(resultType);
return asType;
}
@ -63,7 +63,7 @@ public class GraalJsEvaluator<T> implements ExprEvaluator<T> {
@Override
public ExprEvaluator<T> put(String varName, Object var) {
getContext().getBindings("js").putMember(varName, var);
getCtx().getBindings("js").putMember(varName, var);
return this;
}
}

6
engine-core/src/main/java/io/nosqlbench/engine/cmdstream/Cmd.java
View File

@ -16,13 +16,11 @@
package io.nosqlbench.engine.cmdstream;
import io.nosqlbench.engine.core.lifecycle.session.CmdParser;
import io.nosqlbench.nb.api.errors.BasicError;
import jakarta.validation.constraints.NotNull;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.*;
/**
@ -44,8 +42,8 @@ public class Cmd {
return targetContextName;
}
public Cmd forTargetContext(String contextName, String stepName) {
return new Cmd(cmdType, cmdArgs, contextName, stepName);
public Cmd forContainer(String containerName, String stepName) {
return new Cmd(cmdType, cmdArgs, containerName, stepName);
}

2
engine-core/src/main/java/io/nosqlbench/engine/cmdstream/CmdType.java
View File

@ -32,7 +32,7 @@ public enum CmdType {
await(CmdParam.of("activity")),
waitMillis(CmdParam.of("ms", Long::parseLong)),
fragment(CmdParam.ofFreeform("fragment")),
context(CmdParam.of("name")),
container(CmdParam.of("name")),
indirect(CmdParam.of("indirect"));
private final CmdParam<?>[] positional;

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivitiesExceptionHandler.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.engine.core.lifecycle.activity;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -24,9 +24,9 @@ public class ActivitiesExceptionHandler implements Thread.UncaughtExceptionHandl
private static final Logger logger = LogManager.getLogger(ActivitiesExceptionHandler.class);
private final ContextActivitiesController controller;
private final ContainerActivitiesController controller;
public ActivitiesExceptionHandler(ContextActivitiesController controller) {
public ActivitiesExceptionHandler(ContainerActivitiesController controller) {
this.controller = controller;
logger.debug(() -> "Activities exception handler starting up for executor '" + this.controller + "'");
}

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivitiesProgressIndicator.java
View File

@ -20,9 +20,9 @@ import io.nosqlbench.engine.api.activityapi.core.RunState;
import io.nosqlbench.engine.api.activityapi.core.progress.ProgressMeterDisplay;
import io.nosqlbench.engine.api.activityapi.core.progress.StateCapable;
import io.nosqlbench.engine.api.metrics.IndicatorMode;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.nb.api.engine.metrics.PeriodicRunnable;
import io.nosqlbench.nb.api.engine.util.Unit;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -35,14 +35,14 @@ public class ActivitiesProgressIndicator implements Runnable {
private final static Logger logger = LogManager.getLogger("PROGRESS");
private final String indicatorSpec;
private final ContextActivitiesController sc;
private final ContainerActivitiesController sc;
private PeriodicRunnable<ActivitiesProgressIndicator> runnable;
private IndicatorMode indicatorMode = IndicatorMode.console;
private final Set<String> seen = new HashSet<>();
private long intervalMillis = 1L;
public ActivitiesProgressIndicator(ContextActivitiesController sc, String indicatorSpec) {
public ActivitiesProgressIndicator(ContainerActivitiesController sc, String indicatorSpec) {
this.sc = sc;
this.indicatorSpec = indicatorSpec;
start();

10
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/ActivityBindings.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/ActivityBindings.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef;
import org.graalvm.polyglot.Value;
@ -28,11 +28,11 @@ import java.util.stream.Collectors;
*/
public class ActivityBindings implements Bindings, ProxyObject {
private final ContextActivitiesController scenario;
private final ContainerActivitiesController scenario;
private final Map<String, Bindings> elementMap = new HashMap<String, Bindings>();
public ActivityBindings(ContextActivitiesController contextActivitiesController) {
this.scenario = contextActivitiesController;
public ActivityBindings(ContainerActivitiesController containerActivitiesController) {
this.scenario = containerActivitiesController;
}
@Override
@ -41,7 +41,7 @@ public class ActivityBindings implements Bindings, ProxyObject {
}
@Override
public void putAll(Map<? extends String, ? extends Object> toMerge) {
public void putAll(Map<? extends String, ?> toMerge) {
throw new RuntimeException("ScenarioBindings do not allow putAll(...)");
}

8
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/ContextActivitiesController.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/ContainerActivitiesController.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef;
import io.nosqlbench.nb.api.engine.activityimpl.ParameterMap;
@ -40,9 +40,9 @@ import java.util.stream.Collectors;
* A ScenarioController provides a way to start Activities,
* modify them while running, and forceStopMotors, pause or restart them.
*/
public class ContextActivitiesController extends NBBaseComponent {
public class ContainerActivitiesController extends NBBaseComponent {
private static final Logger logger = LogManager.getLogger(ContextActivitiesController.class);
private static final Logger logger = LogManager.getLogger(ContainerActivitiesController.class);
private static final Logger scenariologger = LogManager.getLogger("SCENARIO");
private final ActivityLoader activityLoader;
@ -51,7 +51,7 @@ public class ContextActivitiesController extends NBBaseComponent {
private final ExecutorService executorService;
public ContextActivitiesController(NBComponent parent) {
public ContainerActivitiesController(NBComponent parent) {
super(parent);
this.activityLoader = new ActivityLoader();
ActivitiesExceptionHandler exceptionHandler = new ActivitiesExceptionHandler(this);

8
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/ContextBuilderFacets.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/ContainerBuilderFacets.java
View File

@ -1,4 +1,4 @@
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
/*
* Copyright (c) 2022 nosqlbench
@ -24,7 +24,7 @@ import java.io.PrintWriter;
import java.io.Reader;
import java.util.Map;
public interface ContextBuilderFacets {
public interface ContainerBuilderFacets {
public interface ALL extends
WantsName,
WantsController,
@ -41,7 +41,7 @@ public interface ContextBuilderFacets {
}
public interface WantsController extends WantsStdin, WantsIoType {
public WantsStdin controller(ContextActivitiesController controller);
public WantsStdin controller(ContainerActivitiesController controller);
}
@ -82,7 +82,7 @@ public interface ContextBuilderFacets {
}
public interface CanBuild {
NBBufferedCommandContext build(NBComponent forComponent);
NBBufferedContainer build(NBComponent forComponent);
}
}

2
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/DiagReader.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/DiagReader.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import java.io.CharArrayWriter;
import java.io.IOException;

2
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/DiagWriter.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/DiagWriter.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import java.io.PrintWriter;
import java.io.Writer;

2
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/FanWriter.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/FanWriter.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import org.jetbrains.annotations.NotNull;

3
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/InterjectingCharArrayWriter.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/InterjectingCharArrayWriter.java
View File

@ -14,14 +14,13 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import org.jetbrains.annotations.NotNull;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.Writer;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class InterjectingCharArrayWriter extends CharArrayWriter {

48
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/NBBufferedCommandContext.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/NBBufferedContainer.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import io.nosqlbench.engine.core.annotation.Annotators;
import io.nosqlbench.engine.core.lifecycle.activity.ActivitiesProgressIndicator;
@ -38,12 +38,12 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
public class NBBufferedCommandContext extends NBBaseComponent implements NBCommandContext {
public class NBBufferedContainer extends NBBaseComponent implements NBContainer {
private final static Logger logger = LogManager.getLogger(NBBufferedCommandContext.class);
private final ContextActivitiesController controller;
private final static Logger logger = LogManager.getLogger(NBBufferedContainer.class);
private final ContainerActivitiesController controller;
private final ActivitiesProgressIndicator activitiesProgressIndicator;
private ContextShutdownHook contextShutdownHook;
private ContextShutdownHook containerShutdownHook;
private long startedAtMillis;
private Exception error;
private long endedAtMillis;
@ -60,10 +60,10 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
private DiagWriter stderrBuffer;
private DiagReader stdinBuffer;
public NBBufferedCommandContext(NBComponent parent, String name, IOType ioTypes) {
super(parent, NBLabels.forKV("context",name));
public NBBufferedContainer(NBComponent parent, String name, IOType ioTypes) {
super(parent, NBLabels.forKV("container",name));
this.iotype = ioTypes;
this.controller = new ContextActivitiesController(this);
this.controller = new ContainerActivitiesController(this);
switch (iotype) {
case traced:
@ -83,9 +83,9 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
break;
}
this.contextShutdownHook = new ContextShutdownHook(this);
this.containerShutdownHook = new ContextShutdownHook(this);
Runtime.getRuntime().addShutdownHook(this.contextShutdownHook);
Runtime.getRuntime().addShutdownHook(this.containerShutdownHook);
Annotators.recordAnnotation(
Annotation.newBuilder()
@ -100,7 +100,7 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
@Override
public ContextActivitiesController controller() {
public ContainerActivitiesController controller() {
return controller;
}
@ -123,13 +123,13 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
return this.stdoutBuffer.getTimedLog() + this.stderrBuffer.getTimedLog();
}
public NBCommandContext asFixtures() {
return (NBCommandContext) this;
public NBContainer asFixtures() {
return (NBContainer) this;
}
public static ContextBuilderFacets.WantsName builder() {
return new NBScenarioContextBuilder();
public static ContainerBuilderFacets.WantsName builder() {
return new NBScenarioContainerBuilder();
}
@Override
@ -168,11 +168,11 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
// ignore
// } else {
//
// RuntimeException error = new RuntimeException("Unrecognizable type to set context vars with:" + object.getClass().getCanonicalName());
// RuntimeException error = new RuntimeException("Unrecognizable type to set container vars with:" + object.getClass().getCanonicalName());
// logger.error(error);
//// throw new RuntimeException("Unrecognizable type to set context vars with:" + object.getClass().getCanonicalName());
//// throw new RuntimeException("Unrecognizable type to set container vars with:" + object.getClass().getCanonicalName());
} else {
logger.debug("no object was provided to set the context result");
logger.debug("no object was provided to set the container result");
}
return safeCmdResult;
@ -180,7 +180,7 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
@Override
public void doShutdown() {
NBCommandContext.super.doShutdown();
NBContainer.super.doShutdown();
}
@Override
@ -190,11 +190,11 @@ public class NBBufferedCommandContext extends NBBaseComponent implements NBComma
@Override
public void beforeDetach() {
// TODO, shutdown hooks need to be moved to context
Runtime.getRuntime().removeShutdownHook(this.contextShutdownHook);
final var retiringScenarioShutdownHook = this.contextShutdownHook;
this.contextShutdownHook = null;
// TODO, shutdown hooks need to be moved to container
Runtime.getRuntime().removeShutdownHook(this.containerShutdownHook);
final var retiringScenarioShutdownHook = this.containerShutdownHook;
this.containerShutdownHook = null;
retiringScenarioShutdownHook.run();
this.logger.debug("removing context shutdown hook");
this.logger.debug("removing container shutdown hook");
}
}

2
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/NBCommandParams.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/NBCommandParams.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

12
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/NBCommandContext.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/NBContainer.java
View File

@ -14,27 +14,25 @@
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import os.CommandResult;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
public interface NBCommandContext extends NBComponent, BiFunction<NBInvokableCommand,NBCommandParams, NBCommandResult> {
public interface NBContainer extends NBComponent, BiFunction<NBInvokableCommand,NBCommandParams, NBCommandResult> {
// ScenarioPhaseParams params();
ContextActivitiesController controller();
ContainerActivitiesController controller();
PrintWriter out();
PrintWriter err();
Reader in();
public static ContextBuilderFacets.WantsName builder() {
return new NBScenarioContextBuilder();
public static ContainerBuilderFacets.WantsName builder() {
return new NBScenarioContainerBuilder();
}
default void doShutdown() {

42
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/NBScenarioContextBuilder.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/NBScenarioContainerBuilder.java
View File

@ -1,4 +1,4 @@
package io.nosqlbench.engine.core.lifecycle.scenario.context;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
/*
* Copyright (c) 2022 nosqlbench
@ -25,74 +25,74 @@ import java.io.PrintWriter;
import java.io.Reader;
import java.util.Map;
public class NBScenarioContextBuilder implements ContextBuilderFacets.ALL {
public class NBScenarioContainerBuilder implements ContainerBuilderFacets.ALL {
private Map<String,String> params = Map.of();
private ContextActivitiesController controller;
private ContainerActivitiesController controller;
private PrintWriter out = new PrintWriter(System.out);
private PrintWriter err = new PrintWriter(System.err);
private Reader in = new InputStreamReader(System.in);
private NBBufferedCommandContext.IOType iotype = NBBufferedCommandContext.IOType.traced;
private String contextName;
private NBBufferedContainer.IOType iotype = NBBufferedContainer.IOType.traced;
private String containerName;
public NBScenarioContextBuilder() {}
public NBBufferedCommandContext build(NBComponent contextParentComponent) {
return new NBBufferedCommandContext(contextParentComponent,contextName,iotype);
public NBScenarioContainerBuilder() {}
public NBBufferedContainer build(NBComponent contextParentComponent) {
return new NBBufferedContainer(contextParentComponent, containerName,iotype);
}
@Override
public NBScenarioContextBuilder controller(ContextActivitiesController controller) {
public NBScenarioContainerBuilder controller(ContainerActivitiesController controller) {
this.controller = controller;
return this;
}
@Override
public NBScenarioContextBuilder out(PrintWriter out) {
public NBScenarioContainerBuilder out(PrintWriter out) {
this.out = out;
return this;
}
@Override
public ContextBuilderFacets.WantsParams err(PrintWriter err) {
public ContainerBuilderFacets.WantsParams err(PrintWriter err) {
this.err = err;
return this;
}
@Override
public NBScenarioContextBuilder in(Reader in) {
public NBScenarioContainerBuilder in(Reader in) {
this.in = in;
return this;
}
@Override
public NBScenarioContextBuilder params(Map<String, String> params) {
public NBScenarioContainerBuilder params(Map<String, String> params) {
this.params=params;
return this;
}
@Override
public ContextBuilderFacets.WantsParams virtualIO() {
this.iotype= NBBufferedCommandContext.IOType.virtual;
public ContainerBuilderFacets.WantsParams virtualIO() {
this.iotype= NBBufferedContainer.IOType.virtual;
return this;
}
@Override
public ContextBuilderFacets.WantsParams connectedIO() {
this.iotype = NBBufferedCommandContext.IOType.connected;
public ContainerBuilderFacets.WantsParams connectedIO() {
this.iotype = NBBufferedContainer.IOType.connected;
return this;
}
@Override
public ContextBuilderFacets.WantsParams tracedIO() {
this.iotype= NBBufferedCommandContext.IOType.traced;
public ContainerBuilderFacets.WantsParams tracedIO() {
this.iotype= NBBufferedContainer.IOType.traced;
return this;
}
@Override
public ContextBuilderFacets.WantsController name(String contextName) {
this.contextName = contextName;
public ContainerBuilderFacets.WantsController name(String contextName) {
this.containerName = contextName;
return this;
}
}

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/context/ScriptEnvBuffer.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/container/ScriptEnvBuffer.java
View File

@ -13,11 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.nosqlbench.engine.core.lifecycle.scenario.context;
import io.nosqlbench.engine.core.lifecycle.scenario.context.DiagReader;
import io.nosqlbench.engine.core.lifecycle.scenario.context.DiagWriter;
import io.nosqlbench.engine.core.lifecycle.scenario.context.InterjectingCharArrayWriter;
package io.nosqlbench.engine.core.lifecycle.scenario.container;
import javax.script.SimpleScriptContext;
import java.io.Reader;

10
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/execution/ContextShutdownHook.java
View File

@ -16,19 +16,19 @@
package io.nosqlbench.engine.core.lifecycle.scenario.execution;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
public class ContextShutdownHook extends Thread {
private final NBCommandContext context;
private final NBContainer container;
public ContextShutdownHook(NBCommandContext context) {
this.context = context;
public ContextShutdownHook(NBContainer container) {
this.container = container;
}
@Override
public void run() {
context.doShutdown();
container.doShutdown();
}
}

20
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/execution/NBBaseCommand.java
View File

@ -16,16 +16,10 @@
package io.nosqlbench.engine.core.lifecycle.scenario.execution;
import io.nosqlbench.nb.api.annotations.Annotation;
import io.nosqlbench.nb.api.annotations.Layer;
import io.nosqlbench.nb.api.labels.NBLabels;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.nb.api.components.NBComponentErrorHandler;
import io.nosqlbench.engine.core.annotation.Annotators;
import io.nosqlbench.engine.core.lifecycle.activity.ActivitiesProgressIndicator;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -37,12 +31,12 @@ public abstract class NBBaseCommand extends NBInvokableCommand {
private final String targetScenario;
protected Logger logger = LogManager.getLogger("COMMAND");
public NBBaseCommand(NBBufferedCommandContext parentComponent, String stepName, String targetScenario) {
public NBBaseCommand(NBBufferedContainer parentComponent, String stepName, String targetScenario) {
super(parentComponent, NBLabels.forKV("step", stepName));
this.targetScenario = targetScenario;
}
public NBBaseCommand(NBBufferedCommandContext parentComponent, String commandLabel) {
public NBBaseCommand(NBBufferedContainer parentComponent, String commandLabel) {
this(parentComponent, commandLabel, "_testing_");
}
@ -55,7 +49,7 @@ public abstract class NBBaseCommand extends NBInvokableCommand {
}
@Override
public final Object apply(NBBufferedCommandContext sctx, NBCommandParams params) {
public final Object apply(NBBufferedContainer sctx, NBCommandParams params) {
return invoke(params, sctx.out(), sctx.err(), sctx.in(), sctx.controller());
}
@ -69,7 +63,7 @@ public abstract class NBBaseCommand extends NBInvokableCommand {
PrintWriter stdout,
PrintWriter stderr,
Reader stdin,
ContextActivitiesController controller
ContainerActivitiesController controller
);

4
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/execution/NBCommandInfo.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.engine.core.lifecycle.scenario.execution;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.nb.api.components.NBComponent;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -37,7 +37,7 @@ public abstract class NBCommandInfo {
public NBInvokableCommand create(NBComponent parent, String cmdName, String ctxName) {
Constructor<? extends NBInvokableCommand> cmdCtor;
try {
cmdCtor = getType().getConstructor(NBBufferedCommandContext.class, String.class, String.class);
cmdCtor = getType().getConstructor(NBBufferedContainer.class, String.class, String.class);
return cmdCtor.newInstance(parent, cmdName, ctxName);
} catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
throw new RuntimeException("Unable to instantiate command via ctor(parent,name,ctx): " + e,e);

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/execution/NBCommandResult.java
View File

@ -17,7 +17,7 @@
package io.nosqlbench.engine.core.lifecycle.scenario.execution;
import io.nosqlbench.engine.core.lifecycle.ExecutionResult;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import java.util.function.Supplier;
@ -25,11 +25,11 @@ public class NBCommandResult implements Supplier<ExecutionResult> {
private final long startedAt;
private final long endedAt;
private final Exception exception;
private final NBBufferedCommandContext fixtures;
private final NBBufferedContainer fixtures;
private Object resultObject;
public NBCommandResult(NBBufferedCommandContext fixtures, long start, long end, Exception exception) {
public NBCommandResult(NBBufferedContainer fixtures, long start, long end, Exception exception) {
this.fixtures = fixtures;
this.startedAt=start;
this.endedAt=end;

18
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/execution/NBInvokableCommand.java
View File

@ -16,35 +16,33 @@
package io.nosqlbench.engine.core.lifecycle.scenario.execution;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.api.components.NBBaseComponent;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.nb.api.labels.NBLabels;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Objects;
import java.util.function.BiFunction;
public abstract class NBInvokableCommand extends NBBaseComponent implements BiFunction<NBBufferedCommandContext, NBCommandParams, Object> {
public abstract class NBInvokableCommand extends NBBaseComponent implements BiFunction<NBBufferedContainer, NBCommandParams, Object> {
private static final Logger logger = LogManager.getLogger(NBInvokableCommand.class);
public NBInvokableCommand(NBBufferedCommandContext parentComponent, NBLabels componentSpecificLabelsOnly) {
public NBInvokableCommand(NBBufferedContainer parentComponent, NBLabels componentSpecificLabelsOnly) {
super(parentComponent, componentSpecificLabelsOnly);
}
@Override
public abstract Object apply(NBBufferedCommandContext nbBufferedCommandContext, NBCommandParams nbCommandParams);
public abstract Object apply(NBBufferedContainer nbBufferedContainer, NBCommandParams nbCommandParams);
public NBCommandResult invokeSafe(NBBufferedCommandContext context, NBCommandParams params) {
public NBCommandResult invokeSafe(NBBufferedContainer container, NBCommandParams params) {
Object resultObject = null;
Exception exception = null;
long startAt = System.currentTimeMillis();
NBCommandResult result = null;
try {
logger.debug("invoking command: " + this);
resultObject=apply(context, params);
resultObject=apply(container, params);
logger.debug("cmd produced: " + (resultObject==null ? "NULL" : resultObject.toString()));
} catch (Exception e) {
exception = e;
@ -52,7 +50,7 @@ public abstract class NBInvokableCommand extends NBBaseComponent implements BiFu
exception.printStackTrace(System.out);
} finally {
long endAt = System.currentTimeMillis();
result = new NBCommandResult(context, startAt, endAt, exception);
result = new NBCommandResult(container, startAt, endAt, exception);
if (resultObject!=null) {
result.setResultObject(resultObject);
}

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/script/BufferedScriptContext.java → engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/script/BufferedScriptCtx.java
View File

@ -16,19 +16,17 @@
package io.nosqlbench.engine.core.lifecycle.scenario.script;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import javax.script.SimpleScriptContext;
import java.io.Reader;
import java.io.Writer;
public class BufferedScriptContext extends SimpleScriptContext {
public class BufferedScriptCtx extends SimpleScriptContext {
Reader reader;
Writer writer;
Writer errorWriter;
public BufferedScriptContext(Writer writer, Writer errorWriter,Reader reader) {
public BufferedScriptCtx(Writer writer, Writer errorWriter, Reader reader) {
this.writer = writer;
this.errorWriter = errorWriter;
this.reader = reader;

24
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/script/NBScriptedCommand.java
View File

@ -18,12 +18,12 @@ package io.nosqlbench.engine.core.lifecycle.scenario.script;
import com.oracle.truffle.js.scriptengine.GraalJSScriptEngine;
import io.nosqlbench.engine.cmdstream.BasicScriptBuffer;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.engine.core.lifecycle.ExecutionMetricsResult;
import io.nosqlbench.engine.core.lifecycle.activity.ActivitiesProgressIndicator;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Engine.Builder;
import org.graalvm.polyglot.EnvironmentAccess;
@ -43,7 +43,7 @@ public class NBScriptedCommand extends NBBaseCommand {
private Exception error;
private ExecutionMetricsResult result;
private BufferedScriptContext context;
private BufferedScriptCtx ctx;
private GraalJSScriptEngine _engine;
public Optional<ExecutionMetricsResult> getResultIfComplete() {
@ -77,7 +77,7 @@ public class NBScriptedCommand extends NBBaseCommand {
}
public NBScriptedCommand(
NBBufferedCommandContext parentComponent,
NBBufferedContainer parentComponent,
String phaseName,
String targetScenario
) {
@ -87,7 +87,7 @@ public class NBScriptedCommand extends NBBaseCommand {
this.buffer = new BasicScriptBuffer();
}
public static NBScriptedCommand ofScripted(String name, Map<String, String> params, NBBufferedCommandContext parent, Invocation invocation) {
public static NBScriptedCommand ofScripted(String name, Map<String, String> params, NBBufferedContainer parent, Invocation invocation) {
return new NBScriptedCommand(parent, name, "default");
}
public NBScriptedCommand add(Cmd... cmds) {
@ -118,10 +118,10 @@ public class NBScriptedCommand extends NBBaseCommand {
// return this;
// }
private BufferedScriptContext initializeScriptContext(PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
BufferedScriptContext ctx = new BufferedScriptContext(stdout, stderr, stdin);
private BufferedScriptCtx initializeScriptContext(PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
BufferedScriptCtx ctx = new BufferedScriptCtx(stdout, stderr, stdin);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("this", this);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("context", context);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("container", this.ctx);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("controller", controller);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("stdout", stdout);
ctx.getBindings(ScriptContext.ENGINE_SCOPE).put("stderr", stderr);
@ -155,13 +155,13 @@ public class NBScriptedCommand extends NBBaseCommand {
}
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
try {
this.logger.debug("Initializing scripting engine for {}.", phaseName);
GraalJSScriptEngine engine = this.initializeScriptingEngine();
this.context = this.initializeScriptContext(stdout, stderr, stdin, controller);
this.ctx = this.initializeScriptContext(stdout, stderr, stdin, controller);
this.logger.debug("Running control script for {}.", phaseName);
engine.setContext(context);
engine.setContext(ctx);
engine.getContext().getBindings(ScriptContext.ENGINE_SCOPE).put("params", params);
Object resultObject = null;

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/script/ScenarioScriptShell.java
View File

@ -15,12 +15,12 @@
*/
package io.nosqlbench.engine.core.lifecycle.scenario.script;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ScriptEnvBuffer;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ScriptEnvBuffer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
public class ScenarioScriptShell extends ScriptEnvBuffer {
public ScenarioScriptShell(NBCommandContext fixtures) {
public ScenarioScriptShell(NBContainer fixtures) {
}
@Override

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/scenario/script/bindings/PolyglotScenarioController.java
View File

@ -16,8 +16,8 @@
package io.nosqlbench.engine.core.lifecycle.scenario.script.bindings;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.graalvm.polyglot.Value;
@ -29,9 +29,9 @@ public class PolyglotScenarioController {
private static final Logger logger = LogManager.getLogger("SCENARIO/POLYGLOT");
private final ContextActivitiesController controller;
private final ContainerActivitiesController controller;
public PolyglotScenarioController(ContextActivitiesController inner) {
public PolyglotScenarioController(ContainerActivitiesController inner) {
this.controller = inner;
}

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBAutoScriptResolver.java
View File

@ -19,8 +19,7 @@ package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.cmdstream.CmdArg;
import io.nosqlbench.engine.cmdstream.CmdParam;
import io.nosqlbench.engine.cmdstream.CmdType;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.engine.core.lifecycle.scenario.script.NBScriptedCommand;
import io.nosqlbench.nb.annotations.Service;
@ -29,14 +28,13 @@ import io.nosqlbench.nb.api.nbio.NBIO;
import java.nio.file.Path;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@Service(value = NBInvokableResolver.class, selector = "autojs")
public class NBAutoScriptResolver implements NBInvokableResolver {
@Override
public NBInvokableCommand resolve(Cmd cmd, NBBufferedCommandContext parent, String phaseName) {
public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) {
Optional<Content<?>> scriptfile = NBIO.local()
.searchPrefixes("scripts/auto")

32
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java
View File

@ -17,9 +17,9 @@
package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.cmdstream.*;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.api.errors.BasicError;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -31,10 +31,10 @@ public class NBCommandAssembly {
private final static Logger logger = LogManager.getLogger(NBCommandAssembly.class);
public static record CommandInvocation(NBInvokableCommand command, NBCommandParams params, String contextName) {
public static record CommandInvocation(NBInvokableCommand command, NBCommandParams params, String containerName) {
}
public static List<CommandInvocation> assemble(List<Cmd> cmds, Function<String, NBBufferedCommandContext> ctxprovider) {
public static List<CommandInvocation> assemble(List<Cmd> cmds, Function<String, NBBufferedContainer> ctxprovider) {
List<Cmd> mappedCmds = tagCommandsWithContext(cmds);
List<CommandInvocation> invocations = prepareMappedPhases(mappedCmds, ctxprovider);
return invocations;
@ -42,27 +42,27 @@ public class NBCommandAssembly {
private static List<Cmd> tagCommandsWithContext(List<Cmd> cmds) {
LinkedList<Cmd> tagged = new LinkedList<>();
String contextName = Cmd.DEFAULT_TARGET_CONTEXT;
String containerName = Cmd.DEFAULT_TARGET_CONTEXT;
for (Cmd cmd : cmds) {
if (cmd.getArgs().containsKey("context")) {
String ctx = cmd.getArgs().remove("context").getValue();
if (cmd.getArgs().containsKey("container")) {
String ctx = cmd.getArgs().remove("container").getValue();
String step = cmd.getArgs().containsKey("step") ? cmd.getArgs().remove("step").getValue() : "no-step";
tagged.add(cmd.forTargetContext(ctx, step));
} else if (cmd.getCmdType() == CmdType.context) {
contextName = cmd.getArgValue("context_name");
if (contextName.equals(Cmd.DEFAULT_TARGET_CONTEXT)) {
tagged.add(cmd.forContainer(ctx, step));
} else if (cmd.getCmdType() == CmdType.container) {
containerName = cmd.getArgValue("container");
if (containerName.equals(Cmd.DEFAULT_TARGET_CONTEXT)) {
logger.warn("You are explicitly setting the scenario name to " + Cmd.DEFAULT_TARGET_CONTEXT + "'. This is likely an error. " +
"This is the default scenario name, and if you are using different scenario names you should pick something that is different and specific.");
}
} else {
tagged.add(cmd.forTargetContext(contextName, null));
tagged.add(cmd.forContainer(containerName, null));
}
}
return new ArrayList<>(tagged);
}
private static List<CommandInvocation> prepareMappedPhases(List<Cmd> mappedCmds, Function<String, NBBufferedCommandContext> ctxProvider) {
private static List<CommandInvocation> prepareMappedPhases(List<Cmd> mappedCmds, Function<String, NBBufferedContainer> ctxProvider) {
List<CommandInvocation> parameterizedInvocations = new ArrayList<>();
NBCoreInvokableResolver core_resolver = new NBCoreInvokableResolver();
String basename = "phase_";
@ -72,7 +72,7 @@ public class NBCommandAssembly {
String phaseName = basename + count;
NBCommandParams params = switch (cmd.getCmdType()) {
case indirect, java, context -> NBCommandParams.of(cmd.getArgMap());
case indirect, java, container -> NBCommandParams.of(cmd.getArgMap());
default -> NBCommandParams.of(Map.of());
};
@ -81,8 +81,8 @@ public class NBCommandAssembly {
if (command==null) {
throw new BasicError("Found zero commands for spec;" + cmd);
}
String contextName = cmd.getTargetContext();
parameterizedInvocations.add(new CommandInvocation(command, params, contextName));
String containerName = cmd.getTargetContext();
parameterizedInvocations.add(new CommandInvocation(command, params, containerName));
}
return parameterizedInvocations;
}

19
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandInvoker.java
View File

@ -16,9 +16,9 @@
package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.nb.api.config.standard.TestComponent;
@ -26,7 +26,6 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Map;
import java.util.Objects;
public class NBCommandInvoker {
private final static Logger logger = LogManager.getLogger(NBCommandInvoker.class);
@ -35,15 +34,15 @@ public class NBCommandInvoker {
return invoke(createContext(),command,params);
}
public static NBCommandResult invoke(NBBufferedCommandContext context, NBInvokableCommand command) {
return invoke(context, command, NBCommandParams.of(Map.of()));
public static NBCommandResult invoke(NBBufferedContainer container, NBInvokableCommand command) {
return invoke(container, command, NBCommandParams.of(Map.of()));
}
private static NBBufferedCommandContext createContext() {
return NBCommandContext.builder().name("testing").build(TestComponent.EMPTY_COMPONENT);
private static NBBufferedContainer createContext() {
return NBContainer.builder().name("testing").build(TestComponent.EMPTY_COMPONENT);
}
public static NBCommandResult invoke(NBBufferedCommandContext context, NBInvokableCommand command, NBCommandParams params) {
return command.invokeSafe(context,params);
public static NBCommandResult invoke(NBBufferedContainer container, NBInvokableCommand command, NBCommandParams params) {
return command.invokeSafe(container,params);
}
}

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCoreInvokableResolver.java
View File

@ -17,11 +17,9 @@
package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.cmdstream.CmdType;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.nb.annotations.Service;
import io.nosqlbench.nb.api.components.NBComponent;
import java.util.*;
@ -35,7 +33,7 @@ public class NBCoreInvokableResolver implements NBInvokableResolver {
private SequencedMap<String,NBInvokableResolver> resolvers = new LinkedHashMap<>();
@Override
public NBInvokableCommand resolve(Cmd cmd, NBBufferedCommandContext parent, String phaseName) {
public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) {
for (NBInvokableResolver resolver : getResolvers().values()) {
NBInvokableCommand loadedCommand = resolver.resolve(cmd, parent, phaseName);
if (loadedCommand!=null) {

6
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBInvokableResolver.java
View File

@ -17,12 +17,10 @@
package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import java.util.List;
public interface NBInvokableResolver {
NBInvokableCommand resolve(Cmd cmd, NBBufferedCommandContext parent, String phaseName);
NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName);
}

7
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBScriptCommandResolver.java
View File

@ -16,19 +16,16 @@
package io.nosqlbench.engine.core.lifecycle.session;
import io.nosqlbench.engine.cmdstream.BasicScriptBuffer;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand;
import io.nosqlbench.engine.core.lifecycle.scenario.script.NBScriptedCommand;
import io.nosqlbench.nb.annotations.Service;
import java.util.List;
@Service(value = NBInvokableResolver.class, selector = "js")
public class NBScriptCommandResolver implements NBInvokableResolver {
@Override
public NBInvokableCommand resolve(Cmd cmd, NBBufferedCommandContext parent, String phaseName) {
public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) {
return switch (cmd.getCmdType()) {
case run, await, forceStop, stop, start, waitMillis, fragment, script->
new NBScriptedCommand(parent, phaseName, cmd.getTargetContext()).add(cmd);

30
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java
View File

@ -26,8 +26,8 @@ import io.nosqlbench.nb.api.components.decorators.NBTokenWords;
import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.core.clientload.*;
import io.nosqlbench.engine.core.lifecycle.ExecutionResult;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -47,7 +47,7 @@ public class NBSession extends NBBaseComponent implements Function<List<Cmd>, Ex
private final String sessionName;
private final ClientSystemMetricChecker clientMetricChecker;
private final Map<String, NBBufferedCommandContext> contexts = new ConcurrentHashMap<>();
private final Map<String, NBBufferedContainer> containers = new ConcurrentHashMap<>();
public enum STATUS {
OK,
@ -55,10 +55,10 @@ public class NBSession extends NBBaseComponent implements Function<List<Cmd>, Ex
ERROR
}
private NBBufferedCommandContext getContext(String name) {
return contexts.computeIfAbsent(
private NBBufferedContainer getContext(String name) {
return containers.computeIfAbsent(
name,
n -> NBCommandContext.builder().name(n).build(this)
n -> NBContainer.builder().name(n).build(this)
);
}
@ -99,19 +99,19 @@ public class NBSession extends NBBaseComponent implements Function<List<Cmd>, Ex
*/
public ExecutionResult apply(List<Cmd> cmds) {
// TODO: add context closing command
// TODO: inject context closing commands after the last command referencing each context
// TODO: add container closing command
// TODO: inject container closing commands after the last command referencing each container
List<NBCommandAssembly.CommandInvocation> invocationCalls = NBCommandAssembly.assemble(cmds, this::getContext);
ResultCollector collector = new ResultCollector();
try (ResultContext results = new ResultContext(collector).ok()) {
for (NBCommandAssembly.CommandInvocation invocation : invocationCalls) {
try {
String targetContext = invocation.contextName();
NBBufferedCommandContext context = getContext(targetContext);
NBCommandResult cmdResult = context.apply(invocation.command(), invocation.params());
String targetContext = invocation.containerName();
NBBufferedContainer container = getContext(targetContext);
NBCommandResult cmdResult = container.apply(invocation.command(), invocation.params());
results.apply(cmdResult);
} catch (Exception e) {
String msg = "While running command '" + invocation.command() + "' in context '" + invocation.contextName() + "', an error occurred: " + e.toString();
String msg = "While running command '" + invocation.command() + "' in container '" + invocation.containerName() + "', an error occurred: " + e.toString();
logger.error(msg);
results.error(e);
break;
@ -119,9 +119,9 @@ public class NBSession extends NBBaseComponent implements Function<List<Cmd>, Ex
}
}
for (String ctxName : contexts.keySet()) {
NBBufferedCommandContext ctx = contexts.get(ctxName);
logger.debug("awaiting end of activities in context '" + ctxName + "':" +
for (String containerName : containers.keySet()) {
NBBufferedContainer ctx = containers.get(containerName);
logger.debug("awaiting end of activities in container '" + containerName + "':" +
ctx.controller().getActivityDefs().stream().map(ActivityDef::getAlias).toList());
ctx.controller().shutdown();
ctx.controller().awaitCompletion(Long.MAX_VALUE);

2
engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/ResultContext.java
View File

@ -55,7 +55,7 @@ public class ResultContext implements AutoCloseable {
if (this.status==null) {
this.status= ExecutionResult.Status.ERROR;
if (this.error!=null) {
this.error=new RuntimeException("early execution result with no asserted status. Call setStatus on your result context or end with `return ctx.ok() or ctx.error(...)`");
this.error=new RuntimeException("early execution result with no asserted status. Call setStatus on your result object or end with `return ctx.ok() or ctx.error(...)`");
}
}
receiver.accept(this);

9
engine-core/src/test/java/io/nosqlbench/engine/core/NBBaseCommandTest.java
View File

@ -20,12 +20,9 @@ import io.nosqlbench.engine.cmdstream.Cmd;
import io.nosqlbench.engine.cmdstream.CmdArg;
import io.nosqlbench.engine.cmdstream.CmdParam;
import io.nosqlbench.engine.core.lifecycle.session.NBCommandInvoker;
import io.nosqlbench.engine.core.lifecycle.session.NBSession;
import io.nosqlbench.nb.api.config.standard.TestComponent;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import io.nosqlbench.engine.core.lifecycle.scenario.script.NBScriptedCommand;
import org.apache.logging.log4j.LogManager;
@ -41,7 +38,7 @@ public class NBBaseCommandTest {
@Test
public void shouldLoadScriptText() {
NBBufferedCommandContext ctx = NBCommandContext.builder().name("testing").build(NBComponent.EMPTY_COMPONENT);
NBBufferedContainer ctx = NBContainer.builder().name("testing").build(NBComponent.EMPTY_COMPONENT);
NBScriptedCommand cmd = NBScriptedCommand.ofScripted("testing", Map.of(),ctx, NBScriptedCommand.Invocation.EXECUTE_SCRIPT);
cmd.add(new Cmd("fragment",Map.of(
"fragment",new CmdArg(new CmdParam("fragment",s->s,false),"=","print('loaded script environment...');")

2
engine-core/src/test/java/io/nosqlbench/engine/core/script/NBBaseCommandParamsTest.java
View File

@ -17,7 +17,7 @@
package io.nosqlbench.engine.core.script;
import io.nosqlbench.nb.api.errors.BasicError;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import org.junit.jupiter.api.Test;
import java.util.HashMap;

4
mvn-defaults/pom.xml
View File

@ -335,7 +335,7 @@
<dependency>
<groupId>org.antlr</groupId>
<artifactId>antlr4-runtime</artifactId>
<version>4.13.0</version>
<version>4.13.1</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
@ -792,7 +792,7 @@
<plugin>
<groupId>org.antlr</groupId>
<artifactId>antlr4-maven-plugin</artifactId>
<version>4.13.0</version>
<version>4.13.1</version>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>

50
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/DirectRuntimeScenarioTests.java
View File

@ -16,10 +16,10 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.engine.core.lifecycle.session.NBCommandInvoker;
import io.nosqlbench.nb.api.config.standard.TestComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
@ -32,7 +32,7 @@ public class DirectRuntimeScenarioTests {
private final TestComponent testC = new TestComponent("testroot", "testroot");
@Test
public void test_SC_linkedinput() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_linkedinput").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_linkedinput").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_linkedinput(testC,"test_SC_linkedinput");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
Pattern p = Pattern.compile(".*started leader.*started follower.*stopped leader.*stopped follower.*", Pattern.DOTALL);
@ -41,7 +41,7 @@ public class DirectRuntimeScenarioTests {
}
@Test
public void testSC_activity_init_error() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("testSC_activity_init_error").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("testSC_activity_init_error").build(TestComponent.EMPTY_COMPONENT);
NB_activity_init_error command = new NB_activity_init_error(testC, "SC_activity_init_error");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
assertThat(result.getException()).isNotNull();
@ -52,7 +52,7 @@ public class DirectRuntimeScenarioTests {
@Test
public void test_SC_activity_error() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_activity_error").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_activity_error").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_activity_error(testC,"test_SC_activity_error");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
assertThat(result.getException()).isNotNull();
@ -61,14 +61,14 @@ public class DirectRuntimeScenarioTests {
}
@Test
public void test_SC_await_finished() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_await_finished").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_await_finished").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_await_finished(testC,"test_SC_await_finished");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
assertThat(result.getIOLog()).contains("awaited activity");
}
@Test
public void test_SC_basicdiag() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_basicdiag").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_basicdiag").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_basicdiag(testC,"test_SC_basicdiag");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
assertThat(result.getIOLog().indexOf("starting activity basic_diag")).isGreaterThanOrEqualTo(0);
@ -77,7 +77,7 @@ public class DirectRuntimeScenarioTests {
}
@Test
public void test_SC_blockingrun() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_blockingrun").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_blockingrun").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_blockingrun(testC,"test_SC_blockingrun");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
assertThat(result.getIOLog()).matches(Pattern.compile(".*running.*finished.*running.*finished.*",Pattern.DOTALL));
@ -87,7 +87,7 @@ public class DirectRuntimeScenarioTests {
@Test
public void test_SC_cocycledelay_bursty() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_cocycledelay_bursty").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_cocycledelay_bursty").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_cocycledelay_bursty(testC,"test_SC_cocycledelay_bursty");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
result.report();
@ -97,7 +97,7 @@ public class DirectRuntimeScenarioTests {
@Disabled("enable before merge")
@Test
public void test_SC_cocycledelay_strict() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("testest_SC_cocycledelay_strictting").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("testest_SC_cocycledelay_strictting").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_cocycledelay_strict(testC,"test_SC_cocycledelay_strict");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@ -105,48 +105,48 @@ public class DirectRuntimeScenarioTests {
@Disabled("enable before merge")
@Test
public void test_SC_cycle_rate() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_cycle_rate").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_cycle_rate").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_cycle_rate(testC,"test_SC_cycle_rate");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_cycle_rate_change() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_cycle_rate_change").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_cycle_rate_change").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_cycle_rate_change(testC,"test_SC_cycle_rate_change");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_extension_csvmetrics() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_extension_csvmetrics").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_extension_csvmetrics").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_extension_csvmetrics(testC,"test_SC_extension_csvmetrics");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_extension_csvoutput() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_extension_csvoutput").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_extension_csvoutput").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_extension_csvoutput(testC,"test_SC_extension_csvoutput");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_extension_histostatslogger() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_extension_histostatslogger").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_extension_histostatslogger").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_extension_histostatslogger(testC,"test_SC_extension_histostatslogger");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_extension_shutdown_hook() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_extension_shutdown_hook").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_extension_shutdown_hook").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_extension_shutdown_hook(testC,"test_SC_extension_shutdown_hook");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Test
public void test_SC_extension_example() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_extension_example").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_extension_example").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_extension_example(testC,"test_SC_extension_example");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
// samples.exitWithCode();
@ -155,14 +155,14 @@ public class DirectRuntimeScenarioTests {
@Disabled("enable before merge")
@Test
public void test_SC_histologger() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("tetest_SC_histologgersting").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("tetest_SC_histologgersting").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_histologger(testC,"test_SC_histologger");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_optimo() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_optimo").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_optimo").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_optimo_test(testC,"test_SC_optimo");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
System.out.println(result);
@ -170,41 +170,41 @@ public class DirectRuntimeScenarioTests {
@Disabled("enable before merge")
@Test
public void test_SC_params_variable() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_params_variable").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_params_variable").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_params_variable(testC,"test_SC_params_variable");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_readmetrics() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_readmetrics").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_readmetrics").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_readmetrics(testC,"test_SC_readmetrics");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_speedcheck() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_speedcheck").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_speedcheck").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_speedcheck(testC,"test_SC_speedcheck");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_start_stop_diag() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_start_stop_diag").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_start_stop_diag").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_start_stop_diag(testC,"test_SC_start_stop_diag");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Test
public void test_SC_threadchange() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_threadchange").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_threadchange").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_threadchange(testC,"test_SC_threadchange");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@Disabled("enable before merge")
@Test
public void test_SC_threadspeeds() {
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_threadspeeds").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_threadspeeds").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_threadspeeds(testC,"test_SC_threadspeeds");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
}
@ -212,7 +212,7 @@ public class DirectRuntimeScenarioTests {
@Test
public void test_SC_undef_param() {
//.params(Map.of("one", "two", "three", "four")
NBBufferedCommandContext testC = NBBufferedCommandContext.builder().name("test_SC_undef_param").build(TestComponent.EMPTY_COMPONENT);
NBBufferedContainer testC = NBBufferedContainer.builder().name("test_SC_undef_param").build(TestComponent.EMPTY_COMPONENT);
NBBaseCommand command = new NB_undef_param(testC, "test_SC_undef_param");
NBCommandResult result = NBCommandInvoker.invoke(testC,command);
String out = result.getIOLog();

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_activity_error.java
View File

@ -16,11 +16,10 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import java.io.PrintWriter;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_activity_error extends NBBaseCommand {
public NB_activity_error(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_activity_error(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -53,7 +52,7 @@ public class NB_activity_error extends NBBaseCommand {
* </pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activitydef1 = Map.of("alias", "activity_error",
"driver", "diag",
"cycles", "0..1500000",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_activity_init_error.java
View File

@ -16,11 +16,10 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.annotations.Service;
@ -30,7 +29,7 @@ import java.util.Map;
@Service(value= NBBaseCommand.class,selector="activity_init_error")
public class NB_activity_init_error extends NBBaseCommand {
public NB_activity_init_error(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_activity_init_error(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -53,7 +52,7 @@ public class NB_activity_init_error extends NBBaseCommand {
*
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activitydef1 = Map.of(
"alias","activity_init_error",
"driver","diag",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_await_finished.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_await_finished extends NBBaseCommand {
public NB_await_finished(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_await_finished(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -50,7 +49,7 @@ public class NB_await_finished extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activitydef1 = Map.of(
"alias", "activity_to_await",
"driver", "diag",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_basicdiag.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_basicdiag extends NBBaseCommand {
public NB_basicdiag(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_basicdiag(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -45,7 +44,7 @@ public class NB_basicdiag extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var basic_diag = params.withOverrides(
Map.of("alias","basic_diag","driver","diag")
);

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_blockingrun.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_blockingrun extends NBBaseCommand {
public NB_blockingrun(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_blockingrun(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -60,7 +59,7 @@ public class NB_blockingrun extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activitydef1 = Map.of(
"alias","blockactivity1","driver","diag",
"cycles","0..10000","threads","1",

20
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty.java
View File

@ -16,7 +16,8 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer;
@ -24,8 +25,7 @@ import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.nb.api.components.events.ParamChange;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import java.io.PrintWriter;
@ -33,7 +33,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_cocycledelay_bursty extends NBBaseCommand {
public NB_cocycledelay_bursty(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_cocycledelay_bursty(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -89,7 +89,7 @@ public class NB_cocycledelay_bursty extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
int diagrate = 500;
var co_cycle_delay_bursty = Map.of(
"alias", "co_cycle_delay_bursty",
@ -100,9 +100,9 @@ public class NB_cocycledelay_bursty extends NBBaseCommand {
"op", "diagrate: diagrate=" + diagrate
// "dryrun", "op" // silent
);
NBComponent context = this;
while (context.getParent()!=null) {
context=context.getParent();
NBComponent container = this;
while (container.getParent()!=null) {
container=container.getParent();
}
controller.waitMillis(500);
@ -110,8 +110,8 @@ public class NB_cocycledelay_bursty extends NBBaseCommand {
Activity activity = controller.start(co_cycle_delay_bursty);
controller.waitMillis(1000);
NBMetricTimer service_time_counter = context.find().topMetric("activity=co_cycle_delay_bursty,name=cycles_servicetime", NBMetricTimer.class);
NBMetricGauge wait_time_gauge = context.find().topMetric("activity=co_cycle_delay_bursty,name=cycles_waittime",NBMetricGauge.class);
NBMetricTimer service_time_counter = container.find().topMetric("activity=co_cycle_delay_bursty,name=cycles_servicetime", NBMetricTimer.class);
NBMetricGauge wait_time_gauge = container.find().topMetric("activity=co_cycle_delay_bursty,name=cycles_waittime",NBMetricGauge.class);
for (int i = 0; i < 5; i++) {
controller.waitMillis(1000);

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty_backup.java
View File

@ -16,13 +16,12 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricCounter;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import java.io.PrintWriter;
@ -30,7 +29,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_cocycledelay_bursty_backup extends NBBaseCommand {
public NB_cocycledelay_bursty_backup(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_cocycledelay_bursty_backup(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -86,7 +85,7 @@ public class NB_cocycledelay_bursty_backup extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var co_cycle_delay_bursty = Map.of(
"alias", "co_cycle_delay_bursty",
"driver", "diag",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_strict.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_cocycledelay_strict extends NBBaseCommand {
public NB_cocycledelay_strict(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_cocycledelay_strict(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -63,7 +62,7 @@ public class NB_cocycledelay_strict extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cycle_rate.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_cycle_rate extends NBBaseCommand {
public NB_cycle_rate(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_cycle_rate(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -48,7 +47,7 @@ public class NB_cycle_rate extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cycle_rate_change.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_cycle_rate_change extends NBBaseCommand {
public NB_cycle_rate_change(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_cycle_rate_change(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -70,7 +69,7 @@ public class NB_cycle_rate_change extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_extension_csvmetrics.java
View File

@ -16,18 +16,17 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import java.io.PrintWriter;
import java.io.Reader;
public class NB_extension_csvmetrics extends NBBaseCommand {
public NB_extension_csvmetrics(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_extension_csvmetrics(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -55,7 +54,7 @@ public class NB_extension_csvmetrics extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
// TODO create().csvmetrics....
return null;

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_extension_csvoutput.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_extension_csvoutput extends NBBaseCommand {
public NB_extension_csvoutput(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_extension_csvoutput(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -38,7 +37,7 @@ public class NB_extension_csvoutput extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_extension_example.java
View File

@ -16,11 +16,10 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.engine.extensions.example.ExamplePlugin;
@ -28,7 +27,7 @@ import java.io.PrintWriter;
import java.io.Reader;
public class NB_extension_example extends NBBaseCommand {
public NB_extension_example(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_extension_example(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -39,7 +38,7 @@ public class NB_extension_example extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
ExamplePlugin examplePlugin = create().requiredExtension("example", ExamplePlugin.class);
long sum = examplePlugin.getSum(3, 5);
stdout.println("3+5=" + sum);

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_extension_histostatslogger.java
View File

@ -16,18 +16,17 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import java.io.PrintWriter;
import java.io.Reader;
public class NB_extension_histostatslogger extends NBBaseCommand {
public NB_extension_histostatslogger(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_extension_histostatslogger(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -50,7 +49,7 @@ public class NB_extension_histostatslogger extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_extension_shutdown_hook.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_extension_shutdown_hook extends NBBaseCommand {
public NB_extension_shutdown_hook(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_extension_shutdown_hook(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -38,7 +37,7 @@ public class NB_extension_shutdown_hook extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_histologger.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_histologger extends NBBaseCommand {
public NB_histologger(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_histologger(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -52,7 +51,7 @@ public class NB_histologger extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_linkedinput.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_linkedinput extends NBBaseCommand {
public NB_linkedinput(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_linkedinput(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -61,7 +60,7 @@ public class NB_linkedinput extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var leader = Map.of(
"driver", "diag",
"alias", "leader",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_optimo_test.java
View File

@ -16,12 +16,11 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.nb.api.optimizers.BobyqaOptimizerInstance;
import io.nosqlbench.nb.api.optimizers.MVResult;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -30,7 +29,7 @@ import java.io.Reader;
import java.util.function.ToDoubleFunction;
public class NB_optimo_test extends NBBaseCommand {
public NB_optimo_test(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_optimo_test(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -63,7 +62,7 @@ public class NB_optimo_test extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
BobyqaOptimizerInstance bobby = create().bobyqaOptimizer();
bobby.param("pa", 0.0d, 200000.0d);
bobby.param("pb", 0.0d, 2000000d);

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_params_variable.java
View File

@ -16,18 +16,17 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import java.io.PrintWriter;
import java.io.Reader;
public class NB_params_variable extends NBBaseCommand {
public NB_params_variable(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_params_variable(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -54,7 +53,7 @@ public class NB_params_variable extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_readmetrics.java
View File

@ -17,10 +17,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer;
@ -30,7 +29,7 @@ import java.util.Map;
public class NB_readmetrics extends NBBaseCommand {
public NB_readmetrics(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_readmetrics(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -57,7 +56,7 @@ public class NB_readmetrics extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
Activity activity = controller.start(Map.of(
"alias", "testactivity",
"driver", "diag",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_speedcheck.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import java.io.PrintWriter;
@ -27,7 +26,7 @@ import java.io.Reader;
public class NB_speedcheck extends NBBaseCommand {
public NB_speedcheck(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_speedcheck(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -63,7 +62,7 @@ public class NB_speedcheck extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_start_stop_diag.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_start_stop_diag extends NBBaseCommand {
public NB_start_stop_diag(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_start_stop_diag(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -58,7 +57,7 @@ public class NB_start_stop_diag extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activitydef = Map.of(
"alias" , "teststartstopdiag",

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_threadchange.java
View File

@ -16,18 +16,17 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import java.io.PrintWriter;
import java.io.Reader;
public class NB_threadchange extends NBBaseCommand {
public NB_threadchange(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_threadchange(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -45,7 +44,7 @@ public class NB_threadchange extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
var activity = controller.start("driver=diag;alias=threadchange;cycles=0..60000;threads=1;interval=2000;op='noop';rate=1000");
activity.getActivityDef().setThreads(1);

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_threadspeeds.java
View File

@ -16,18 +16,17 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import java.io.PrintWriter;
import java.io.Reader;
public class NB_threadspeeds extends NBBaseCommand {
public NB_threadspeeds(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_threadspeeds(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -85,7 +84,7 @@ public class NB_threadspeeds extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
return null;
}
}

11
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_undef_param.java
View File

@ -16,10 +16,9 @@
package io.nosqlbench.nbr.examples.injava;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
@ -28,7 +27,7 @@ import java.io.Reader;
import java.util.Map;
public class NB_undef_param extends NBBaseCommand {
public NB_undef_param(NBBufferedCommandContext parentComponent, String scenarioName) {
public NB_undef_param(NBBufferedContainer parentComponent, String scenarioName) {
super(parentComponent, scenarioName);
}
@ -50,7 +49,7 @@ public class NB_undef_param extends NBBaseCommand {
* }</pre>
*/
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
stdout.println("paramValues from command line:");
stdout.println(params.toString());
stdout.println("before: paramValues.get(\"three\"):" + params.get("three"));

8
nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injavascript/ScriptExampleTests.java
View File

@ -17,11 +17,11 @@
package io.nosqlbench.nbr.examples.injavascript;
import io.nosqlbench.engine.cmdstream.BasicScriptBuffer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.nb.api.config.standard.TestComponent;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult;
import io.nosqlbench.engine.core.lifecycle.scenario.script.NBScriptedCommand;
import org.apache.commons.compress.utils.IOUtils;
@ -62,7 +62,7 @@ public class ScriptExampleTests {
System.out.println("=".repeat(29) + " Running integration test for example scenario: " + scenarioName);
NBComponent root = new TestComponent("exampletest",scriptname);
NBBufferedCommandContext ctx = NBCommandContext.builder().name(scriptname).build(root);
NBBufferedContainer ctx = NBContainer.builder().name(scriptname).build(root);
NBScriptedCommand s = NBScriptedCommand.ofScripted(scenarioName,Map.of(),ctx, NBScriptedCommand.Invocation.EXECUTE_SCRIPT);
ClassLoader cl = ScriptExampleTests.class.getClassLoader();

11
nbr/src/main/java/io/nosqlbench/scenarios/diag/NB_diag.java
View File

@ -16,11 +16,10 @@
package io.nosqlbench.scenarios.diag;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.annotations.Service;
import java.io.PrintWriter;
@ -28,12 +27,12 @@ import java.io.Reader;
@Service(value = NBBaseCommand.class, selector = "diag")
public class NB_diag extends NBBaseCommand {
public NB_diag(NBBufferedCommandContext parentComponent, String scenarioName, String targetScenario) {
public NB_diag(NBBufferedContainer parentComponent, String scenarioName, String targetScenario) {
super(parentComponent, scenarioName, targetScenario);
}
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
stdout.println("diagnostic scenario writing params to stdout:");
params.forEach((k, v) -> {
stdout.println(k + ":" + v);

2
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/FindmaxSearchParams.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.scenarios.simframe.findmax;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
/**
* These search parameters are based on the original findmax algorithm, and

10
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NB_findmax.java
View File

@ -16,11 +16,11 @@
package io.nosqlbench.scenarios.simframe.findmax;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.annotations.Service;
import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture;
import io.nosqlbench.scenarios.simframe.findmax.planners.FindmaxPlannerType;
@ -56,12 +56,12 @@ import java.io.Reader;
public class NB_findmax extends NBBaseCommand {
private final static Logger logger = LogManager.getLogger(NB_findmax.class);
public NB_findmax(NBBufferedCommandContext parentComponent, String scenarioName, String context) {
public NB_findmax(NBBufferedContainer parentComponent, String scenarioName, String context) {
super(parentComponent, scenarioName, context);
}
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
Activity flywheel = SimFrameUtils.findFlywheelActivity(controller, params.get("activity"));
stdout.println("starting analysis on activity '" + flywheel.getAlias() + "'");
SimFrameUtils.awaitActivity(flywheel);

2
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/FindmaxPlannerType.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.scenarios.simframe.findmax.planners;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.scenarios.simframe.findmax.planners.ratchet.FindmaxRatchet;
import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner;

2
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/FindmaxRampup.java
View File

@ -19,7 +19,7 @@ package io.nosqlbench.scenarios.simframe.findmax.planners;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.api.components.events.ParamChange;
import io.nosqlbench.scenarios.simframe.capture.JournalView;
import io.nosqlbench.scenarios.simframe.findmax.FindMaxFrameParams;

5
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/ratchet/FindmaxRatchet.java
View File

@ -19,7 +19,7 @@ package io.nosqlbench.scenarios.simframe.findmax.planners.ratchet;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.nb.api.components.events.ParamChange;
import io.nosqlbench.scenarios.simframe.capture.JournalView;
import io.nosqlbench.scenarios.simframe.planning.SimFrame;
@ -27,9 +27,6 @@ import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.List;
public class FindmaxRatchet extends SimFramePlanner<RatchetConfig, RatchetFrameParams> {
private final Logger logger = LogManager.getLogger(FindmaxRatchet.class);

2
nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/ratchet/RatchetConfig.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.scenarios.simframe.findmax.planners.ratchet;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
/**
* These search parameters are based on the original findmax algorithm, and

14
nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java
View File

@ -16,19 +16,18 @@
package io.nosqlbench.scenarios.simframe.optimo;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBBufferedCommandContext;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer;
import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricHistogram;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer;
import io.nosqlbench.nb.api.components.NBComponent;
import io.nosqlbench.nb.api.components.events.ParamChange;
import io.nosqlbench.nb.api.components.events.SetThreads;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture;
import io.nosqlbench.scenarios.simframe.capture.SimFrameJournal;
import io.nosqlbench.scenarios.simframe.findmax.NB_findmax;
@ -46,9 +45,6 @@ import org.apache.logging.log4j.Logger;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.locks.LockSupport;
/**
* If the initial trust radius is not large enough with respect to the stopping trust radius, then the search will stop
@ -69,12 +65,12 @@ import java.util.concurrent.locks.LockSupport;
public class NB_optimo extends NBBaseCommand {
private final static Logger logger = LogManager.getLogger(NB_findmax.class);
public NB_optimo(NBBufferedCommandContext parentComponent, String phaseName, String targetScenario) {
public NB_optimo(NBBufferedContainer parentComponent, String phaseName, String targetScenario) {
super(parentComponent, phaseName, targetScenario);
}
@Override
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContextActivitiesController controller) {
public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) {
// TODO: having "scenario" here as well as in "named scenario" in workload templates is confusing. Make this clearer.
Activity flywheel = SimFrameUtils.findFlywheelActivity(controller, params.get("activity"));

6
nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameFunction.java
View File

@ -18,7 +18,7 @@ package io.nosqlbench.scenarios.simframe.optimo;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.core.RunState;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture;
import io.nosqlbench.scenarios.simframe.capture.SimFrameJournal;
import io.nosqlbench.scenarios.simframe.planning.SimFrameFunction;
@ -29,10 +29,10 @@ public class OptimoFrameFunction implements SimFrameFunction {
private final SimFrameCapture capture;
private final SimFrameJournal<OptimoFrameParams> journal;
private final OptimoSearchSettings settings;
private final ContextActivitiesController controller;
private final ContainerActivitiesController controller;
public OptimoFrameFunction(
ContextActivitiesController controller,
ContainerActivitiesController controller,
OptimoSearchSettings settings,
Activity flywheel,
SimFrameCapture capture,

2
nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoSearchSettings.java
View File

@ -16,7 +16,7 @@
package io.nosqlbench.scenarios.simframe.optimo;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
public record OptimoSearchSettings(
long sample_time_ms,

4
nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/SimFrameUtils.java
View File

@ -19,7 +19,7 @@ package io.nosqlbench.scenarios.simframe.optimo;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec;
import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.nb.api.components.events.ParamChange;
import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer;
@ -44,7 +44,7 @@ public class SimFrameUtils {
}
}
public static Activity findFlywheelActivity(ContextActivitiesController controller, String providedActivityName) {
public static Activity findFlywheelActivity(ContainerActivitiesController controller, String providedActivityName) {
Optional<Activity> optionalActivity = Optional.ofNullable(providedActivityName).flatMap(controller::getActivity);
if (providedActivityName!=null && optionalActivity.isEmpty()) {
throw new RuntimeException("you specified activity '" + providedActivityName + "' but it was not found.");

6
nbr/src/main/java/io/nosqlbench/scenarios/simframe/planning/SimFramePlanner.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.scenarios.simframe.planning;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.core.lifecycle.scenario.context.ContextActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.context.NBCommandParams;
import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
import io.nosqlbench.scenarios.simframe.capture.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -62,7 +62,7 @@ public abstract class SimFramePlanner<C,P extends Record> {
public abstract P nextStep(JournalView<P> journal);
public abstract void applyParams(P params, Activity activity);
public P analyze(Activity flywheel, SimFrameCapture capture, PrintWriter stdout, PrintWriter stderr, ContextActivitiesController controller) {
public P analyze(Activity flywheel, SimFrameCapture capture, PrintWriter stdout, PrintWriter stderr, ContainerActivitiesController controller) {
var frameParams = initialStep();
while (frameParams != null) {

2
virtdata-lang/pom.xml
View File

@ -43,7 +43,7 @@
<plugin>
<groupId>org.antlr</groupId>
<artifactId>antlr4-maven-plugin</artifactId>
<version>4.13.0</version>
<version>4.13.1</version>
<configuration>
<sourceDirectory>src/main/java/io/nosqlbench/virtdata/lang/grammars</sourceDirectory>
<arguments>

6
virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_double/to_bigdecimal/ToBigDecimal.java
View File

@ -41,7 +41,7 @@ public class ToBigDecimal implements DoubleFunction<BigDecimal> {
/**
* Convert all input values to BigDecimal values with a specific MathContext.
* The value for context can be one of UNLIMITED,
* The value for mathCtx can be one of UNLIMITED,
* DECIMAL32, DECIMAL64, DECIMAL128, or any valid configuration supported by
* {@link MathContext#MathContext(String)}, such as {@code "precision=32 roundingMode=CEILING"}.
* In the latter form, roundingMode can be any valid value for {@link RoundingMode}, like
@ -52,8 +52,8 @@ public class ToBigDecimal implements DoubleFunction<BigDecimal> {
@Example({"ToBigDecimal('DECIMAL128')", "IEEE 754R Decimal128 format, 34 digits, HALF_EVEN"})
@Example({"ToBigDecimal('UNLIMITED')", "unlimited precision, HALF_UP"})
@Example({"ToBigDecimal('precision=17 roundingMode=UNNECESSARY')", "Custom precision with no rounding performed"})
public ToBigDecimal(String context) {
this.mathContext = MathContextReader.getMathContext(context);
public ToBigDecimal(String mathCtx) {
this.mathContext = MathContextReader.getMathContext(mathCtx);
}
@Override

12
virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_string/to_bigdecimal/ToBigDecimal.java
View File

@ -31,11 +31,11 @@ import java.util.function.Function;
@Categories(Category.conversion)
public class ToBigDecimal implements Function<String, BigDecimal> {
private final MathContext context;
private final MathContext mathCtx;
@Example({"Convert strings to BigDecimal according to default precision (unlimited) and rounding (HALF_UP)"})
public ToBigDecimal() {
this.context = MathContext.UNLIMITED;
this.mathCtx = MathContext.UNLIMITED;
}
/**
@ -46,14 +46,14 @@ public class ToBigDecimal implements Function<String, BigDecimal> {
* In the latter form, roundingMode can be any valid value for {@link RoundingMode}, like
* UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, or UNNECESSARY.
*/
public ToBigDecimal(String context) {
this.context =
MathContextReader.getMathContext(context);
public ToBigDecimal(String mathCtx) {
this.mathCtx =
MathContextReader.getMathContext(mathCtx);
}
@Override
public BigDecimal apply(String s) {
return new BigDecimal(s, context);
return new BigDecimal(s, mathCtx);
}
}