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

typos and small cleanups

Browse Source
This commit is contained in:
Jonathan Shook 2021-07-06 11:12:44 -05:00
parent 06d43b8c55
commit 0bddb0bdaf
9 changed files with 47 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
driver-direct/src/main/java/io/nosqlbench/driver/direct/DirectActivity.java
View File

@ -1,21 +0,0 @@
package io.nosqlbench.driver.direct;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.OpDispenser;
import io.nosqlbench.engine.api.activityimpl.uniform.StandardActivity;
import java.util.function.Function;
public class DirectActivity extends StandardActivity<DirectCall> implements Activity {
public DirectActivity(ActivityDef activityDef) {
super(activityDef);
}
@Override
protected Function<OpTemplate, OpDispenser<DirectCall>> getOpMapperFunction() {
return DirectOpMapper::new;
}
}

55
driver-direct/src/main/java/io/nosqlbench/driver/direct/DirectActivityType.java
View File

@ -1,55 +0,0 @@
package io.nosqlbench.driver.direct;
import io.nosqlbench.engine.api.activityapi.core.Action;
import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
import io.nosqlbench.engine.api.activityapi.core.ActivityType;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.OpDispenser;
import io.nosqlbench.engine.api.activityimpl.uniform.StandardAction;
import io.nosqlbench.engine.api.activityimpl.uniform.StandardActivity;
import io.nosqlbench.nb.annotations.Service;
import java.util.function.Function;
/**
* This activity type driver allows you to dynamically map any available
* Java API which is exposed to the NoSQLBench runtime, executing methods
* on this API by name, (optionally) storing named results, and re-using
* these named results as arguments to subsequent calls.
*
* It supports static method dispatch, instance methods, and per-thread
* object scoping.
*/
@Service(value = ActivityType.class,selector = "direct")
public class DirectActivityType extends StandardActivity<DirectCall> {
@Override
public DirectActivity getActivity(ActivityDef activityDef) {
return new DirectActivity(activityDef);
}
@Override
public ActionDispenser getActionDispenser(DirectActivity activity) {
return new DirectActionDispenser(activity);
}
@Override
protected Function<OpTemplate, OpDispenser<DirectCall>> getOpMapperFunction() {
return null;
}
private static class DirectActionDispenser implements ActionDispenser {
private final DirectActivity activity;
public DirectActionDispenser(DirectActivity activity) {
this.activity = activity;
}
@Override
public Action getAction(int slot) {
return new StandardAction<DirectActivity,DirectCall>(slot, getOpSource());
}
}
}

25
driver-grpc/src/main/java/io/nosqlbench/driver/grpc/GrpcAction.java
View File

@ -1,25 +0,0 @@
package io.nosqlbench.driver.grpc;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityapi.planning.OpSource;
import io.nosqlbench.engine.api.activityimpl.OpDispenser;
import io.nosqlbench.engine.api.activityimpl.uniform.StandardAction;
public class GrpcAction extends StandardAction<GrpcActivity,GrpcOp> {
private final int slot;
private final GrpcActivity activity;
private OpSource<GrpcOp> sequencer;
public GrpcAction(int slot, GrpcActivity activity, OpSequence<OpDispenser<GrpcOp>> opsource) {
super(activity, opsource);
this.slot = slot;
this.activity = activity;
}
@Override
public void init() {
this.sequencer = activity.getOpsource();
}
}

4
driver-grpc/src/main/java/io/nosqlbench/driver/grpc/GrpcOp.java
View File

@ -1,4 +0,0 @@
package io.nosqlbench.driver.grpc;
public interface GrpcOp extends Runnable {
}

19
driver-grpc/src/main/java/io/nosqlbench/driver/grpc/GrpcOpMapper.java
View File

@ -1,19 +0,0 @@
package io.nosqlbench.driver.grpc;
import io.nosqlbench.driver.grpc.optypes.NullGrpcOp;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityimpl.OpDispenser;
public class GrpcOpMapper implements OpDispenser<GrpcOp> {
private final OpTemplate opTemplate;
public GrpcOpMapper(OpTemplate opTemplate) {
this.opTemplate = opTemplate;
}
@Override
public GrpcOp apply(long value) {
return new NullGrpcOp();
}
}

