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

consolidate to log4j2

Browse Source
This commit is contained in:
Jonathan Shook 2020-11-16 17:30:20 -06:00
parent 6a523dc484
commit a09efbe994
187 changed files with 1153 additions and 756 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/codecsupport/UDTCodecInjector.java
View File

@ -3,18 +3,18 @@ package io.nosqlbench.activitytype.cql.codecsupport;
import com.datastax.driver.core.CodecRegistry;
import com.datastax.driver.core.Session;
import com.datastax.driver.core.UserType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
public class UDTCodecInjector {
private final static Logger logger = LoggerFactory.getLogger(UDTCodecInjector.class);
private final static Logger logger = LogManager.getLogger(UDTCodecInjector.class);
private List<UserCodecProvider> codecProviders = new ArrayList<>();
private List<UserType> userTypes = new ArrayList<>();
private final List<UserCodecProvider> codecProviders = new ArrayList<>();
private final List<UserType> userTypes = new ArrayList<>();
public void injectUserProvidedCodecs(Session session, boolean allowAcrossKeyspaces) {

8
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/codecsupport/UserCodecProvider.java
View File

@ -1,8 +1,8 @@
package io.nosqlbench.activitytype.cql.codecsupport;
import com.datastax.driver.core.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.lang.reflect.Constructor;
import java.util.*;
@ -10,7 +10,7 @@ import java.util.stream.Collectors;
public abstract class UserCodecProvider {
private final static Logger logger = LoggerFactory.getLogger(UserCodecProvider.class);
private final static Logger logger = LogManager.getLogger(UserCodecProvider.class);
public List<UDTTransformCodec> registerCodecsForCluster(
Session session,
@ -131,7 +131,7 @@ public abstract class UserCodecProvider {
.orElseThrow(
() -> new RuntimeException("Unable to find UDTJavaType annotation for " + codecClass.getCanonicalName())
);
return (Class<?>) javaType;
return javaType;
}

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/core/CQLOptions.java
View File

@ -4,8 +4,8 @@ import com.datastax.driver.core.*;
import com.datastax.driver.core.policies.*;
import io.netty.util.HashedWheelTimer;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.net.InetSocketAddress;
import java.util.*;
@ -16,7 +16,7 @@ import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class CQLOptions {
private final static Logger logger = LoggerFactory.getLogger(CQLOptions.class);
private final static Logger logger = LogManager.getLogger(CQLOptions.class);
private final static Pattern CORE_AND_MAX_RQ_PATTERN = Pattern.compile("(?<core>\\d+)(:(?<max>\\d+)(:(?<rq>\\d+))?)?(,(?<rcore>\\d+)(:(?<rmax>\\d+)(:(?<rrq>\\d+))?)?)?(,?heartbeat_interval_s:(?<heartbeatinterval>\\d+))?(,?idle_timeout_s:(?<idletimeout>\\d+))?(,?pool_timeout_ms:(?<pooltimeout>\\d+))?");
private final static Pattern PERCENTILE_EAGER_PATTERN = Pattern.compile("^p(?<pctile>[^:]+)(:(?<executions>\\d+))?(:(?<tracked>\\d+)ms)?$");

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/core/CqlAction.java
View File

@ -19,8 +19,8 @@ import io.nosqlbench.engine.api.activityapi.core.MultiPhaseAction;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.concurrent.TimeUnit;
@ -28,7 +28,7 @@ import java.util.concurrent.TimeUnit;
@SuppressWarnings("Duplicates")
public class CqlAction implements SyncAction, MultiPhaseAction, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(CqlAction.class);
private final static Logger logger = LogManager.getLogger(CqlAction.class);
private final int slot;
private final CqlActivity cqlActivity;
private final ActivityDef activityDef;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/core/CqlActivity.java
View File

@ -44,8 +44,8 @@ import io.nosqlbench.engine.api.util.TagFilter;
import io.nosqlbench.engine.api.util.Unit;
import io.nosqlbench.nb.api.errors.BasicError;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.FileWriter;
import java.io.IOException;
@ -56,7 +56,7 @@ import java.util.*;
@SuppressWarnings("Duplicates")
public class CqlActivity extends SimpleActivity implements Activity, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(CqlActivity.class);
private final static Logger logger = LogManager.getLogger(CqlActivity.class);
private final ExceptionCountMetrics exceptionCountMetrics;
private final ExceptionHistoMetrics exceptionHistoMetrics;
private final ActivityDef activityDef;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/core/CqlAsyncAction.java
View File

@ -23,8 +23,8 @@ import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.SucceededOp
import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.concurrent.TimeUnit;
@ -33,7 +33,7 @@ import java.util.function.LongFunction;
@SuppressWarnings("Duplicates")
public class CqlAsyncAction extends BaseAsyncAction<CqlOpData, CqlActivity> {
private final static Logger logger = LoggerFactory.getLogger(CqlAsyncAction.class);
private final static Logger logger = LogManager.getLogger(CqlAsyncAction.class);
private final ActivityDef activityDef;
private List<RowCycleOperator> rowOps;

10
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/datamappers/functions/long_string/ModuloCSVLineToUUID.java
View File

@ -25,8 +25,8 @@ import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper;
import io.nosqlbench.virtdata.library.basics.shared.from_long.to_string.ModuloLineToString;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
@ -40,11 +40,11 @@ import java.util.function.LongFunction;
*/
@ThreadSafeMapper
public class ModuloCSVLineToUUID implements LongFunction<UUID> {
private final static Logger logger = LoggerFactory.getLogger(ModuloLineToString.class);
private final static Logger logger = LogManager.getLogger(ModuloLineToString.class);
private List<String> lines = new ArrayList<>();
private final List<String> lines = new ArrayList<>();
private String filename;
private final String filename;
@Example({"ModuloCSVLineToUUID('data/myfile.csv','lat')","load values for 'lat' from the CSV file myfile.csv."})
public ModuloCSVLineToUUID(String filename, String fieldname) {

8
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/datamappers/functions/to_tuple/CustomFunc955.java
View File

@ -71,8 +71,8 @@ public class CustomFunc955 implements LongFunction<Map<?,?>>, ConfigAware {
}
@Override
public void applyConfig(Map<String, ?> elements) {
this.cluster = Optional.ofNullable(elements.get("cluster"))
public void applyConfig(Map<String, ?> providedConfig) {
this.cluster = Optional.ofNullable(providedConfig.get("cluster"))
.map(Cluster.class::cast)
.orElseThrow();
this.tupleType = cluster.getMetadata().newTupleType(DataType.cint(), DataType.bigint());
@ -80,8 +80,8 @@ public class CustomFunc955 implements LongFunction<Map<?,?>>, ConfigAware {
@Override
public ConfigModel getConfigModel() {
return new MutableConfigModel()
.add("<cluster>", Cluster.class)
return new MutableConfigModel(this)
.optional("<cluster>", Cluster.class)
.asReadOnly();
}
}

8
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/errorhandling/CQLExceptionEnum.java
View File

@ -3,8 +3,8 @@ package io.nosqlbench.activitytype.cql.errorhandling;
import com.datastax.driver.core.exceptions.*;
import io.nosqlbench.activitytype.cql.errorhandling.exceptions.*;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.HashMap;
@ -64,10 +64,10 @@ public enum CQLExceptionEnum implements ResultReadable {
EbdseCycleException(CqlGenericCycleException.class, 42),
MaxTriesExhaustedException(io.nosqlbench.activitytype.cql.errorhandling.exceptions.MaxTriesExhaustedException.class,43);
private final static Logger logger = LoggerFactory.getLogger(CQLExceptionEnum.class);
private final static Logger logger = LogManager.getLogger(CQLExceptionEnum.class);
private static Map<String, Integer> codesByName = getCodesByName();
private static String[] namesByCode = getNamesByCode();
private static final String[] namesByCode = getNamesByCode();
private final Class<? extends Exception> exceptionClass;
private final int resultCode;

10
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/errorhandling/HashedCQLErrorHandler.java
View File

@ -8,18 +8,18 @@ import io.nosqlbench.activitytype.cql.errorhandling.exceptions.RowVerificationEx
import io.nosqlbench.engine.api.activityapi.errorhandling.CycleErrorHandler;
import io.nosqlbench.engine.api.activityapi.errorhandling.HashedErrorHandler;
import io.nosqlbench.engine.api.metrics.ExceptionCountMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class HashedCQLErrorHandler extends HashedErrorHandler<Throwable, ErrorStatus> {
private static final Logger logger = LoggerFactory.getLogger(HashedCQLErrorHandler.class);
private static final Logger logger = LogManager.getLogger(HashedCQLErrorHandler.class);
// private static Set<Class<? extends Throwable>> UNVERIFIED_ERRORS = new HashSet<Class<? extends Throwable>>() {{
// add(RowVerificationException.class);
// add(ResultSetVerificationException.class);
// }};
private ExceptionCountMetrics exceptionCountMetrics;
private static ThreadLocal<Integer> tlResultCode = ThreadLocal.withInitial(() -> (0));
private final ExceptionCountMetrics exceptionCountMetrics;
private static final ThreadLocal<Integer> tlResultCode = ThreadLocal.withInitial(() -> (0));
public HashedCQLErrorHandler(ExceptionCountMetrics exceptionCountMetrics) {
this.exceptionCountMetrics = exceptionCountMetrics;

10
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/errorhandling/NBCycleErrorHandler.java
View File

@ -6,8 +6,8 @@ import io.nosqlbench.activitytype.cql.errorhandling.exceptions.CQLExceptionDetai
import io.nosqlbench.engine.api.activityapi.errorhandling.CycleErrorHandler;
import io.nosqlbench.engine.api.metrics.ExceptionCountMetrics;
import io.nosqlbench.engine.api.metrics.ExceptionHistoMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* A contextualized error handler that can catch a cycle-specific error.
@ -42,10 +42,10 @@ import org.slf4j.LoggerFactory;
@SuppressWarnings("Duplicates")
public class NBCycleErrorHandler implements CycleErrorHandler<Throwable, ErrorStatus> {
private static final Logger logger = LoggerFactory.getLogger(NBCycleErrorHandler.class);
private static final Logger logger = LogManager.getLogger(NBCycleErrorHandler.class);
private ErrorResponse errorResponse;
private ExceptionCountMetrics exceptionCountMetrics;
private final ErrorResponse errorResponse;
private final ExceptionCountMetrics exceptionCountMetrics;
private final ExceptionHistoMetrics exceptionHistoMetrics;
private boolean throwExceptionOnStop=false;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/binders/DiagnosticPreparedBinder.java
View File

@ -3,8 +3,8 @@ package io.nosqlbench.activitytype.cql.statements.binders;
import com.datastax.driver.core.*;
import io.nosqlbench.activitytype.cql.core.CQLBindHelper;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
@ -15,7 +15,7 @@ import java.util.List;
* order to explain in more detail what is happening for users.
*/
public class DiagnosticPreparedBinder implements ValuesArrayBinder<PreparedStatement, Statement> {
public static final Logger logger = LoggerFactory.getLogger(DiagnosticPreparedBinder.class);
public static final Logger logger = LogManager.getLogger(DiagnosticPreparedBinder.class);
@Override
public Statement bindValues(PreparedStatement prepared, Object[] values) {
ColumnDefinitions columnDefinitions = prepared.getVariables();

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/binders/DirectArrayValuesBinder.java
View File

@ -3,8 +3,8 @@ package io.nosqlbench.activitytype.cql.statements.binders;
import com.datastax.driver.core.PreparedStatement;
import com.datastax.driver.core.Statement;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Arrays;
@ -19,7 +19,7 @@ import java.util.Arrays;
* will become the default.
*/
public class DirectArrayValuesBinder implements ValuesArrayBinder<PreparedStatement, Statement> {
public final static Logger logger = LoggerFactory.getLogger(DirectArrayValuesBinder.class);
public final static Logger logger = LogManager.getLogger(DirectArrayValuesBinder.class);
@Override
public Statement bindValues(PreparedStatement preparedStatement, Object[] objects) {

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/binders/UnsettableValuesBinder.java
View File

@ -3,14 +3,14 @@ package io.nosqlbench.activitytype.cql.statements.binders;
import com.datastax.driver.core.*;
import io.nosqlbench.virtdata.api.bindings.VALUE;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.nio.ByteBuffer;
import java.util.List;
public class UnsettableValuesBinder implements ValuesArrayBinder<PreparedStatement, Statement> {
private final static Logger logger = LoggerFactory.getLogger(UnsettableValuesBinder.class);
private final static Logger logger = LogManager.getLogger(UnsettableValuesBinder.class);
private final Session session;
private final CodecRegistry codecRegistry;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/core/CQLSessionCache.java
View File

@ -14,8 +14,8 @@ import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import io.nosqlbench.engine.api.scripting.NashornEvaluator;
import io.nosqlbench.engine.api.util.SSLKsFactory;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.net.ssl.SSLContext;
import java.io.File;
@ -28,7 +28,7 @@ import java.util.*;
public class CQLSessionCache implements Shutdownable {
private final static Logger logger = LoggerFactory.getLogger(CQLSessionCache.class);
private final static Logger logger = LogManager.getLogger(CQLSessionCache.class);
private final static String DEFAULT_SESSION_ID = "default";
private static final CQLSessionCache instance = new CQLSessionCache();
private final Map<String, Session> sessionCache = new HashMap<>();

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/core/CQLStatementDef.java
View File

@ -1,14 +1,14 @@
package io.nosqlbench.activitytype.cql.statements.core;
import com.datastax.driver.core.ConsistencyLevel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.stream.Collectors;
public class CQLStatementDef {
private final static Logger logger = LoggerFactory.getLogger(CQLStatementDef.class);
private final static Logger logger = LogManager.getLogger(CQLStatementDef.class);
private Map<String,String> params = new HashMap<>();
private String name = "";

18
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/core/CQLStatementDefParser.java
View File

@ -1,7 +1,7 @@
package io.nosqlbench.activitytype.cql.statements.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.regex.Matcher;
@ -9,7 +9,7 @@ import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class CQLStatementDefParser {
private final static Logger logger = LoggerFactory.getLogger(CQLStatementDefParser.class);
private final static Logger logger = LogManager.getLogger(CQLStatementDefParser.class);
// private final static Pattern templateToken = Pattern.compile("<<(\\w+(:(.+?))?)>>");
private final static Pattern stmtToken = Pattern.compile("\\?(\\w+[-_\\d\\w]*)|\\{(\\w+[-_\\d\\w.]*)}");
private final static String UNSET_VALUE = "UNSET-VALUE";
@ -93,9 +93,7 @@ public class CQLStatementDefParser {
if (!namedBindings.contains(tokenName)) {
missingBindings.add(tokenName);
} else {
if (missingAnchors.contains(tokenName)) {
missingAnchors.remove(tokenName);
}
missingAnchors.remove(tokenName);
}
}
@ -114,11 +112,11 @@ public class CQLStatementDefParser {
}
public static class ParseResult {
private Set<String> missingGenerators;
private Set<String> missingAnchors;
private String statement;
private final Set<String> missingGenerators;
private final Set<String> missingAnchors;
private final String statement;
private Map<String,String> bindings;
private String name;
private final String name;
public ParseResult(String stmt, String name, Map<String,String> bindings, Set<String> missingGenerators, Set<String> missingAnchors) {
this.missingGenerators = missingGenerators;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/core/ReadyCQLStatementTemplate.java
View File

@ -15,15 +15,15 @@ import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import io.nosqlbench.virtdata.core.bindings.ContextualBindingsArrayTemplate;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.Writer;
import java.util.Map;
public class ReadyCQLStatementTemplate {
private final static Logger logger = LoggerFactory.getLogger(ReadyCQLStatementTemplate.class);
private final static Logger logger = LogManager.getLogger(ReadyCQLStatementTemplate.class);
private final Session session;
private final ContextualBindingsArrayTemplate<?, Statement> template;
private final long ratio;

10
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/core/YamlCQLStatementLoader.java
View File

@ -3,25 +3,21 @@ package io.nosqlbench.activitytype.cql.statements.core;
import io.nosqlbench.engine.api.activityimpl.ActivityInitializationError;
import io.nosqlbench.nb.api.content.Content;
import io.nosqlbench.nb.api.content.NBIO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.yaml.snakeyaml.TypeDescription;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.Constructor;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
@SuppressWarnings("ALL")
public class YamlCQLStatementLoader {
private final static Logger logger = LoggerFactory.getLogger(YamlCQLStatementLoader.class);
private final static Logger logger = LogManager.getLogger(YamlCQLStatementLoader.class);
List<Function<String, String>> transformers = new ArrayList<>();
public YamlCQLStatementLoader() {

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/rowoperators/Save.java
View File

@ -4,8 +4,8 @@ import com.datastax.driver.core.ColumnDefinitions;
import com.datastax.driver.core.Row;
import io.nosqlbench.activitytype.cql.api.RowCycleOperator;
import io.nosqlbench.virtdata.library.basics.core.threadstate.SharedState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Arrays;
import java.util.HashMap;
@ -16,7 +16,7 @@ import java.util.stream.Collectors;
* Save specific variables to the thread local object map
*/
public class Save implements RowCycleOperator {
private final static Logger logger = LoggerFactory.getLogger(Save.class);
private final static Logger logger = LogManager.getLogger(Save.class);
ThreadLocal<HashMap<String, Object>> tl_objectMap = SharedState.tl_ObjectMap;

6
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/rsoperators/CqlResultSetLogger.java
View File

@ -2,15 +2,15 @@ package io.nosqlbench.activitytype.cql.statements.rsoperators;
import com.datastax.driver.core.*;
import io.nosqlbench.activitytype.cql.api.ResultSetCycleOperator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* Logs a trace-level event for the result set, including
* cycles, rows, fetched row count, and the statement.
*/
public class CqlResultSetLogger implements ResultSetCycleOperator {
private final static Logger logger = LoggerFactory.getLogger(CqlResultSetLogger.class);
private final static Logger logger = LogManager.getLogger(CqlResultSetLogger.class);
private static String getQueryString(Statement stmt) {
if (stmt instanceof PreparedStatement) {

8
driver-cql-shaded/src/main/java/io/nosqlbench/activitytype/cql/statements/rsoperators/TraceLogger.java
View File

@ -7,8 +7,8 @@ import com.datastax.driver.core.Statement;
import io.nosqlbench.activitytype.cql.api.ResultSetCycleOperator;
import io.nosqlbench.activitytype.cql.statements.modifiers.StatementModifier;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.FileDescriptor;
import java.io.FileWriter;
@ -18,9 +18,9 @@ import java.util.Date;
public class TraceLogger implements ResultSetCycleOperator, StatementModifier {
private final static Logger logger = LoggerFactory.getLogger(TraceLogger.class);
private final static Logger logger = LogManager.getLogger(TraceLogger.class);
private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
private static final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
private final long modulo;
private final String filename;
private final FileWriter writer;

8
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/codecsupport/UDTCodecInjector.java
View File

@ -2,17 +2,17 @@ package io.nosqlbench.activitytype.cqld4.codecsupport;
import com.datastax.oss.driver.api.core.session.Session;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
public class UDTCodecInjector {
private final static Logger logger = LoggerFactory.getLogger(UDTCodecInjector.class);
private final static Logger logger = LogManager.getLogger(UDTCodecInjector.class);
private List<UserCodecProvider> codecProviders = new ArrayList<>();
private final List<UserCodecProvider> codecProviders = new ArrayList<>();
public void injectUserProvidedCodecs(Session session, boolean allowAcrossKeyspaces) {

8
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/codecsupport/UserCodecProvider.java
View File

@ -6,8 +6,8 @@ import com.datastax.oss.driver.api.core.type.UserDefinedType;
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import com.datastax.oss.driver.api.core.type.codec.registry.MutableCodecRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.lang.reflect.Constructor;
import java.util.*;
@ -15,7 +15,7 @@ import java.util.stream.Collectors;
public abstract class UserCodecProvider {
private final static Logger logger = LoggerFactory.getLogger(UserCodecProvider.class);
private final static Logger logger = LogManager.getLogger(UserCodecProvider.class);
public List<UDTTransformCodec<?>> registerCodecsForCluster(
Session session,
@ -139,7 +139,7 @@ public abstract class UserCodecProvider {
.orElseThrow(
() -> new RuntimeException("Unable to find UDTJavaType annotation for " + codecClass.getCanonicalName())
);
return (Class<?>) javaType;
return javaType;
}

2
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/core/CQLOptions.java
View File

@ -1,7 +1,7 @@
package io.nosqlbench.activitytype.cqld4.core;
public class CQLOptions {
// private final static Logger logger = LoggerFactory.getLogger(CQLOptions.class);
// private final static Logger logger = LogManager.getLogger(CQLOptions.class);
//
// private final static Pattern CORE_AND_MAX_RQ_PATTERN = Pattern.compile("(?<core>\\d+)(:(?<max>\\d+)(:(?<rq>\\d+))?)?(,(?<rcore>\\d+)(:(?<rmax>\\d+)(:(?<rrq>\\d+))?)?)?(,?heartbeat_interval_s:(?<heartbeatinterval>\\d+))?(,?idle_timeout_s:(?<idletimeout>\\d+))?(,?pool_timeout_ms:(?<pooltimeout>\\d+))?");
// private final static Pattern PERCENTILE_EAGER_PATTERN = Pattern.compile("^p(?<pctile>[^:]+)(:(?<executions>\\d+))?(:(?<tracked>\\d+)ms)?$");

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/core/CqlAction.java
View File

@ -17,8 +17,8 @@ import io.nosqlbench.engine.api.activityapi.core.MultiPhaseAction;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.concurrent.CompletionStage;
@ -27,7 +27,7 @@ import java.util.concurrent.TimeUnit;
@SuppressWarnings("Duplicates")
public class CqlAction implements SyncAction, MultiPhaseAction, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(CqlAction.class);
private final static Logger logger = LogManager.getLogger(CqlAction.class);
private final int slot;
private final CqlActivity cqlActivity;
private final ActivityDef activityDef;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/core/CqlActivity.java
View File

@ -45,8 +45,8 @@ import io.nosqlbench.engine.api.util.SimpleConfig;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.engine.api.util.TagFilter;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.FileWriter;
import java.io.IOException;
@ -57,7 +57,7 @@ import java.util.*;
@SuppressWarnings("Duplicates")
public class CqlActivity extends SimpleActivity implements Activity, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(CqlActivity.class);
private final static Logger logger = LogManager.getLogger(CqlActivity.class);
private final ExceptionCountMetrics exceptionCountMetrics;
private final ExceptionHistoMetrics exceptionHistoMetrics;
private final ActivityDef activityDef;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/core/CqlAsyncAction.java
View File

@ -22,8 +22,8 @@ import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.SucceededOp
import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.concurrent.CompletionStage;
@ -33,7 +33,7 @@ import java.util.function.LongFunction;
@SuppressWarnings("Duplicates")
public class CqlAsyncAction extends BaseAsyncAction<CqlOpData, CqlActivity> {
private final static Logger logger = LoggerFactory.getLogger(CqlAsyncAction.class);
private final static Logger logger = LogManager.getLogger(CqlAsyncAction.class);
private final ActivityDef activityDef;
private List<RowCycleOperator> rowOps;

16
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/errorhandling/CQLExceptionEnum.java
View File

@ -1,18 +1,12 @@
package io.nosqlbench.activitytype.cqld4.errorhandling;
import com.datastax.dse.driver.api.core.servererrors.UnfitClientException;
import com.datastax.oss.driver.api.core.*;
import com.datastax.oss.driver.api.core.RequestThrottlingException;
import com.datastax.oss.driver.api.core.connection.ClosedConnectionException;
import com.datastax.oss.driver.api.core.connection.ConnectionInitException;
import com.datastax.oss.driver.api.core.connection.FrameTooLongException;
import com.datastax.oss.driver.api.core.connection.HeartbeatException;
import com.datastax.oss.driver.api.core.servererrors.*;
import com.datastax.oss.driver.internal.core.channel.ClusterNameMismatchException;
import com.datastax.oss.driver.shaded.guava.common.collect.ComputationException;
import io.nosqlbench.activitytype.cqld4.errorhandling.exceptions.CqlGenericCycleException;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.HashMap;
@ -92,10 +86,10 @@ public enum CQLExceptionEnum implements ResultReadable {
RequestThrottlingException(RequestThrottlingException.class,57),
CqlGenericCycleException(CqlGenericCycleException.class,58);
private final static Logger logger = LoggerFactory.getLogger(CQLExceptionEnum.class);
private final static Logger logger = LogManager.getLogger(CQLExceptionEnum.class);
private static Map<String, Integer> codesByName = getCodesByName();
private static String[] namesByCode = getNamesByCode();
private static final String[] namesByCode = getNamesByCode();
private final Class<? extends Exception> exceptionClass;
private final int resultCode;

10
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/errorhandling/HashedCQLErrorHandler.java
View File

@ -16,18 +16,18 @@ import io.nosqlbench.activitytype.cqld4.errorhandling.exceptions.RowVerification
import io.nosqlbench.engine.api.activityapi.errorhandling.CycleErrorHandler;
import io.nosqlbench.engine.api.activityapi.errorhandling.HashedErrorHandler;
import io.nosqlbench.engine.api.metrics.ExceptionCountMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class HashedCQLErrorHandler extends HashedErrorHandler<Throwable, ErrorStatus> {
private static final Logger logger = LoggerFactory.getLogger(HashedCQLErrorHandler.class);
private static final Logger logger = LogManager.getLogger(HashedCQLErrorHandler.class);
// private static Set<Class<? extends Throwable>> UNVERIFIED_ERRORS = new HashSet<Class<? extends Throwable>>() {{
// add(RowVerificationException.class);
// add(ResultSetVerificationException.class);
// }};
private ExceptionCountMetrics exceptionCountMetrics;
private static ThreadLocal<Integer> tlResultCode = ThreadLocal.withInitial(() -> (0));
private final ExceptionCountMetrics exceptionCountMetrics;
private static final ThreadLocal<Integer> tlResultCode = ThreadLocal.withInitial(() -> (0));
public HashedCQLErrorHandler(ExceptionCountMetrics exceptionCountMetrics) {
this.exceptionCountMetrics = exceptionCountMetrics;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/errorhandling/NBCycleErrorHandler.java
View File

@ -5,8 +5,8 @@ import io.nosqlbench.activitytype.cqld4.errorhandling.exceptions.CQLCycleWithSta
import io.nosqlbench.engine.api.activityapi.errorhandling.CycleErrorHandler;
import io.nosqlbench.engine.api.metrics.ExceptionCountMetrics;
import io.nosqlbench.engine.api.metrics.ExceptionHistoMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* A contextualized error handler that can catch a cycle-specific error.
@ -41,7 +41,7 @@ import org.slf4j.LoggerFactory;
@SuppressWarnings("Duplicates")
public class NBCycleErrorHandler implements CycleErrorHandler<Throwable, ErrorStatus> {
private static final Logger logger = LoggerFactory.getLogger(NBCycleErrorHandler.class);
private static final Logger logger = LogManager.getLogger(NBCycleErrorHandler.class);
private final ErrorResponse errorResponse;
private final ExceptionCountMetrics exceptionCountMetrics;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/binders/DiagnosticPreparedBinder.java
View File

@ -5,8 +5,8 @@ import com.datastax.oss.driver.api.core.cql.*;
import com.datastax.oss.driver.api.core.type.DataType;
import io.nosqlbench.activitytype.cqld4.core.CQLBindHelper;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
@ -19,7 +19,7 @@ import java.util.List;
*/
public class DiagnosticPreparedBinder implements ValuesArrayBinder<PreparedStatement, Statement<?>> {
public static final Logger logger = LoggerFactory.getLogger(DiagnosticPreparedBinder.class);
public static final Logger logger = LogManager.getLogger(DiagnosticPreparedBinder.class);
private final CqlSession session;
public DiagnosticPreparedBinder(CqlSession session) {

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/binders/DirectArrayValuesBinder.java
View File

@ -4,8 +4,8 @@ import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Arrays;
@ -20,7 +20,7 @@ import java.util.Arrays;
* will become the default.
*/
public class DirectArrayValuesBinder implements ValuesArrayBinder<PreparedStatement, Statement<?>> {
public final static Logger logger = LoggerFactory.getLogger(DirectArrayValuesBinder.class);
public final static Logger logger = LogManager.getLogger(DirectArrayValuesBinder.class);
private final CqlSession session;
public DirectArrayValuesBinder(CqlSession session) {

8
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/binders/UnsettableValuesBinder.java
View File

@ -1,6 +1,5 @@
package io.nosqlbench.activitytype.cqld4.statements.binders;
import com.datastax.driver.core.*;
import com.datastax.oss.driver.api.core.ProtocolVersion;
import com.datastax.oss.driver.api.core.cql.*;
import com.datastax.oss.driver.api.core.session.Session;
@ -9,16 +8,15 @@ import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import io.nosqlbench.virtdata.api.bindings.VALUE;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class UnsettableValuesBinder implements ValuesArrayBinder<PreparedStatement, Statement<?>> {
private final static Logger logger = LoggerFactory.getLogger(UnsettableValuesBinder.class);
private final static Logger logger = LogManager.getLogger(UnsettableValuesBinder.class);
private final Session session;
private final CodecRegistry codecRegistry;

10
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/core/CQLSessionCache.java
View File

@ -23,8 +23,8 @@ import io.nosqlbench.engine.api.scripting.NashornEvaluator;
import io.nosqlbench.engine.api.util.SSLKsFactory;
import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.graalvm.options.OptionMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.IOException;
@ -37,10 +37,10 @@ import java.util.concurrent.ConcurrentHashMap;
public class CQLSessionCache implements Shutdownable {
private final static Logger logger = LoggerFactory.getLogger(CQLSessionCache.class);
private final static Logger logger = LogManager.getLogger(CQLSessionCache.class);
private final static String DEFAULT_SESSION_ID = "default";
private static CQLSessionCache instance = new CQLSessionCache();
private Map<String, SessionConfig> sessionCache = new HashMap<>();
private static final CQLSessionCache instance = new CQLSessionCache();
private final Map<String, SessionConfig> sessionCache = new HashMap<>();
public final static class SessionConfig extends ConcurrentHashMap<String,String> {

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/core/CQLStatementDef.java
View File

@ -1,14 +1,14 @@
package io.nosqlbench.activitytype.cqld4.statements.core;
import com.datastax.oss.driver.api.core.ConsistencyLevel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.stream.Collectors;
public class CQLStatementDef {
private final static Logger logger = LoggerFactory.getLogger(CQLStatementDef.class);
private final static Logger logger = LogManager.getLogger(CQLStatementDef.class);
private Map<String,String> params = new HashMap<>();
private String name = "";

18
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/core/CQLStatementDefParser.java
View File

@ -1,7 +1,7 @@
package io.nosqlbench.activitytype.cqld4.statements.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.regex.Matcher;
@ -9,7 +9,7 @@ import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class CQLStatementDefParser {
private final static Logger logger = LoggerFactory.getLogger(CQLStatementDefParser.class);
private final static Logger logger = LogManager.getLogger(CQLStatementDefParser.class);
// private final static Pattern templateToken = Pattern.compile("<<(\\w+(:(.+?))?)>>");
private final static Pattern stmtToken = Pattern.compile("\\?(\\w+[-_\\d\\w]*)|\\{(\\w+[-_\\d\\w.]*)}");
private final static String UNSET_VALUE = "UNSET-VALUE";
@ -93,9 +93,7 @@ public class CQLStatementDefParser {
if (!namedBindings.contains(tokenName)) {
missingBindings.add(tokenName);
} else {
if (missingAnchors.contains(tokenName)) {
missingAnchors.remove(tokenName);
}
missingAnchors.remove(tokenName);
}
}
@ -114,11 +112,11 @@ public class CQLStatementDefParser {
}
public static class ParseResult {
private Set<String> missingGenerators;
private Set<String> missingAnchors;
private String statement;
private final Set<String> missingGenerators;
private final Set<String> missingAnchors;
private final String statement;
private Map<String,String> bindings;
private String name;
private final String name;
public ParseResult(String stmt, String name, Map<String,String> bindings, Set<String> missingGenerators, Set<String> missingAnchors) {
this.missingGenerators = missingGenerators;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/core/ReadyCQLStatementTemplate.java
View File

@ -16,15 +16,15 @@ import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import io.nosqlbench.virtdata.core.bindings.ContextualBindingsArrayTemplate;
import io.nosqlbench.virtdata.core.bindings.ValuesArrayBinder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.Writer;
import java.util.Map;
public class ReadyCQLStatementTemplate {
private final static Logger logger = LoggerFactory.getLogger(ReadyCQLStatementTemplate.class);
private final static Logger logger = LogManager.getLogger(ReadyCQLStatementTemplate.class);
private final Session session;
private final ContextualBindingsArrayTemplate<?, Statement<?>> template;
private final long ratio;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/core/YamlCQLStatementLoader.java
View File

@ -3,8 +3,8 @@ package io.nosqlbench.activitytype.cqld4.statements.core;
import io.nosqlbench.engine.api.activityimpl.ActivityInitializationError;
import io.nosqlbench.nb.api.content.Content;
import io.nosqlbench.nb.api.content.NBIO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.yaml.snakeyaml.TypeDescription;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.Constructor;
@ -17,7 +17,7 @@ import java.util.function.Function;
@SuppressWarnings("ALL")
public class YamlCQLStatementLoader {
private final static Logger logger = LoggerFactory.getLogger(YamlCQLStatementLoader.class);
private final static Logger logger = LogManager.getLogger(YamlCQLStatementLoader.class);
List<Function<String, String>> transformers = new ArrayList<>();
public YamlCQLStatementLoader() {

8
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/rowoperators/Save.java
View File

@ -4,8 +4,8 @@ import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
import com.datastax.oss.driver.api.core.cql.Row;
import io.nosqlbench.activitytype.cqld4.api.RowCycleOperator;
import io.nosqlbench.virtdata.library.basics.core.threadstate.SharedState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Arrays;
import java.util.HashMap;
@ -17,11 +17,11 @@ import java.util.stream.StreamSupport;
* Save specific variables to the thread local object map
*/
public class Save implements RowCycleOperator {
private final static Logger logger = LoggerFactory.getLogger(Save.class);
private final static Logger logger = LogManager.getLogger(Save.class);
ThreadLocal<HashMap<String, Object>> tl_objectMap = SharedState.tl_ObjectMap;
private String[] varnames;
private final String[] varnames;
public Save(String... varnames) {
this.varnames = varnames;

6
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/rsoperators/CqlD4ResultSetLogger.java
View File

@ -2,15 +2,15 @@ package io.nosqlbench.activitytype.cqld4.statements.rsoperators;
import com.datastax.oss.driver.api.core.cql.*;
import io.nosqlbench.activitytype.cqld4.api.D4ResultSetCycleOperator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* Logs a trace-level event for the result set, including
* cycles, rows, fetched row count, and the statement.
*/
public class CqlD4ResultSetLogger implements D4ResultSetCycleOperator {
private final static Logger logger = LoggerFactory.getLogger(CqlD4ResultSetLogger.class);
private final static Logger logger = LogManager.getLogger(CqlD4ResultSetLogger.class);
private static String getQueryString(Statement stmt) {
if (stmt instanceof PreparedStatement) {

8
driver-cqld4/src/main/java/io/nosqlbench/activitytype/cqld4/statements/rsoperators/TraceLogger.java
View File

@ -4,8 +4,8 @@ import com.datastax.oss.driver.api.core.cql.*;
import io.nosqlbench.activitytype.cqld4.api.D4ResultSetCycleOperator;
import io.nosqlbench.activitytype.cqld4.core.StatementModifier;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.FileDescriptor;
import java.io.FileWriter;
@ -15,9 +15,9 @@ import java.util.Date;
public class TraceLogger implements D4ResultSetCycleOperator, StatementModifier {
private final static Logger logger = LoggerFactory.getLogger(TraceLogger.class);
private final static Logger logger = LogManager.getLogger(TraceLogger.class);
private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
private static final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
private final long modulo;
private final String filename;
private final FileWriter writer;

6
driver-cqlverify/src/main/java/io/nosqlbench/activitytype/cqlverify/CqlVerifyActivity.java
View File

@ -5,8 +5,8 @@ import io.nosqlbench.activitytype.cql.statements.rsoperators.AssertSingleRowResu
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.virtdata.core.bindings.Bindings;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
@ -15,7 +15,7 @@ import java.util.Optional;
public class CqlVerifyActivity extends CqlActivity {
private final static Logger logger = LoggerFactory.getLogger(CqlVerifyActivity.class);
private final static Logger logger = LogManager.getLogger(CqlVerifyActivity.class);
private BindingsTemplate expectedValuesTemplate;
private VerificationMetrics verificationMetrics;

10
driver-diag/src/main/java/io/nosqlbench/activitytype/diag/AsyncDiagAction.java
View File

@ -24,8 +24,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.op_output.StrideOut
import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.ParameterMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.concurrent.BlockingQueue;
@ -38,7 +38,7 @@ import java.util.stream.Collectors;
public class AsyncDiagAction extends BaseAsyncAction<DiagOpData, DiagActivity> implements Thread.UncaughtExceptionHandler, StrideOutputConsumer<DiagOpData> {
private final static Logger logger = LoggerFactory.getLogger(AsyncDiagAction.class);
private final static Logger logger = LogManager.getLogger(AsyncDiagAction.class);
private long lastUpdate;
private long quantizedInterval;
@ -213,8 +213,8 @@ public class AsyncDiagAction extends BaseAsyncAction<DiagOpData, DiagActivity> i
private final AsyncDiagAction action;
AsyncDiagAction mainContext;
private volatile boolean running = true;
private Thread thread;
private String name;
private final Thread thread;
private final String name;
public OpFinisher(String name, BlockingQueue<StartedOp<DiagOpData>> queue, AsyncDiagAction action) {
this.queue = queue;

8
driver-diag/src/main/java/io/nosqlbench/activitytype/diag/DiagAction.java
View File

@ -20,16 +20,16 @@ import io.nosqlbench.engine.api.activityapi.core.MultiPhaseAction;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class DiagAction implements SyncAction, ActivityDefObserver, MultiPhaseAction {
private final static Logger logger = LoggerFactory.getLogger(DiagAction.class);
private final static Logger logger = LogManager.getLogger(DiagAction.class);
private final ActivityDef activityDef;
private final DiagActivity diagActivity;
private int slot;
private final int slot;
private long lastUpdate;
private long quantizedInterval;
private long reportModulo;

9
driver-diag/src/main/java/io/nosqlbench/activitytype/diag/DiagActionDispenser.java
View File

@ -16,14 +16,13 @@ package io.nosqlbench.activitytype.diag;
import io.nosqlbench.engine.api.activityapi.core.Action;
import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
import org.slf4j.Logger;
import static org.slf4j.LoggerFactory.getLogger;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class DiagActionDispenser implements ActionDispenser {
private final static Logger logger = getLogger(DiagActionDispenser.class);
private DiagActivity activity;
private final static Logger logger = LogManager.getLogger(DiagActionDispenser.class);
private final DiagActivity activity;
public DiagActionDispenser(DiagActivity activity) {
this.activity = activity;

6
driver-diag/src/main/java/io/nosqlbench/activitytype/diag/DiagActivityType.java
View File

@ -19,8 +19,8 @@ import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
import io.nosqlbench.engine.api.activityapi.core.ActivityType;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* The DiagActivity, aka "diag", is simply a diagnostic activity.
@ -33,7 +33,7 @@ import org.slf4j.LoggerFactory;
@Service(ActivityType.class)
public class DiagActivityType implements ActivityType<DiagActivity> {
private static final Logger logger = LoggerFactory.getLogger(DiagActivityType.class);
private static final Logger logger = LogManager.getLogger(DiagActivityType.class);
@Override
public String getName() {

6
driver-diag/src/main/java/io/nosqlbench/activitytype/diag/SequenceBlocker.java
View File

@ -17,14 +17,14 @@
package io.nosqlbench.activitytype.diag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.concurrent.atomic.AtomicLong;
public class SequenceBlocker {
private final static Logger logger = LoggerFactory.getLogger(SequenceBlocker.class);
private final static Logger logger = LogManager.getLogger(SequenceBlocker.class);
private final AtomicLong sequence;
private final AtomicLong waiting=new AtomicLong(0L);
private final boolean errorsAreFatal;

6
driver-http/src/main/java/io/nosqlbench/activitytype/http/HttpAction.java
View File

@ -8,8 +8,8 @@ import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.nb.api.errors.BasicError;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.*;
import java.net.http.HttpClient;
@ -23,7 +23,7 @@ import java.util.concurrent.TimeUnit;
public class HttpAction implements SyncAction {
private final static Logger logger = LoggerFactory.getLogger(HttpAction.class);
private final static Logger logger = LogManager.getLogger(HttpAction.class);
private final HttpActivity httpActivity;
private final int slot;

6
driver-http/src/main/java/io/nosqlbench/activitytype/http/HttpActivity.java
View File

@ -10,14 +10,14 @@ import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.SimpleActivity;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.net.http.HttpClient;
import java.util.function.Function;
public class HttpActivity extends SimpleActivity implements Activity, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(HttpActivity.class);
private final static Logger logger = LogManager.getLogger(HttpActivity.class);
private final ActivityDef activityDef;
public HttpConsoleFormats console;

6
driver-http/src/main/java/io/nosqlbench/activitytype/http/HttpActivityType.java
View File

@ -4,13 +4,13 @@ import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
import io.nosqlbench.engine.api.activityapi.core.ActivityType;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@Service(ActivityType.class)
public class HttpActivityType implements ActivityType<HttpActivity> {
private static final Logger logger = LoggerFactory.getLogger(HttpActivityType.class);
private static final Logger logger = LogManager.getLogger(HttpActivityType.class);
@Override
public String getName() {

6
driver-http/src/main/java/io/nosqlbench/activitytype/http/async/HttpAsyncAction.java
View File

@ -7,8 +7,8 @@ import io.nosqlbench.activitytype.http.HttpActivity;
import io.nosqlbench.engine.api.activityapi.core.BaseAsyncAction;
import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.net.http.HttpClient;
import java.net.http.HttpResponse;
@ -17,7 +17,7 @@ import java.util.function.LongFunction;
public class HttpAsyncAction extends BaseAsyncAction<HttpAsyncOp, HttpActivity> {
private final static Logger logger = LoggerFactory.getLogger(HttpAsyncAction.class);
private final static Logger logger = LogManager.getLogger(HttpAsyncAction.class);
private OpSequence<ReadyHttpOp> sequencer;
private HttpClient client;

6
driver-jmx/src/main/java/io/nosqlbench/driver/jmx/JMXAction.java
View File

@ -4,12 +4,12 @@ import io.nosqlbench.driver.jmx.ops.JmxOp;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class JMXAction implements SyncAction {
private final static Logger logger = LoggerFactory.getLogger(JMXAction.class);
private final static Logger logger = LogManager.getLogger(JMXAction.class);
private final ActivityDef activityDef;
private final int slot;

7
driver-jmx/src/main/java/io/nosqlbench/driver/jmx/SecureUtils.java
View File

@ -1,16 +1,15 @@
package io.nosqlbench.driver.jmx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.Console;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
public class SecureUtils {
private final static Logger logger = LoggerFactory.getLogger(SecureUtils.class);
private final static Logger logger = LogManager.getLogger(SecureUtils.class);
public static String readSecret(String description, String source) {
if (source==null) {

6
driver-jmx/src/main/java/io/nosqlbench/driver/jmx/ops/JmxOp.java
View File

@ -1,7 +1,7 @@
package io.nosqlbench.driver.jmx.ops;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
@ -12,7 +12,7 @@ import javax.management.remote.JMXConnector;
*/
public abstract class JmxOp {
protected final static Logger logger = LoggerFactory.getLogger(JmxOp.class);
protected final static Logger logger = LogManager.getLogger(JmxOp.class);
protected JMXConnector connector;
protected ObjectName objectName;

6
driver-kafka/src/main/java/com/datastax/ebdrivers/kafkaproducer/KafkaAction.java
View File

@ -2,13 +2,13 @@ package com.datastax.ebdrivers.kafkaproducer;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class KafkaAction implements SyncAction {
private final static Logger logger = LoggerFactory.getLogger(KafkaAction.class);
private final static Logger logger = LogManager.getLogger(KafkaAction.class);
private final KafkaProducerActivity activity;
private final int slot;

18
driver-kafka/src/main/java/com/datastax/ebdrivers/kafkaproducer/KafkaProducerActivity.java
View File

@ -4,7 +4,6 @@ import com.codahale.metrics.Timer;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityapi.planning.SequencePlanner;
import io.nosqlbench.engine.api.activityapi.planning.SequencerType;
import io.nosqlbench.engine.api.activityconfig.ParsedStmt;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
@ -12,22 +11,15 @@ import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.SimpleActivity;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import io.nosqlbench.virtdata.core.templates.StringBindingsTemplate;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.*;
import java.util.concurrent.Future;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class KafkaProducerActivity extends SimpleActivity {
private final static Logger logger = LoggerFactory.getLogger(KafkaProducerActivity.class);
private final static Logger logger = LogManager.getLogger(KafkaProducerActivity.class);
private String yamlLoc;
private String clientId;
private String servers;

6
driver-kafka/src/main/java/com/datastax/ebdrivers/kafkaproducer/KafkaStatement.java
View File

@ -9,8 +9,8 @@ import io.nosqlbench.virtdata.core.templates.StringBindings;
import io.nosqlbench.virtdata.core.templates.StringBindingsTemplate;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.IOException;
import java.nio.file.Files;
@ -20,7 +20,7 @@ import java.util.Properties;
import java.util.concurrent.Future;
public class KafkaStatement {
private final static Logger logger = LoggerFactory.getLogger(KafkaStatement.class);
private final static Logger logger = LogManager.getLogger(KafkaStatement.class);
private Producer<Object,Object> producer = null;
private final StringBindings bindings;

6
driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/MongoAction.java
View File

@ -2,8 +2,8 @@ package io.nosqlbench.driver.mongodb;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import com.codahale.metrics.Timer;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
@ -13,7 +13,7 @@ import org.bson.conversions.Bson;
public class MongoAction implements SyncAction {
private final static Logger logger = LoggerFactory.getLogger(MongoAction.class);
private final static Logger logger = LogManager.getLogger(MongoAction.class);
private final MongoActivity activity;
private final int slot;

6
driver-mongodb/src/main/java/io/nosqlbench/driver/mongodb/MongoActivity.java
View File

@ -5,8 +5,8 @@ import java.util.Objects;
import java.util.function.Function;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import com.codahale.metrics.Histogram;
import com.codahale.metrics.Timer;
@ -37,7 +37,7 @@ import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;
public class MongoActivity extends SimpleActivity implements ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(MongoActivity.class);
private final static Logger logger = LogManager.getLogger(MongoActivity.class);
private String yamlLoc;
private String connectionString;

30
driver-mongodb/src/test/java/io/nosqlbench/driver/mongodb/ReadyMongoStatementTest.java
View File

@ -1,28 +1,26 @@
package io.nosqlbench.driver.mongodb;
import io.nosqlbench.engine.api.activityconfig.ParsedStmt;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.virtdata.core.templates.BindPoint;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.nosqlbench.engine.api.activityconfig.ParsedStmt;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtDef;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.virtdata.core.templates.BindPoint;
import org.bson.conversions.Bson;
import static org.assertj.core.api.Assertions.assertThat;
public class ReadyMongoStatementTest {
private final static Logger logger = LoggerFactory.getLogger(ReadyMongoStatementTest.class);
private final static Logger logger = LogManager.getLogger(ReadyMongoStatementTest.class);
private ActivityDef activityDef;
private StmtsDocList stmtsDocList;

6
driver-stdout/src/main/java/io/nosqlbench/activitytype/stdout/AsyncStdoutAction.java
View File

@ -7,14 +7,14 @@ import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.function.LongFunction;
@SuppressWarnings("Duplicates")
public class AsyncStdoutAction extends BaseAsyncAction<StdoutOpContext, StdoutActivity> {
private final static Logger logger = LoggerFactory.getLogger(AsyncStdoutAction.class);
private final static Logger logger = LogManager.getLogger(AsyncStdoutAction.class);
private OpSequence<StringBindings> sequencer;

20
driver-stdout/src/main/java/io/nosqlbench/activitytype/stdout/StdoutAction.java
View File

@ -19,20 +19,20 @@ package io.nosqlbench.activitytype.stdout;
import com.codahale.metrics.Timer;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
import io.nosqlbench.engine.api.activityapi.planning.OpSource;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@SuppressWarnings("Duplicates")
public class StdoutAction implements SyncAction {
private static final Logger logger = LoggerFactory.getLogger(StdoutAction.class);
private int slot;
private StdoutActivity activity;
private int maxTries = 10;
private static final Logger logger = LogManager.getLogger(StdoutAction.class);
private final int slot;
private final StdoutActivity activity;
private final int maxTries = 10;
private boolean showstmts;
private OpSequence<StringBindings> sequencer;
private OpSource<StringBindings> opsource;
public StdoutAction(int slot, StdoutActivity activity) {
this.slot = slot;
@ -41,7 +41,7 @@ public class StdoutAction implements SyncAction {
@Override
public void init() {
this.sequencer = activity.getOpSequence();
this.opsource = activity.getOpSequence();
}
@Override
@ -49,7 +49,7 @@ public class StdoutAction implements SyncAction {
StringBindings stringBindings;
String statement = null;
try (Timer.Context bindTime = activity.bindTimer.time()) {
stringBindings = sequencer.get(cycleValue);
stringBindings = opsource.get(cycleValue);
statement = stringBindings.bind(cycleValue);
showstmts = activity.getShowstmts();
if (showstmts) {

6
driver-stdout/src/main/java/io/nosqlbench/activitytype/stdout/StdoutActivity.java
View File

@ -36,8 +36,8 @@ import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import io.nosqlbench.virtdata.core.templates.StringBindingsTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
@ -48,7 +48,7 @@ import java.util.regex.Pattern;
@SuppressWarnings("Duplicates")
public class StdoutActivity extends SimpleActivity implements ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(StdoutActivity.class);
private final static Logger logger = LogManager.getLogger(StdoutActivity.class);
private final Boolean showstmts;
private final StmtsDocList stmtsDocList;
public Timer bindTimer;

6
driver-tcp/src/main/java/io/nosqlbench/activitytype/tcpclient/TCPClientActivity.java
View File

@ -20,8 +20,8 @@ package io.nosqlbench.activitytype.tcpclient;
import io.nosqlbench.activitytype.stdout.StdoutActivity;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.util.SSLKsFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.net.SocketFactory;
import java.io.IOException;
@ -29,7 +29,7 @@ import java.io.PrintWriter;
import java.net.Socket;
public class TCPClientActivity extends StdoutActivity {
private final static Logger logger = LoggerFactory.getLogger(TCPClientActivity.class);
private final static Logger logger = LogManager.getLogger(TCPClientActivity.class);
public TCPClientActivity(ActivityDef activityDef) {
super(activityDef);

12
driver-tcp/src/main/java/io/nosqlbench/activitytype/tcpserver/TCPServerActivity.java
View File

@ -20,8 +20,8 @@ package io.nosqlbench.activitytype.tcpserver;
import io.nosqlbench.activitytype.stdout.StdoutActivity;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.util.SSLKsFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.net.ServerSocketFactory;
import javax.net.ssl.SSLServerSocketFactory;
@ -41,11 +41,11 @@ import java.util.concurrent.LinkedBlockingQueue;
public class TCPServerActivity extends StdoutActivity {
private final static Logger logger = LoggerFactory.getLogger(TCPServerActivity.class);
private final static Logger logger = LogManager.getLogger(TCPServerActivity.class);
private final ServerSocketFactory socketFactory;
private LinkedBlockingQueue<String> queue;
private final LinkedBlockingQueue<String> queue;
private ServerSocket listenerSocket;
private List<Shutdown> managedShutdown = new ArrayList<>();
private final List<Shutdown> managedShutdown = new ArrayList<>();
private int capacity=10;
@ -118,7 +118,7 @@ public class TCPServerActivity extends StdoutActivity {
}
private static interface Shutdown {
private interface Shutdown {
void shutdown();
}

10
driver-web/src/main/java/io/nosqlbench/driver/webdriver/WebContext.java
View File

@ -1,8 +1,8 @@
package io.nosqlbench.driver.webdriver;
import org.openqa.selenium.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Collection;
import java.util.HashMap;
@ -10,14 +10,14 @@ import java.util.LinkedList;
import java.util.List;
public class WebContext {
private final static Logger logger = LoggerFactory.getLogger(WebContext.class);
private final static Logger logger = LogManager.getLogger(WebContext.class);
private final WebDriver rootwindow;
WebDriver focus;
LinkedList<WebElement> elements = new LinkedList<>();
private LinkedList<Cookie> cookies = new LinkedList<>();
private HashMap<String,Object> vars = new HashMap<>();
private final LinkedList<Cookie> cookies = new LinkedList<>();
private final HashMap<String,Object> vars = new HashMap<>();
private Alert alert;
public WebContext(WebDriver initial) {

8
driver-web/src/main/java/io/nosqlbench/driver/webdriver/WebDriverAction.java
View File

@ -5,16 +5,14 @@ import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.templating.CommandTemplate;
import io.nosqlbench.nb.api.errors.BasicError;
import org.openqa.selenium.WebDriver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
/**
* Holds the definition and tracking state for a web driver command.
*/
public class WebDriverAction implements SyncAction, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger(WebDriverAction.class);
private final static Logger logger = LogManager.getLogger(WebDriverAction.class);
private final WebDriverActivity activity;
private final int slot;

13
driver-web/src/main/java/io/nosqlbench/driver/webdriver/WebDriverActivity.java
View File

@ -10,7 +10,6 @@ import io.nosqlbench.engine.api.activityapi.planning.SequencePlanner;
import io.nosqlbench.engine.api.activityapi.planning.SequencerType;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtDef;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.SimpleActivity;
@ -18,27 +17,29 @@ import io.nosqlbench.engine.api.templating.CommandTemplate;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.nb.api.content.NBIO;
import io.nosqlbench.nb.api.errors.BasicError;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
public class WebDriverActivity extends SimpleActivity {
private final static Logger logger = LoggerFactory.getLogger(WebDriverActivity.class);
private final static Logger logger = LogManager.getLogger(WebDriverActivity.class);
// private final StmtsDocList stmtsDocList;
private OpSequence<CommandTemplate> opSequence;
private ConcurrentHashMap<Integer,WebContext> contexts = new ConcurrentHashMap<>();
private final ConcurrentHashMap<Integer,WebContext> contexts = new ConcurrentHashMap<>();
// private static ThreadLocal<WebContext> TL_WebContext = new ThreadLocal<>();
public WebDriverActivity(ActivityDef activityDef) {

9
driver-web/src/main/java/io/nosqlbench/driver/webdriver/verbs/AssertElement.java
View File

@ -1,16 +1,13 @@
package io.nosqlbench.driver.webdriver.verbs;
import io.nosqlbench.driver.webdriver.WebContext;
import io.nosqlbench.nb.api.errors.BasicError;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class AssertElement implements WebDriverVerb {
private final static Logger logger = LoggerFactory.getLogger(AssertElement.class);
private final static Logger logger = LogManager.getLogger(AssertElement.class);
private final By by;
public AssertElement(By by) {

7
driver-web/src/main/java/io/nosqlbench/driver/webdriver/verbs/FindElement.java
View File

@ -1,15 +1,14 @@
package io.nosqlbench.driver.webdriver.verbs;
import io.nosqlbench.driver.webdriver.WebContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class FindElement implements WebDriverVerb {
private final static Logger logger = LoggerFactory.getLogger(FindElement.class);
private final static Logger logger = LogManager.getLogger(FindElement.class);
private final By by;

7
driver-web/src/main/java/io/nosqlbench/driver/webdriver/verbs/FindElements.java
View File

@ -1,17 +1,16 @@
package io.nosqlbench.driver.webdriver.verbs;
import io.nosqlbench.driver.webdriver.WebContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
public class FindElements implements WebDriverVerb {
private final static Logger logger = LoggerFactory.getLogger(FindElements.class);
private final static Logger logger = LogManager.getLogger(FindElements.class);
private final By by;

6
driver-web/src/main/java/io/nosqlbench/driver/webdriver/verbs/Get.java
View File

@ -1,11 +1,11 @@
package io.nosqlbench.driver.webdriver.verbs;
import io.nosqlbench.driver.webdriver.WebContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class Get implements WebDriverVerb {
private final static Logger logger = LoggerFactory.getLogger(Get.class);
private final static Logger logger = LogManager.getLogger(Get.class);
private final String target;

6
driver-web/src/main/java/io/nosqlbench/driver/webdriver/verbs/WebDriverVerbs.java
View File

@ -3,8 +3,8 @@ package io.nosqlbench.driver.webdriver.verbs;
import io.nosqlbench.driver.webdriver.WebContext;
import io.nosqlbench.engine.api.templating.CommandTemplate;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.Map;
@ -19,7 +19,7 @@ import java.util.function.Function;
* The JUnit exporter command generator</a>
*/
public class WebDriverVerbs {
private final static Logger logger = LoggerFactory.getLogger(WebDriverVerbs.class);
private final static Logger logger = LogManager.getLogger(WebDriverVerbs.class);
public final static String COMMAND = "command";
public enum Verb {

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/core/BaseAsyncAction.java
View File

@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityapi.core;
import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.ParameterMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
*
@ -29,7 +29,7 @@ import org.slf4j.LoggerFactory;
* @param <A> An type of of an Activity, a state holder for a runtime instance of an Activity
*/
public abstract class BaseAsyncAction<D, A extends Activity> implements AsyncAction<D>, Stoppable, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger("BaseAsyncAction");
private final static Logger logger = LogManager.getLogger("BaseAsyncAction");
protected final A activity;

12
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/buffers/results_rle/CycleResultsRLEBufferTarget.java
View File

@ -21,8 +21,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.nio.ByteBuffer;
import java.util.function.Predicate;
@ -40,7 +40,7 @@ import java.util.function.Predicate;
* will be deemed invalid and will cause an exception to be thrown.
*/
public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(CycleResultsRLEBufferTarget.class);
private final static Logger logger = LogManager.getLogger(CycleResultsRLEBufferTarget.class);
public final static int BYTES = Long.BYTES + Long.BYTES + Byte.BYTES;
@ -49,8 +49,8 @@ public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue
private long lastResult = Integer.MIN_VALUE;
private long runlength = 0L;
private boolean flushed = false;
private long count=0L;
private long min=Long.MAX_VALUE;
private final long count=0L;
private final long min=Long.MAX_VALUE;
private Predicate<ResultReadable> filter;
/**
@ -147,7 +147,7 @@ public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue
}
private static class ResultReadableWrapper implements ResultReadable {
private int result;
private final int result;
ResultReadableWrapper(int result) {
this.result = result;
}

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/filters/tristate/EnumReadableMappingFilter.java
View File

@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.activityapi.cyclelog.filters.tristate;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.regex.Pattern;
@ -31,10 +31,10 @@ import java.util.regex.Pattern;
* @param <E> The type of the Enum which implements TristateFilter
*/
public class EnumReadableMappingFilter<E extends Enum<E> & ResultReadable> implements TristateFilter<ResultReadable> {
private final static Logger logger = LoggerFactory.getLogger(EnumReadableMappingFilter.class);
private final static Logger logger = LogManager.getLogger(EnumReadableMappingFilter.class);
private final E[] enumValues;
private ResultMappingArrayFilter arrayFilter = new ResultMappingArrayFilter();
private final ResultMappingArrayFilter arrayFilter = new ResultMappingArrayFilter();
public EnumReadableMappingFilter(E[] enumValues, Policy defaultPolicy) {
this.enumValues = enumValues;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/inputs/cyclelog/CycleLogInput.java
View File

@ -27,8 +27,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results_rle.CycleRe
import io.nosqlbench.engine.api.activityapi.input.Input;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.RandomAccessFile;
@ -38,7 +38,7 @@ import java.util.Iterator;
import java.util.function.Predicate;
public class CycleLogInput implements Input, AutoCloseable, Iterable<CycleResultsSegment>, CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(CycleLogInput.class);
private final static Logger logger = LogManager.getLogger(CycleLogInput.class);
private final Iterator<CycleResultsSegment> cycleResultSegmentIterator;
private RandomAccessFile raf;
private MappedByteBuffer mbb;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/ReorderingConcurrentResultBuffer.java
View File

@ -23,8 +23,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Collections;
import java.util.LinkedList;
@ -36,10 +36,10 @@ import java.util.function.Predicate;
*/
public class ReorderingConcurrentResultBuffer implements Output, CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(ReorderingConcurrentResultBuffer.class);
private final static Logger logger = LogManager.getLogger(ReorderingConcurrentResultBuffer.class);
private LinkedList<CycleResultsSegment> segments = new LinkedList<>();
private Output downstream;
private final LinkedList<CycleResultsSegment> segments = new LinkedList<>();
private final Output downstream;
private final int threshold;
private int currentCount;
private int segmentCount;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/cyclelog/CycleLogOutput.java
View File

@ -26,8 +26,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results_rle.CycleSp
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.RandomAccessFile;
@ -51,13 +51,13 @@ import java.util.function.Predicate;
public class CycleLogOutput implements Output, CanFilterResultValue {
// For use in allocating file data, etc
private final static Logger logger = LoggerFactory.getLogger(CycleLogOutput.class);
private final static Logger logger = LogManager.getLogger(CycleLogOutput.class);
private MappedByteBuffer mbb;
private RandomAccessFile file;
// private FileBufferConfig config;
private CycleResultsRLEBufferTarget targetBuffer;
private int extentSizeInSpans;
private File outputFile;
private final int extentSizeInSpans;
private final File outputFile;
private Predicate<ResultReadable> filter;
public CycleLogOutput(Activity activity) {

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/cyclelog/CycleLogOutputType.java
View File

@ -24,8 +24,8 @@ import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityapi.output.OutputDispenser;
import io.nosqlbench.engine.api.activityapi.output.OutputType;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@Service(OutputType.class)
public class CycleLogOutputType implements OutputType {
@ -41,10 +41,10 @@ public class CycleLogOutputType implements OutputType {
}
public static class Dispenser implements OutputDispenser {
private final static Logger logger = LoggerFactory.getLogger(OutputDispenser.class);
private final static Logger logger = LogManager.getLogger(OutputDispenser.class);
private final Output output;
private Activity activity;
private final Activity activity;
public Dispenser(Activity activity) {
this.activity = activity;

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/logger/LoggingMarkerDispenser.java
View File

@ -21,14 +21,14 @@ import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityapi.output.OutputDispenser;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@Service(OutputDispenser.class)
public class LoggingMarkerDispenser implements OutputDispenser {
private final static Logger logger = LoggerFactory.getLogger(LoggingMarkerDispenser.class);
private Activity activity;
private final static Logger logger = LogManager.getLogger(LoggingMarkerDispenser.class);
private final Activity activity;
public LoggingMarkerDispenser(Activity activity) {
this.activity = activity;

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/logger/LoggingOutput.java
View File

@ -21,13 +21,13 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReada
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.function.Predicate;
public class LoggingOutput implements Output,CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(LoggingOutput.class);
private final static Logger logger = LogManager.getLogger(LoggingOutput.class);
private final ActivityDef def;
private final long slot;
@ -63,7 +63,7 @@ public class LoggingOutput implements Output,CanFilterResultValue {
}
private static class ResultReadableWrapper implements ResultReadable {
private int result;
private final int result;
public ResultReadableWrapper(int result) {
this.result = result;
}

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/errorhandling/CycleErrorHandlers.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.errorhandling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
@ -27,7 +27,7 @@ import java.util.List;
*/
public class CycleErrorHandlers {
private final static Logger logger = LoggerFactory.getLogger(CycleErrorHandlers.class);
private final static Logger logger = LogManager.getLogger(CycleErrorHandlers.class);
public static <T extends Throwable, R> CycleErrorHandler<T, R> log(R result) {
return (cycle, error, errMsg) -> {

12
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/errorhandling/HashedErrorHandler.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.errorhandling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
@ -59,15 +59,15 @@ import java.util.stream.Collectors;
* @param <R> The result type that will be produced by these error handlers.
*/
public class HashedErrorHandler<T extends Throwable, R> implements CycleErrorHandler<T, R> {
private final static Logger logger = LoggerFactory.getLogger(HashedErrorHandler.class);
private final static Logger logger = LogManager.getLogger(HashedErrorHandler.class);
private final CycleErrorHandler<T, R> DEFAULT_defaultHandler = (cycle, error, errMsg) -> {
throw new RuntimeException("no handler defined for type " + error.getClass() + " in cycle " + cycle + ", " + errMsg);
};
private Class<? extends Throwable> upperBound = Throwable.class;
private Map<String, Set<Class<? extends T>>> errorGroups = new ConcurrentHashMap<>();
private Map<Class<? extends T>, CycleErrorHandler<T, R>> handlers = new ConcurrentHashMap<>();
private Set<Class<? extends T>> validClasses = new HashSet<>();
private final Map<String, Set<Class<? extends T>>> errorGroups = new ConcurrentHashMap<>();
private final Map<Class<? extends T>, CycleErrorHandler<T, R>> handlers = new ConcurrentHashMap<>();
private final Set<Class<? extends T>> validClasses = new HashSet<>();
private CycleErrorHandler<T, R> defaultHandler = DEFAULT_defaultHandler;
/**

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/planning/SequencePlanner.java
View File

@ -17,15 +17,15 @@
package io.nosqlbench.engine.api.activityapi.planning;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
import java.util.function.ToLongFunction;
public class SequencePlanner<T> {
private final static Logger logger = LoggerFactory.getLogger(SequencePlanner.class);
private final static Logger logger = LogManager.getLogger(SequencePlanner.class);
private final SequencerType sequencerType;
private List<T> elements = new ArrayList<>();
private final List<Long> ratios = new ArrayList<>();

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/HybridRateLimiter.java
View File

@ -21,8 +21,8 @@ import com.codahale.metrics.Gauge;
import io.nosqlbench.engine.api.activityapi.core.Startable;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.atomic.AtomicLong;
@ -78,7 +78,7 @@ import java.util.concurrent.atomic.AtomicLong;
*/
public class HybridRateLimiter implements Startable, RateLimiter {
private final static Logger logger = LoggerFactory.getLogger(HybridRateLimiter.class);
private final static Logger logger = LogManager.getLogger(HybridRateLimiter.class);
private volatile TokenFiller filler;
private volatile long starttime;
@ -98,7 +98,7 @@ public class HybridRateLimiter implements Startable, RateLimiter {
// diagnostics
// TODO Doc rate limiter scenarios, including when you want to reset the waittime, and when you don't
private AtomicLong cumulativeWaitTimeNanos = new AtomicLong(0L);
private final AtomicLong cumulativeWaitTimeNanos = new AtomicLong(0L);
protected HybridRateLimiter() {
}

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiters.java
View File

@ -19,11 +19,11 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import com.codahale.metrics.Gauge;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class RateLimiters {
private final static Logger logger = LoggerFactory.getLogger(RateLimiters.class);
private final static Logger logger = LogManager.getLogger(RateLimiters.class);
public static synchronized RateLimiter createOrUpdate(ActivityDef def, String label, RateLimiter extant, RateSpec spec) {

11
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateSpec.java
View File

@ -19,8 +19,8 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import io.nosqlbench.engine.api.activityimpl.ParameterMap;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* <H2>Rate Limiter Specifications</H2>
@ -101,7 +101,7 @@ import org.slf4j.LoggerFactory;
*/
public class RateSpec {
private final static Logger logger = LoggerFactory.getLogger(RateSpec.class);
private final static Logger logger = LogManager.getLogger(RateSpec.class);
public static final double DEFAULT_RATE_OPS_S = 1.0D;
public static final double DEFAULT_BURST_RATIO = 1.1D;
@ -114,7 +114,7 @@ public class RateSpec {
public double burstRatio = DEFAULT_BURST_RATIO;
public Verb verb = Verb.start;
public static enum Verb {
public enum Verb {
/**
* Specify that a rate limiter should only be configured without affecting its running state.
* If the rate limiter is already running, then the configuration should take effect immediately.
@ -223,8 +223,7 @@ public class RateSpec {
RateSpec rateSpec = (RateSpec) o;
if (Double.compare(rateSpec.opsPerSec, opsPerSec) != 0) return false;
if (Double.compare(rateSpec.burstRatio, burstRatio) != 0) return false;
return true;
return Double.compare(rateSpec.burstRatio, burstRatio) == 0;
}
@Override

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/TokenFiller.java
View File

@ -20,14 +20,14 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import com.codahale.metrics.Timer;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
public class TokenFiller implements Runnable {
private final static Logger logger = LoggerFactory.getLogger(TokenFiller.class);
private final static Logger logger = LogManager.getLogger(TokenFiller.class);
public final static double MIN_PER_SECOND = 10D;
public final static double MAX_PER_SECOND = 1000D;
@ -40,7 +40,7 @@ public class TokenFiller implements Runnable {
private RateSpec rateSpec;
private Thread thread;
private volatile long lastRefillAt;
private Timer timer;
private final Timer timer;
/**
* A token filler adds tokens to a {@link TokenPool} at some rate.

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/TokenPool.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.ratelimits;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import static io.nosqlbench.engine.api.util.Colors.*;
@ -44,7 +44,7 @@ import static io.nosqlbench.engine.api.util.Colors.*;
*/
public class TokenPool {
private final static Logger logger = LoggerFactory.getLogger(TokenPool.class);
private final static Logger logger = LogManager.getLogger(TokenPool.class);
public static final double MIN_CONCURRENT_OPS = 2;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/sysperf/SysPerf.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.sysperf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.yaml.snakeyaml.Yaml;
import java.io.File;
@ -31,7 +31,7 @@ import java.nio.file.attribute.FileTime;
import java.util.Optional;
public class SysPerf {
public final static Logger logger = LoggerFactory.getLogger(SysPerf.class);
public final static Logger logger = LogManager.getLogger(SysPerf.class);
private static final Charset CHARSET = StandardCharsets.UTF_8;
private static SysPerfData cachedData;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/sysperf/SysPerfBaseliner.java
View File

@ -21,8 +21,8 @@ import org.openjdk.jmh.results.RunResult;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.nio.file.Files;
import java.util.ArrayList;
@ -32,7 +32,7 @@ import java.util.Map;
public class SysPerfBaseliner {
private final static Logger logger = LoggerFactory.getLogger(SysPerfBaseliner.class);
private final static Logger logger = LogManager.getLogger(SysPerfBaseliner.class);
public static void main(String[] args) {
try {

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/ParsedStmt.java
View File

@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityconfig;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtDef;
import io.nosqlbench.virtdata.core.templates.BindPoint;
import io.nosqlbench.virtdata.core.templates.ParsedTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.Map;
@ -39,7 +39,7 @@ import java.util.regex.Pattern;
public class ParsedStmt {
private final static Pattern stmtToken = Pattern.compile("\\?(\\w+[-_\\d\\w]*)|\\{(\\w+[-_\\d\\w.]*)}");
private final static Logger logger = LoggerFactory.getLogger(ParsedStmt.class);
private final static Logger logger = LogManager.getLogger(ParsedStmt.class);
private ParsedTemplate template;
private final StmtDef stmtDef;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/StatementsLoader.java
View File

@ -22,15 +22,15 @@ import io.nosqlbench.engine.api.activityconfig.rawyaml.RawStmtsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.nb.api.content.Content;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Map;
import java.util.function.Function;
public class StatementsLoader {
private final static Logger logger = LoggerFactory.getLogger(StatementsLoader.class);
private final static Logger logger = LogManager.getLogger(StatementsLoader.class);
public enum Loader {
original,

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/rawyaml/RawStmtFields.java
View File

@ -18,15 +18,15 @@
package io.nosqlbench.engine.api.activityconfig.rawyaml;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
public class RawStmtFields extends Tags {
private final static Logger logger = LoggerFactory.getLogger(RawStmtFields.class);
private final static Logger logger = LogManager.getLogger(RawStmtFields.class);
private String name = "";
private String desc = "";

2
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/rawyaml/RawStmtsLoader.java
View File

@ -4,7 +4,7 @@ import io.nosqlbench.engine.api.activityimpl.ActivityInitializationError;
import io.nosqlbench.nb.api.content.Content;
import io.nosqlbench.nb.api.content.NBIO;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.apache.logging.log4j.Logger;
import org.yaml.snakeyaml.Yaml;
import java.util.*;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/ActivityDef.java
View File

@ -19,8 +19,8 @@
package io.nosqlbench.engine.api.activityimpl;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.Optional;
@ -43,7 +43,7 @@ public class ActivityDef {
public static final String DEFAULT_ATYPE = "stdout ";
public static final String DEFAULT_CYCLES = "0";
public static final int DEFAULT_THREADS = 1;
private final static Logger logger = LoggerFactory.getLogger(ActivityDef.class);
private final static Logger logger = LogManager.getLogger(ActivityDef.class);
// an alias with which to control the activity while it is running
private static final String FIELD_ALIAS = "alias";
// a file or URL containing the activity: statements, generator bindings, ...
@ -52,11 +52,11 @@ public class ActivityDef {
private static final String FIELD_CYCLES = "cycles";
// initial thread concurrency for this activity
private static final String FIELD_THREADS = "threads";
private static String[] field_list = new String[]{
private static final String[] field_list = new String[]{
FIELD_ALIAS, FIELD_ATYPE, FIELD_CYCLES, FIELD_THREADS
};
// parameter map has its own internal atomic map
private ParameterMap parameterMap;
private final ParameterMap parameterMap;
public ActivityDef(ParameterMap parameterMap) {
this.parameterMap = parameterMap;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/CpuInfo.java
View File

@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityimpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.HardwareAbstractionLayer;
@ -27,7 +27,7 @@ import java.util.DoubleSummaryStatistics;
import java.util.Optional;
public class CpuInfo {
private final static Logger logger = LoggerFactory.getLogger(CpuInfo.class);
private final static Logger logger = LogManager.getLogger(CpuInfo.class);
final private static SystemInfo SYSTEM_INFO = new SystemInfo();

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/ParameterMap.java
View File

@ -15,13 +15,13 @@
package io.nosqlbench.engine.api.activityimpl;
import io.nosqlbench.engine.api.activityimpl.motor.ParamsParser;
import io.nosqlbench.nb.api.config.ParamsParser;
import io.nosqlbench.engine.api.util.Unit;
import org.graalvm.polyglot.Value;
import org.graalvm.polyglot.proxy.ProxyObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.script.Bindings;
import java.util.*;
@ -42,7 +42,7 @@ import java.util.stream.Collectors;
* generic type is parameterized for Bindings support.</p>
*/
public class ParameterMap extends ConcurrentHashMap<String,Object> implements Bindings, ProxyObject {
private final static Logger logger = LoggerFactory.getLogger(ParameterMap.class);
private final static Logger logger = LogManager.getLogger(ParameterMap.class);
// private final ConcurrentHashMap<String, String> paramMap = new ConcurrentHashMap<>(10);

Some files were not shown because too many files have changed in this diff Show More