9
driver-grpc/src/main/java/io/nosqlbench/driver/grpc/optypes/NullGrpcOp.java
View File

@ -1,9 +0,0 @@
package io.nosqlbench.driver.grpc.optypes;
import io.nosqlbench.driver.grpc.GrpcOp;
public class NullGrpcOp implements GrpcOp {
@Override
public void run() {
}
}

42
engine-api/src/main/java/io/nosqlbench/engine/api/templating/ResolvedCommand.java
View File

@ -1,42 +0,0 @@
package io.nosqlbench.engine.api.templating;
import io.nosqlbench.virtdata.core.bindings.Binder;
import java.util.HashMap;
import java.util.Map;
public class ResolvedCommand<T> {
private final ParsedCommand command;
private final int mapsize;
private final Map<String, Object> statics;
private final Map<String, Binder<?>> dynamics;
public ResolvedCommand(ParsedCommand command) {
this.command = command;
this.statics = command.getStatics();
this.dynamics = resolveDynamics(command);
this.mapsize = command.getStatics().size() + command.getDynamics().size();
}
private Map<String, Binder<?>> resolveDynamics(ParsedCommand command) {
command.getDynamics().forEach((k,v) -> {
});
return null;
}
public Map<String,Object> getCommand(long seed) {
HashMap<String, Object> map = new HashMap<>(mapsize);
map.putAll(statics);
dynamics.forEach((k, v) -> {
map.put(k, v.bind(seed));
});
return map;
}
}

80
nb-api/src/main/java/io/nosqlbench/nb/api/config/params/NBParams.java
View File

@ -6,42 +6,43 @@ import java.util.Map;
import java.util.stream.Collectors;
/**
* NBParams is the main entry point into accessing parameters in a type-safe way.
* <H2>NB Params</H2>
* <p>NBParams is the main entry point into accessing parameters in a type-safe way.
* It provides a reader interface which normalizes all access patterns for reading
* configuration parameters from a variety of sources.
*
* NBParams not a general purpose data interface. It is a parameter reading interface.
* configuration parameters from a variety of sources.</p>
* <br/>
* <p>NBParams is not a general purpose data interface. It is a <em>named</em> parameter reading interface.
* As such, all data which is presented for reading must be named at every level.
* This means that index access such as '[3]' that you might see in other access
* vernaculars is <em>NOT</em> supported.
*
* However, multiplicity is allowed at the API level in order to support reading
* vernaculars is <em>NOT</em> supported.</p>
* <br/>
* <p>However, multiplicity is allowed at the API level in order to support reading
* zero or more of something when the number of provided elements is intended to
* be user-specified. In this usage, direct indexing is not intended nor allowed,
* be configurable. In this usage, direct indexing is not intended nor allowed,
* but order is preserved. This means that if there are any dependency relationships
* within multiple elements at the same level, the developer can rely on them
* being provided in the order specific by the user or underlying configuration source.
* To be crystal clear, direct indexing within configuration parameters is highly
* discouraged and should not be supported directly by this API.
*
* When configuration elements are named within the element definition, regardless
* being provided in the order specified by the user or underlying configuration source.</p>
* <br/>
* <p>When configuration elements are named within the element definition, regardless
* of the source, these names can be taken as naming structure. To enable this, simply
* provide a name property on the element.
* provide a name property on the element.</p>
* <hr/>
*
* <H2>element naming</H2>
* <H2>Element Naming</H2>
*
* If an element contains a property named <i>name</i>, then the value of this property
* <p>If an element contains a property named <i>name</i>, then the value of this property
* is taken as the name of the element. This is useful in certain contexts when you
* need to define a name at the source of a configuration element but expose it
* to readers. This means that an element can be positioned with a hierarchic structure
* simply by naming it appropriately.
* simply by naming it appropriately.</p>
* <hr/>
*
* <H2>Element Views</H2>
*
* The parameter API allows a developer to choose the structural model imposed on
* <p>This API allows a developer to choose the structural model imposed on
* configuration data. Specifically, you must choose whether or not to consume the
* parameter data as a set of properties of one element instance, or as as set
* of elements, each with their own properties.
* of elements, each with their own properties.</p>
*
* <table border="1">
* <tr><td></td><th>view<br>as single</th><th>view<br>as multiple</th></tr>
@ -49,37 +50,44 @@ import java.util.stream.Collectors;
* <tr><th>source is<br>multiple elements</th><td>using <i>element name</i>.<i>param name</td><td>iterable<br>elements</td></tr>
* </table>
*
* <H2>single element view</H2>
* <br/>
*
* The <i>one element access</i> interface is mean to provide basic support for
* This decision is made by which access method below is used. It is key that the
* format of the provided data and the interpretation are in alignment. To ensure that
* the consumer side of this API uses the configuration data appropriately, make
* sure that users are well informed on valid formats. Basically, write good
* docs and provide good examples in them.
* <hr/>
*
* <H2>Single-Element View</H2>
*
* <p>The <i>one element access</i> interface is mean to provide basic support for
* parameterizing a single entity. The names of the parameters surfaced at the
* top level should map directly to the names of properties as provided by the
* underlying data source. This is irrespective of whatever other structure may
* be contained within such properties. The key distinction is that the top level
* names of the configuration object are available under the same top-level names
* within the one element interface.
*
* As data sources can provide either one or many style results, it is important
* within the one element interface.</p>
* <br/>
* <p>As data sources can provide either one or many style results, it is important
* that each data source provide a clear explanation about how it distinguishes
* reading a single element vs reading (possibly) multiple elements.
*
* When explicitly reading a single element, the underlying data source must provide
* reading a single element vs reading (possibly) multiple elements.</p>
* <br/>
* <p>When explicitly reading a single element, the underlying data source must provide
* exactly one element <EM>OR</EM> provide a series of elements of which some contain
* <i>name</i> properties. Non-distinct names are allowed, although the last element
* for a given name will be the only one visible to readers. It is an error for the
* underlying data source in this mode to be null, empty, or otherwise provide zero
* elements. When multiple elements are provided, It is also an error if
* none of them has a name property. Otherwise, those with no name property are
* silently ignored and the ones with a name property are exposed.
*
* <H2>element list view</H2>
*
* When accessing <i>some elements</i>, any number of elements may be provided, even zero.
*
* silently ignored and the ones with a name property are exposed.</p>
* <hr/>
* <H2>Element-List View</H2>
* <p>When accessing <i>some elements</i>, any number of elements may be provided, even zero.</p>
* <hr/>
* <H2>Naming</H2>
*
* A parameter can be read from a reader by simple name or by a hierarchic name.
* hierarchic names are simply simple names concatenated by a dot '.'.
* <p>A parameter can be read from a reader by simple name or by a hierarchic name.
* hierarchic names are simply simple names concatenated by a dot '.'.</p>
*/
public class NBParams {

6
nb-api/src/test/java/io/nosqlbench/nb/api/config/params/NBParamsTest.java
View File

@ -1,7 +1,6 @@
package io.nosqlbench.nb.api.config.params;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.util.Date;
@ -36,9 +35,10 @@ public class NBParamsTest {
}
@Test
@Disabled("This case is unwieldy and generally not useful")
// Fixed this. Agreed it is is generally unwieldy and unuseful as an example although it does test the underlying resolver mechanisms
public void testNestedMixedJsonParamsMap() {
Element one = NBParams.one("{\"key1\":\"key2={\"key3\":\"value3\",\"key4\":\"value4\"}\"}");
String source = "{\"key1\":\"key2={\\\"key3\\\":\\\"value3\\\",\\\"key4\\\":\\\"value4\\\"}\"}";
Element one = NBParams.one(source);
assertThat(one.get("key1.key2.key3", String.class)).isPresent();
assertThat(one.get("key1.key2.key3", String.class).get()).isEqualTo("value3");
assertThat(one.get("key1.key2.key4", String.class).get()).isEqualTo("value4");