code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public static String getPrefixedKeyString(Query query, Result result, List<String> typeNames) {
StringBuilder sb = new StringBuilder();
addTypeName(query, result, typeNames, sb);
addKeyString(query, result, sb);
return sb.toString();
}
|
java
|
private static void addMBeanIdentifier(Query query, Result result, StringBuilder sb) {
if (result.getKeyAlias() != null) {
sb.append(result.getKeyAlias());
} else if (query.isUseObjDomainAsKey()) {
sb.append(StringUtils.cleanupStr(result.getObjDomain(), query.isAllowDottedKeys()));
} else {
sb.append(StringUtils.cleanupStr(result.getClassName()));
}
}
|
java
|
@Override
public void validateSetup(Server server, Query query) throws ValidationException {
// Determine the spoofed hostname
spoofedHostName = getSpoofedHostName(server.getHost(), server.getAlias());
log.debug("Validated Ganglia metric [" +
HOST + ": " + host + ", " +
PORT + ": " + port + ", " +
ADDRESSING_MODE + ": " + addressingMode + ", " +
TTL + ": " + ttl + ", " +
V31 + ": " + v31 + ", " +
UNITS + ": '" + units + "', " +
SLOPE + ": " + slope + ", " +
TMAX + ": " + tmax + ", " +
DMAX + ": " + dmax + ", " +
SPOOF_NAME + ": " + spoofedHostName + ", " +
GROUP_NAME + ": '" + groupName + "']");
}
|
java
|
@Override
public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
for (final Result result : results) {
final String name = KeyUtils.getKeyString(query, result, getTypeNames());
Object transformedValue = valueTransformer.apply(result.getValue());
GMetricType dataType = getType(result.getValue());
log.debug("Sending Ganglia metric {}={} [type={}]", name, transformedValue, dataType);
try (GMetric metric = new GMetric(host, port, addressingMode, ttl, v31, null, spoofedHostName)) {
metric.announce(name, transformedValue.toString(), dataType, units, slope, tmax, dmax, groupName);
}
}
}
|
java
|
private static GMetricType getType(final Object obj) {
// FIXME This is far from covering all cases.
// FIXME Wasteful use of high capacity types (eg Short => INT32)
// Direct mapping when possible
if (obj instanceof Long || obj instanceof Integer || obj instanceof Byte || obj instanceof Short)
return GMetricType.INT32;
if (obj instanceof Float)
return GMetricType.FLOAT;
if (obj instanceof Double)
return GMetricType.DOUBLE;
// Convert to double or int if possible
try {
Double.parseDouble(obj.toString());
return GMetricType.DOUBLE;
} catch (NumberFormatException e) {
// Not a double
}
try {
Integer.parseInt(obj.toString());
return GMetricType.UINT32;
} catch (NumberFormatException e) {
// Not an int
}
return GMetricType.STRING;
}
|
java
|
public static Boolean getBooleanSetting(Map<String, Object> settings, String key, Boolean defaultVal) {
final Object value = settings.get(key);
if (value == null) {
return defaultVal;
}
if (value instanceof Boolean) {
return (Boolean) value;
}
if (value instanceof String) {
return Boolean.valueOf((String) value);
}
return defaultVal;
}
|
java
|
public static Integer getIntegerSetting(Map<String, Object> settings, String key, Integer defaultVal) {
final Object value = settings.get(key);
if (value == null) {
return defaultVal;
}
if (value instanceof Number) {
return ((Number) value).intValue();
}
if (value instanceof String) {
try {
return Integer.parseInt((String) value);
} catch (NumberFormatException e) {
return defaultVal;
}
}
return defaultVal;
}
|
java
|
public static String getStringSetting(Map<String, Object> settings, String key, String defaultVal) {
final Object value = settings.get(key);
return value != null ? value.toString() : defaultVal;
}
|
java
|
protected static int getIntSetting(Map<String, Object> settings, String key, int defaultVal) throws IllegalArgumentException {
if (settings.containsKey(key)) {
final Object objectValue = settings.get(key);
if (objectValue == null) {
throw new IllegalArgumentException("Setting '" + key + " null");
}
final String value = objectValue.toString();
try {
return Integer.parseInt(value);
} catch (Exception e) {
throw new IllegalArgumentException("Setting '" + key + "=" + value + "' is not an integer", e);
}
} else {
return defaultVal;
}
}
|
java
|
protected VelocityEngine getVelocityEngine(List<String> paths) {
VelocityEngine ve = new VelocityEngine();
ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "file");
ve.setProperty("cp.resource.loader.class", "org.apache.velocity.runtime.resource.loader.FileResourceLoader");
ve.setProperty("cp.resource.loader.cache", "true");
ve.setProperty("cp.resource.loader.path", StringUtils.join(paths, ","));
ve.setProperty("cp.resource.loader.modificationCheckInterval ", "10");
ve.setProperty("input.encoding", "UTF-8");
ve.setProperty("output.encoding", "UTF-8");
ve.setProperty("runtime.log", "");
return ve;
}
|
java
|
public JmxProcess parseProcess(File file) throws IOException {
String fileName = file.getName();
ObjectMapper mapper = fileName.endsWith(".yml") || fileName.endsWith(".yaml") ? yamlMapper : jsonMapper;
JsonNode jsonNode = mapper.readTree(file);
JmxProcess jmx = mapper.treeToValue(jsonNode, JmxProcess.class);
jmx.setName(fileName);
return jmx;
}
|
java
|
void addTags(StringBuilder resultString, Server server) {
if (hostnameTag) {
addTag(resultString, "host", server.getLabel());
}
// Add the constant tag names and values.
for (Map.Entry<String, String> tagEntry : tags.entrySet()) {
addTag(resultString, tagEntry.getKey(), tagEntry.getValue());
}
}
|
java
|
void addTag(StringBuilder resultString, String tagName, String tagValue) {
resultString.append(" ");
resultString.append(sanitizeString(tagName));
resultString.append("=");
resultString.append(sanitizeString(tagValue));
}
|
java
|
private void formatResultString(StringBuilder resultString, String metricName, long epoch, Object value) {
resultString.append(sanitizeString(metricName));
resultString.append(" ");
resultString.append(Long.toString(epoch));
resultString.append(" ");
resultString.append(sanitizeString(value.toString()));
}
|
java
|
protected void processOneMetric(List<String> resultStrings, Server server, Result result, Object value, String addTagName,
String addTagValue) {
String metricName = this.metricNameStrategy.formatName(result);
//
// Skip any non-numeric values since OpenTSDB only supports numeric metrics.
//
if (isNumeric(value)) {
StringBuilder resultString = new StringBuilder();
formatResultString(resultString, metricName, result.getEpoch() / 1000L, value);
addTags(resultString, server);
if (addTagName != null) {
addTag(resultString, addTagName, addTagValue);
}
if (!typeNames.isEmpty()) {
this.addTypeNamesTags(resultString, result);
}
resultStrings.add(resultString.toString());
} else {
log.debug("Skipping non-numeric value for metric {}; value={}", metricName, value);
}
}
|
java
|
private String getGatewayMessage(final List<Result> results) throws IOException {
int valueCount = 0;
Writer writer = new StringWriter();
JsonGenerator g = jsonFactory.createGenerator(writer);
g.writeStartObject();
g.writeNumberField("timestamp", System.currentTimeMillis() / 1000);
g.writeNumberField("proto_version", STACKDRIVER_PROTOCOL_VERSION);
g.writeArrayFieldStart("data");
List<String> typeNames = this.getTypeNames();
for (Result metric : results) {
if (isNumeric(metric.getValue())) {
// we have a numeric value, write a value into the message
StringBuilder nameBuilder = new StringBuilder();
// put the prefix if set
if (this.prefix != null) {
nameBuilder.append(prefix);
nameBuilder.append(".");
}
// put the class name or its alias if available
if (!metric.getKeyAlias().isEmpty()) {
nameBuilder.append(metric.getKeyAlias());
} else {
nameBuilder.append(metric.getClassName());
}
// Wildcard "typeNames" substitution
String typeName = com.googlecode.jmxtrans.model.naming.StringUtils.cleanupStr(
TypeNameValuesStringBuilder.getDefaultBuilder().build(typeNames, metric.getTypeName()));
if (typeName != null && typeName.length() > 0) {
nameBuilder.append(".");
nameBuilder.append(typeName);
}
// add the attribute name
nameBuilder.append(".");
nameBuilder.append(KeyUtils.getValueKey(metric));
// check for Float/Double NaN since these will cause the message validation to fail
if (metric.getValue() instanceof Float && ((Float) metric.getValue()).isNaN()) {
logger.info("Metric value for " + nameBuilder.toString() + " is NaN, skipping");
continue;
}
if (metric.getValue() instanceof Double && ((Double) metric.getValue()).isNaN()) {
logger.info("Metric value for " + nameBuilder.toString() + " is NaN, skipping");
continue;
}
valueCount++;
g.writeStartObject();
g.writeStringField("name", nameBuilder.toString());
g.writeNumberField("value", Double.valueOf(metric.getValue().toString()));
// if the metric is attached to an instance, include that in the message
if (instanceId != null && !instanceId.isEmpty()) {
g.writeStringField("instance", instanceId);
}
g.writeNumberField("collected_at", metric.getEpoch() / 1000);
g.writeEndObject();
}
}
g.writeEndArray();
g.writeEndObject();
g.flush();
g.close();
// return the message if there are any values to report
if (valueCount > 0) {
return writer.toString();
} else {
return null;
}
}
|
java
|
private void doSend(final String gatewayMessage) {
HttpURLConnection urlConnection = null;
try {
if (proxy == null) {
urlConnection = (HttpURLConnection) gatewayUrl.openConnection();
} else {
urlConnection = (HttpURLConnection) gatewayUrl.openConnection(proxy);
}
urlConnection.setRequestMethod("POST");
urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);
urlConnection.setReadTimeout(timeoutInMillis);
urlConnection.setRequestProperty("content-type", "application/json; charset=utf-8");
urlConnection.setRequestProperty("x-stackdriver-apikey", apiKey);
// Stackdriver's own implementation does not specify char encoding
// to use. Let's take the simplest approach and at lest ensure that
// if we have problems they can be reproduced in consistant ways.
// See https://github.com/Stackdriver/stackdriver-custommetrics-java/blob/master/src/main/java/com/stackdriver/api/custommetrics/CustomMetricsPoster.java#L262
// for details.
urlConnection.getOutputStream().write(gatewayMessage.getBytes(ISO_8859_1));
int responseCode = urlConnection.getResponseCode();
if (responseCode != 200 && responseCode != 201) {
logger.warn("Failed to send results to Stackdriver server: responseCode=" + responseCode + " message=" + urlConnection.getResponseMessage());
}
} catch (Exception e) {
logger.warn("Failure to send result to Stackdriver server", e);
} finally {
if (urlConnection != null) {
try {
InputStream in = urlConnection.getInputStream();
in.close();
InputStream err = urlConnection.getErrorStream();
if (err != null) {
err.close();
}
urlConnection.disconnect();
} catch (IOException e) {
logger.warn("Error flushing http connection for one result, continuing");
logger.debug("Stack trace for the http connection, usually a network timeout", e);
}
}
}
}
|
java
|
private void doMain() throws Exception {
// Start the process
this.start();
while (true) {
// look for some terminator
// attempt to read off queue
// process message
// TODO : Make something here, maybe watch for files?
try {
Thread.sleep(5);
} catch (Exception e) {
log.info("shutting down", e);
break;
}
}
this.unregisterMBeans();
}
|
java
|
private void stopWriterAndClearMasterServerList() {
for (Server server : this.masterServersList) {
for (OutputWriter writer : server.getOutputWriters()) {
try {
writer.close();
} catch (LifecycleException ex) {
log.error("Eror stopping writer: {}", writer);
}
}
for (Query query : server.getQueries()) {
for (OutputWriter writer : query.getOutputWriterInstances()) {
try {
writer.close();
log.debug("Stopped writer: {} for query: {}", writer, query);
} catch (LifecycleException ex) {
log.error("Error stopping writer: {} for query: {}", writer, query, ex);
}
}
}
}
this.masterServersList = ImmutableList.of();
}
|
java
|
private void startupWatchdir() throws Exception {
File dirToWatch;
if (this.configuration.getProcessConfigDirOrFile().isFile()) {
dirToWatch = new File(FilenameUtils.getFullPath(this.configuration.getProcessConfigDirOrFile().getAbsolutePath()));
} else {
dirToWatch = this.configuration.getProcessConfigDirOrFile();
}
// start the watcher
this.watcher = new WatchDir(dirToWatch, this);
this.watcher.start();
}
|
java
|
public void executeStandalone(JmxProcess process) throws Exception {
this.masterServersList = process.getServers();
this.serverScheduler.start();
this.processServersIntoJobs();
// Sleep for 10 seconds to wait for jobs to complete.
// There should be a better way, but it seems that way isn't working
// right now.
Thread.sleep(MILLISECONDS.convert(10, SECONDS));
}
|
java
|
private void processFilesIntoServers() throws LifecycleException {
// Shutdown the outputwriters and clear the current server list - this gives us a clean
// start when re-reading the json config files
try {
this.stopWriterAndClearMasterServerList();
} catch (Exception e) {
log.error("Error while clearing master server list: " + e.getMessage(), e);
throw new LifecycleException(e);
}
this.masterServersList = configurationParser.parseServers(getProcessConfigFiles(), configuration.isContinueOnJsonError());
}
|
java
|
private boolean isProcessConfigFile(File file) {
if (this.configuration.getProcessConfigDirOrFile().isFile()) {
return file.equals(this.configuration.getProcessConfigDirOrFile());
}
// If the file doesn't exist anymore, treat it as a regular file (to handle file deletion events)
if(file.exists() && !file.isFile()) {
return false;
}
final String fileName = file.getName();
return !fileName.startsWith(".") && (fileName.endsWith(".json") || fileName.endsWith(".yml") || fileName.endsWith(".yaml"));
}
|
java
|
@Override
@JsonIgnore
public JMXConnector getServerConnection() throws IOException {
JMXServiceURL url = getJmxServiceURL();
return JMXConnectorFactory.connect(url, this.getEnvironment());
}
|
java
|
@Override
public void validateSetup(Server server, Query query) throws ValidationException {
// Check if we've already created a logger for this file. If so, use it.
Logger logger;
if (loggers.containsKey(outputFile)) {
logger = getLogger(outputFile);
}else{
// need to create a logger
try {
logger = buildLogger(outputFile);
loggers.put(outputFile, logger);
} catch (IOException e) {
throw new ValidationException("Failed to setup logback", query, e);
}
}
logwriter = new LogWriter(logger,delimiter);
}
|
java
|
@Override
public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
graphiteWriter.write(logwriter, server, query, results);
}
|
java
|
private AmazonCloudWatchClient createCloudWatchClient() {
AmazonCloudWatchClient cloudWatchClient = new AmazonCloudWatchClient(new InstanceProfileCredentialsProvider());
cloudWatchClient.setRegion(checkNotNull(Regions.getCurrentRegion(), "Problems getting AWS metadata"));
return cloudWatchClient;
}
|
java
|
@Override
public String formatName(Result result) {
String formatted;
JexlContext context = new MapContext();
this.populateContext(context, result);
try {
formatted = (String) this.parsedExpr.evaluate(context);
} catch (JexlException jexlExc) {
LOG.error("error applying JEXL expression to query results", jexlExc);
formatted = null;
}
return formatted;
}
|
java
|
protected void populateContext(JexlContext context, Result result) {
context.set(VAR_CLASSNAME, result.getClassName());
context.set(VAR_ATTRIBUTE_NAME, result.getAttributeName());
context.set(VAR_CLASSNAME_ALIAS, result.getKeyAlias());
Map<String, String> typeNameMap = TypeNameValue.extractMap(result.getTypeName());
context.set(VAR_TYPENAME, typeNameMap);
String effectiveClassname = result.getKeyAlias();
if (effectiveClassname == null) {
effectiveClassname = result.getClassName();
}
context.set(VAR_EFFECTIVE_CLASSNAME, effectiveClassname);
context.set(VAR_RESULT, result);
}
|
java
|
public String getDataSourceName(String typeName, String attributeName, List<String> valuePath) {
String result;
String entry = StringUtils.join(valuePath, '.');
if (typeName != null) {
result = typeName + attributeName + entry;
} else {
result = attributeName + entry;
}
if (attributeName.length() > 15) {
String[] split = StringUtils.splitByCharacterTypeCamelCase(attributeName);
String join = StringUtils.join(split, '.');
attributeName = WordUtils.initials(join, INITIALS);
}
result = attributeName + DigestUtils.md5Hex(result);
result = StringUtils.left(result, 19);
return result;
}
|
java
|
protected void rrdToolUpdate(String template, String data) throws Exception {
List<String> commands = new ArrayList<>();
commands.add(binaryPath + "/rrdtool");
commands.add("update");
commands.add(outputFile.getCanonicalPath());
commands.add("-t");
commands.add(template);
commands.add("N:" + data);
ProcessBuilder pb = new ProcessBuilder(commands);
Process process = pb.start();
checkErrorStream(process);
}
|
java
|
protected void rrdToolCreateDatabase(RrdDef def) throws Exception {
List<String> commands = new ArrayList<>();
commands.add(this.binaryPath + "/rrdtool");
commands.add("create");
commands.add(this.outputFile.getCanonicalPath());
commands.add("-s");
commands.add(String.valueOf(def.getStep()));
for (DsDef dsdef : def.getDsDefs()) {
commands.add(getDsDefStr(dsdef));
}
for (ArcDef adef : def.getArcDefs()) {
commands.add(getRraStr(adef));
}
ProcessBuilder pb = new ProcessBuilder(commands);
Process process = pb.start();
try {
checkErrorStream(process);
} finally {
IOUtils.closeQuietly(process.getInputStream());
IOUtils.closeQuietly(process.getOutputStream());
IOUtils.closeQuietly(process.getErrorStream());
}
}
|
java
|
private void checkErrorStream(Process process) throws Exception {
// rrdtool should use platform encoding (unless you did something
// very strange with your installation of rrdtool). So let's be
// explicit and use the presumed correct encoding to read errors.
try (
InputStream is = process.getErrorStream();
InputStreamReader isr = new InputStreamReader(is, Charset.defaultCharset());
BufferedReader br = new BufferedReader(isr)
) {
StringBuilder sb = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
sb.append(line);
}
if (sb.length() > 0) {
throw new RuntimeException(sb.toString());
}
}
}
|
java
|
private String getRraStr(ArcDef def) {
return "RRA:" + def.getConsolFun() + ":" + def.getXff() + ":" + def.getSteps() + ":" + def.getRows();
}
|
java
|
private List<String> getDsNames(DsDef[] defs) {
List<String> names = new ArrayList<>();
for (DsDef def : defs) {
names.add(def.getDsName());
}
return names;
}
|
java
|
public void add(URL url) {
URLClassLoader sysLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
Class sysClass = URLClassLoader.class;
try {
Method method = sysClass.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(sysLoader, new Object[]{ url });
} catch (InvocationTargetException e) {
throw new JarLoadingException(e);
} catch (NoSuchMethodException e) {
throw new JarLoadingException(e);
} catch (IllegalAccessException e) {
throw new JarLoadingException(e);
}
}
|
java
|
private static void describeClassTree(Class<?> inputClass, Set<Class<?>> setOfClasses) {
// can't map null class
if(inputClass == null) {
return;
}
// don't further analyze a class that has been analyzed already
if(Object.class.equals(inputClass) || setOfClasses.contains(inputClass)) {
return;
}
// add to analysis set
setOfClasses.add(inputClass);
// perform super class analysis
describeClassTree(inputClass.getSuperclass(), setOfClasses);
// perform analysis on interfaces
for(Class<?> hasInterface : inputClass.getInterfaces()) {
describeClassTree(hasInterface, setOfClasses);
}
}
|
java
|
private static Set<Class<?>> describeClassTree(Class<?> inputClass) {
if(inputClass == null) {
return Collections.emptySet();
}
// create result collector
Set<Class<?>> classes = Sets.newLinkedHashSet();
// describe tree
describeClassTree(inputClass, classes);
return classes;
}
|
java
|
public void usage(StringBuilder out, String indent) {
if (commander.getDescriptions() == null) {
commander.createDescriptions();
}
boolean hasCommands = !commander.getCommands().isEmpty();
boolean hasOptions = !commander.getDescriptions().isEmpty();
// Indentation constants
final int descriptionIndent = 6;
final int indentCount = indent.length() + descriptionIndent;
// Append first line (aka main line) of the usage
appendMainLine(out, hasOptions, hasCommands, indentCount, indent);
// Align the descriptions at the "longestName" column
int longestName = 0;
List<ParameterDescription> sortedParameters = Lists.newArrayList();
for (ParameterDescription pd : commander.getFields().values()) {
if (!pd.getParameter().hidden()) {
sortedParameters.add(pd);
// + to have an extra space between the name and the description
int length = pd.getNames().length() + 2;
if (length > longestName) {
longestName = length;
}
}
}
// Sort the options
sortedParameters.sort(commander.getParameterDescriptionComparator());
// Append all the parameter names and descriptions
appendAllParametersDetails(out, indentCount, indent, sortedParameters);
// Append commands if they were specified
if (hasCommands) {
appendCommands(out, indentCount, descriptionIndent, indent);
}
}
|
java
|
@SuppressWarnings("deprecation")
private ResourceBundle findResourceBundle(Object o) {
ResourceBundle result = null;
Parameters p = o.getClass().getAnnotation(Parameters.class);
if (p != null && ! isEmpty(p.resourceBundle())) {
result = ResourceBundle.getBundle(p.resourceBundle(), Locale.getDefault());
} else {
com.beust.jcommander.ResourceBundle a = o.getClass().getAnnotation(
com.beust.jcommander.ResourceBundle.class);
if (a != null && ! isEmpty(a.value())) {
result = ResourceBundle.getBundle(a.value(), Locale.getDefault());
}
}
return result;
}
|
java
|
public final void addObject(Object object) {
if (object instanceof Iterable) {
// Iterable
for (Object o : (Iterable<?>) object) {
objects.add(o);
}
} else if (object.getClass().isArray()) {
// Array
for (Object o : (Object[]) object) {
objects.add(o);
}
} else {
// Single object
objects.add(object);
}
}
|
java
|
public void parse(String... args) {
try {
parse(true /* validate */, args);
} catch(ParameterException ex) {
ex.setJCommander(this);
throw ex;
}
}
|
java
|
private void validateOptions() {
// No validation if we found a help parameter
if (helpWasSpecified) {
return;
}
if (!requiredFields.isEmpty()) {
List<String> missingFields = new ArrayList<>();
for (ParameterDescription pd : requiredFields.values()) {
missingFields.add("[" + Strings.join(" | ", pd.getParameter().names()) + "]");
}
String message = Strings.join(", ", missingFields);
throw new ParameterException("The following "
+ pluralize(requiredFields.size(), "option is required: ", "options are required: ")
+ message);
}
if (mainParameter != null && mainParameter.description != null) {
ParameterDescription mainParameterDescription = mainParameter.description;
// Make sure we have a main parameter if it was required
if (mainParameterDescription.getParameter().required() &&
!mainParameterDescription.isAssigned()) {
throw new ParameterException("Main parameters are required (\""
+ mainParameterDescription.getDescription() + "\")");
}
// If the main parameter has an arity, make sure the correct number of parameters was passed
int arity = mainParameterDescription.getParameter().arity();
if (arity != Parameter.DEFAULT_ARITY) {
Object value = mainParameterDescription.getParameterized().get(mainParameter.object);
if (List.class.isAssignableFrom(value.getClass())) {
int size = ((List<?>) value).size();
if (size != arity) {
throw new ParameterException("There should be exactly " + arity + " main parameters but "
+ size + " were found");
}
}
}
}
}
|
java
|
private List<String> readFile(String fileName) {
List<String> result = Lists.newArrayList();
try (BufferedReader bufRead = Files.newBufferedReader(Paths.get(fileName), options.atFileCharset)) {
String line;
// Read through file one line at time. Print line # and line
while ((line = bufRead.readLine()) != null) {
// Allow empty lines and # comments in these at files
if (line.length() > 0 && !line.trim().startsWith("#")) {
result.add(line);
}
}
} catch (IOException e) {
throw new ParameterException("Could not read file " + fileName + ": " + e);
}
return result;
}
|
java
|
private static String trim(String string) {
String result = string.trim();
if (result.startsWith("\"") && result.endsWith("\"") && result.length() > 1) {
result = result.substring(1, result.length() - 1);
}
return result;
}
|
java
|
private char[] readPassword(String description, boolean echoInput) {
getConsole().print(description + ": ");
return getConsole().readPassword(echoInput);
}
|
java
|
public void setProgramName(String name, String... aliases) {
programName = new ProgramName(name, Arrays.asList(aliases));
}
|
java
|
public void addConverterFactory(final IStringConverterFactory converterFactory) {
addConverterInstanceFactory(new IStringConverterInstanceFactory() {
@SuppressWarnings("unchecked")
@Override
public IStringConverter<?> getConverterInstance(Parameter parameter, Class<?> forType, String optionName) {
final Class<? extends IStringConverter<?>> converterClass = converterFactory.getConverter(forType);
try {
if(optionName == null) {
optionName = parameter.names().length > 0 ? parameter.names()[0] : "[Main class]";
}
return converterClass != null ? instantiateConverter(optionName, converterClass) : null;
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new ParameterException(e);
}
}
});
}
|
java
|
public void addCommand(String name, Object object, String... aliases) {
JCommander jc = new JCommander(options);
jc.addObject(object);
jc.createDescriptions();
jc.setProgramName(name, aliases);
ProgramName progName = jc.programName;
commands.put(progName, jc);
/*
* Register aliases
*/
//register command name as an alias of itself for reverse lookup
//Note: Name clash check is intentionally omitted to resemble the
// original behaviour of clashing commands.
// Aliases are, however, are strictly checked for name clashes.
aliasMap.put(new StringKey(name), progName);
for (String a : aliases) {
IKey alias = new StringKey(a);
//omit pointless aliases to avoid name clash exception
if (!alias.equals(name)) {
ProgramName mappedName = aliasMap.get(alias);
if (mappedName != null && !mappedName.equals(progName)) {
throw new ParameterException("Cannot set alias " + alias
+ " for " + name
+ " command because it has already been defined for "
+ mappedName.name + " command");
}
aliasMap.put(alias, progName);
}
}
}
|
java
|
private boolean itemIsObscuredByHeader(RecyclerView parent, View item, View header, int orientation) {
RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) item.getLayoutParams();
mDimensionCalculator.initMargins(mTempRect1, header);
int adapterPosition = parent.getChildAdapterPosition(item);
if (adapterPosition == RecyclerView.NO_POSITION || mHeaderProvider.getHeader(parent, adapterPosition) != header) {
// Resolves https://github.com/timehop/sticky-headers-recyclerview/issues/36
// Handles an edge case where a trailing header is smaller than the current sticky header.
return false;
}
if (orientation == LinearLayoutManager.VERTICAL) {
int itemTop = item.getTop() - layoutParams.topMargin;
int headerBottom = getListTop(parent) + header.getBottom() + mTempRect1.bottom + mTempRect1.top;
if (itemTop >= headerBottom) {
return false;
}
} else {
int itemLeft = item.getLeft() - layoutParams.leftMargin;
int headerRight = getListLeft(parent) + header.getRight() + mTempRect1.right + mTempRect1.left;
if (itemLeft >= headerRight) {
return false;
}
}
return true;
}
|
java
|
public void drawHeader(RecyclerView recyclerView, Canvas canvas, View header, Rect offset) {
canvas.save();
if (recyclerView.getLayoutManager().getClipToPadding()) {
// Clip drawing of headers to the padding of the RecyclerView. Avoids drawing in the padding
initClipRectForHeader(mTempRect, recyclerView, header);
canvas.clipRect(mTempRect);
}
canvas.translate(offset.left, offset.top);
header.draw(canvas);
canvas.restore();
}
|
java
|
public static boolean isIanaRel(String relation) {
Assert.notNull(relation, "Link relation must not be null!");
return LINK_RELATIONS.stream() //
.anyMatch(it -> it.value().equalsIgnoreCase(relation));
}
|
java
|
public List<MethodParameter> getParametersOfType(Class<?> type) {
Assert.notNull(type, "Type must not be null!");
return getParameters().stream() //
.filter(it -> it.getParameterType().equals(type)) //
.collect(Collectors.toList());
}
|
java
|
public static boolean isTemplate(String candidate) {
return StringUtils.hasText(candidate) //
? VARIABLE_REGEX.matcher(candidate).find()
: false;
}
|
java
|
public List<String> getVariableNames() {
return variables.asList().stream() //
.map(TemplateVariable::getName) //
.collect(Collectors.toList());
}
|
java
|
private static String join(String typeMapping, String mapping) {
return MULTIPLE_SLASHES.matcher(typeMapping.concat("/").concat(mapping)).replaceAll("/");
}
|
java
|
public static String encodePath(Object source) {
Assert.notNull(source, "Path value must not be null!");
try {
return UriUtils.encodePath(source.toString(), ENCODING);
} catch (Throwable e) {
throw new IllegalStateException(e);
}
}
|
java
|
public static String encodeParameter(Object source) {
Assert.notNull(source, "Request parameter value must not be null!");
try {
return UriUtils.encodeQueryParam(source.toString(), ENCODING);
} catch (Throwable e) {
throw new IllegalStateException(e);
}
}
|
java
|
protected D createModelWithId(Object id, T entity) {
return createModelWithId(id, entity, new Object[0]);
}
|
java
|
private static void validate(RepresentationModel<?> resource, HalFormsAffordanceModel model) {
String affordanceUri = model.getURI();
String selfLinkUri = resource.getRequiredLink(IanaLinkRelations.SELF.value()).expand().getHref();
if (!affordanceUri.equals(selfLinkUri)) {
throw new IllegalStateException("Affordance's URI " + affordanceUri + " doesn't match self link " + selfLinkUri
+ " as expected in HAL-FORMS");
}
}
|
java
|
public Hop withParameter(String name, Object value) {
Assert.hasText(name, "Name must not be null or empty!");
HashMap<String, Object> parameters = new HashMap<>(this.parameters);
parameters.put(name, value);
return new Hop(this.rel, parameters, this.headers);
}
|
java
|
public Hop header(String headerName, String headerValue) {
Assert.hasText(headerName, "headerName must not be null or empty!");
if (this.headers == HttpHeaders.EMPTY) {
HttpHeaders newHeaders = new HttpHeaders();
newHeaders.add(headerName, headerValue);
return new Hop(this.rel, this.parameters, newHeaders);
}
this.headers.add(headerName, headerValue);
return this;
}
|
java
|
private static List<UberData> doExtractLinksAndContent(Object item) {
if (item instanceof EntityModel) {
return extractLinksAndContent((EntityModel<?>) item);
}
if (item instanceof RepresentationModel) {
return extractLinksAndContent((RepresentationModel<?>) item);
}
return extractLinksAndContent(new EntityModel<>(item));
}
|
java
|
@JsonIgnore
public HalFormsTemplate getTemplate(String key) {
Assert.notNull(key, "Template key must not be null!");
return this.templates.get(key);
}
|
java
|
public HalFormsDocument<T> andEmbedded(HalLinkRelation key, Object value) {
Assert.notNull(key, "Embedded key must not be null!");
Assert.notNull(value, "Embedded value must not be null!");
Map<HalLinkRelation, Object> embedded = new HashMap<>(this.embedded);
embedded.put(key, value);
return new HalFormsDocument<>(resource, resources, embedded, pageMetadata, links, templates);
}
|
java
|
@Nullable
public Object toRawData(JavaType javaType) {
if (this.data.isEmpty()) {
return null;
}
if (PRIMITIVE_TYPES.contains(javaType.getRawClass())) {
return this.data.get(0).getValue();
}
return PropertyUtils.createObjectFromProperties(javaType.getRawClass(), //
this.data.stream().collect(Collectors.toMap(CollectionJsonData::getName, CollectionJsonData::getValue)));
}
|
java
|
@SuppressWarnings("unchecked")
public T add(Link link) {
Assert.notNull(link, "Link must not be null!");
this.links.add(link);
return (T) this;
}
|
java
|
private static void insertJsonColumn(CqlSession session) {
User alice = new User("alice", 30);
User bob = new User("bob", 35);
// Build and execute a simple statement
Statement stmt =
insertInto("examples", "json_jackson_column")
.value("id", literal(1))
// the User object will be converted into a String and persisted into the VARCHAR column
// "json"
.value("json", literal(alice, session.getContext().getCodecRegistry()))
.build();
session.execute(stmt);
// The JSON object can be a bound value if the statement is prepared
// (subsequent calls to the prepare() method will return cached statement)
PreparedStatement pst =
session.prepare(
insertInto("examples", "json_jackson_column")
.value("id", bindMarker("id"))
.value("json", bindMarker("json"))
.build());
session.execute(pst.bind().setInt("id", 2).set("json", bob, User.class));
}
|
java
|
private static void selectJsonColumn(CqlSession session) {
Statement stmt =
selectFrom("examples", "json_jackson_column")
.all()
.whereColumn("id")
.in(literal(1), literal(2))
.build();
ResultSet rows = session.execute(stmt);
for (Row row : rows) {
int id = row.getInt("id");
// retrieve the JSON payload and convert it to a User instance
User user = row.get("json", User.class);
// it is also possible to retrieve the raw JSON payload
String json = row.getString("json");
System.out.printf(
"Retrieved row:%n id %d%n user %s%n user (raw) %s%n%n",
id, user, json);
}
}
|
java
|
public static String opcodeString(int opcode) {
switch (opcode) {
case ProtocolConstants.Opcode.ERROR:
return "ERROR";
case ProtocolConstants.Opcode.STARTUP:
return "STARTUP";
case ProtocolConstants.Opcode.READY:
return "READY";
case ProtocolConstants.Opcode.AUTHENTICATE:
return "AUTHENTICATE";
case ProtocolConstants.Opcode.OPTIONS:
return "OPTIONS";
case ProtocolConstants.Opcode.SUPPORTED:
return "SUPPORTED";
case ProtocolConstants.Opcode.QUERY:
return "QUERY";
case ProtocolConstants.Opcode.RESULT:
return "RESULT";
case ProtocolConstants.Opcode.PREPARE:
return "PREPARE";
case ProtocolConstants.Opcode.EXECUTE:
return "EXECUTE";
case ProtocolConstants.Opcode.REGISTER:
return "REGISTER";
case ProtocolConstants.Opcode.EVENT:
return "EVENT";
case ProtocolConstants.Opcode.BATCH:
return "BATCH";
case ProtocolConstants.Opcode.AUTH_CHALLENGE:
return "AUTH_CHALLENGE";
case ProtocolConstants.Opcode.AUTH_RESPONSE:
return "AUTH_RESPONSE";
case ProtocolConstants.Opcode.AUTH_SUCCESS:
return "AUTH_SUCCESS";
default:
return "0x" + Integer.toHexString(opcode);
}
}
|
java
|
public static String errorCodeString(int errorCode) {
switch (errorCode) {
case ProtocolConstants.ErrorCode.SERVER_ERROR:
return "SERVER_ERROR";
case ProtocolConstants.ErrorCode.PROTOCOL_ERROR:
return "PROTOCOL_ERROR";
case ProtocolConstants.ErrorCode.AUTH_ERROR:
return "AUTH_ERROR";
case ProtocolConstants.ErrorCode.UNAVAILABLE:
return "UNAVAILABLE";
case ProtocolConstants.ErrorCode.OVERLOADED:
return "OVERLOADED";
case ProtocolConstants.ErrorCode.IS_BOOTSTRAPPING:
return "IS_BOOTSTRAPPING";
case ProtocolConstants.ErrorCode.TRUNCATE_ERROR:
return "TRUNCATE_ERROR";
case ProtocolConstants.ErrorCode.WRITE_TIMEOUT:
return "WRITE_TIMEOUT";
case ProtocolConstants.ErrorCode.READ_TIMEOUT:
return "READ_TIMEOUT";
case ProtocolConstants.ErrorCode.READ_FAILURE:
return "READ_FAILURE";
case ProtocolConstants.ErrorCode.FUNCTION_FAILURE:
return "FUNCTION_FAILURE";
case ProtocolConstants.ErrorCode.WRITE_FAILURE:
return "WRITE_FAILURE";
case ProtocolConstants.ErrorCode.SYNTAX_ERROR:
return "SYNTAX_ERROR";
case ProtocolConstants.ErrorCode.UNAUTHORIZED:
return "UNAUTHORIZED";
case ProtocolConstants.ErrorCode.INVALID:
return "INVALID";
case ProtocolConstants.ErrorCode.CONFIG_ERROR:
return "CONFIG_ERROR";
case ProtocolConstants.ErrorCode.ALREADY_EXISTS:
return "ALREADY_EXISTS";
case ProtocolConstants.ErrorCode.UNPREPARED:
return "UNPREPARED";
default:
return "0x" + Integer.toHexString(errorCode);
}
}
|
java
|
public void reconnectNow(boolean forceIfStopped) {
assert executor.inEventLoop();
if (state == State.ATTEMPT_IN_PROGRESS || state == State.STOP_AFTER_CURRENT) {
LOG.debug(
"[{}] reconnectNow and current attempt was still running, letting it complete",
logPrefix);
if (state == State.STOP_AFTER_CURRENT) {
// Make sure that we will schedule other attempts if this one fails.
state = State.ATTEMPT_IN_PROGRESS;
}
} else if (state == State.STOPPED && !forceIfStopped) {
LOG.debug("[{}] reconnectNow(false) while stopped, nothing to do", logPrefix);
} else {
assert state == State.SCHEDULED || (state == State.STOPPED && forceIfStopped);
LOG.debug("[{}] Forcing next attempt now", logPrefix);
if (nextAttempt != null) {
nextAttempt.cancel(true);
}
try {
onNextAttemptStarted(reconnectionTask.call());
} catch (Exception e) {
Loggers.warnWithException(
LOG, "[{}] Uncaught error while starting reconnection attempt", logPrefix, e);
scheduleNextAttempt();
}
}
}
|
java
|
private void onNextAttemptStarted(CompletionStage<Boolean> futureOutcome) {
assert executor.inEventLoop();
state = State.ATTEMPT_IN_PROGRESS;
futureOutcome
.whenCompleteAsync(this::onNextAttemptCompleted, executor)
.exceptionally(UncaughtExceptions::log);
}
|
java
|
public static <T> T getCompleted(CompletionStage<T> stage) {
CompletableFuture<T> future = stage.toCompletableFuture();
Preconditions.checkArgument(future.isDone() && !future.isCompletedExceptionally());
try {
return future.get();
} catch (InterruptedException | ExecutionException e) {
// Neither can happen given the precondition
throw new AssertionError("Unexpected error", e);
}
}
|
java
|
public static Throwable getFailed(CompletionStage<?> stage) {
CompletableFuture<?> future = stage.toCompletableFuture();
Preconditions.checkArgument(future.isCompletedExceptionally());
try {
future.get();
throw new AssertionError("future should be failed");
} catch (InterruptedException e) {
throw new AssertionError("Unexpected error", e);
} catch (ExecutionException e) {
return e.getCause();
}
}
|
java
|
private CompletionStage<Void> prepareOnOtherNode(Node node) {
LOG.trace("[{}] Repreparing on {}", logPrefix, node);
DriverChannel channel = session.getChannel(node, logPrefix);
if (channel == null) {
LOG.trace("[{}] Could not get a channel to reprepare on {}, skipping", logPrefix, node);
return CompletableFuture.completedFuture(null);
} else {
ThrottledAdminRequestHandler handler =
new ThrottledAdminRequestHandler(
channel,
message,
request.getCustomPayload(),
timeout,
throttler,
session.getMetricUpdater(),
logPrefix,
message.toString());
return handler
.start()
.handle(
(result, error) -> {
if (error == null) {
LOG.trace("[{}] Successfully reprepared on {}", logPrefix, node);
} else {
Loggers.warnWithException(
LOG, "[{}] Error while repreparing on {}", node, logPrefix, error);
}
return null;
});
}
}
|
java
|
private static void insertJsonColumn(CqlSession session) {
JsonObject alice = Json.createObjectBuilder().add("name", "alice").add("age", 30).build();
JsonObject bob = Json.createObjectBuilder().add("name", "bob").add("age", 35).build();
// Build and execute a simple statement
Statement stmt =
insertInto("examples", "json_jsr353_column")
.value("id", literal(1))
// the JSON object will be converted into a String and persisted into the VARCHAR column
// "json"
.value("json", literal(alice, session.getContext().getCodecRegistry()))
.build();
session.execute(stmt);
// The JSON object can be a bound value if the statement is prepared
// (subsequent calls to the prepare() method will return cached statement)
PreparedStatement pst =
session.prepare(
insertInto("examples", "json_jsr353_column")
.value("id", bindMarker("id"))
.value("json", bindMarker("json"))
.build());
session.execute(
pst.bind()
.setInt("id", 2)
// note that the codec requires that the type passed to the set() method
// be always JsonStructure, and not a subclass of it, such as JsonObject
.set("json", bob, JsonStructure.class));
}
|
java
|
public static void warnWithException(Logger logger, String format, Object... arguments) {
if (logger.isDebugEnabled()) {
logger.warn(format, arguments);
} else {
Object last = arguments[arguments.length - 1];
if (last instanceof Throwable) {
Throwable t = (Throwable) last;
arguments[arguments.length - 1] = t.getClass().getSimpleName() + ": " + t.getMessage();
logger.warn(format + " ({})", arguments);
} else {
// Should only be called with an exception as last argument, but handle gracefully anyway
logger.warn(format, arguments);
}
}
}
|
java
|
private void savePort(DriverChannel channel) {
if (port < 0) {
SocketAddress address = channel.getEndPoint().resolve();
if (address instanceof InetSocketAddress) {
port = ((InetSocketAddress) address).getPort();
}
}
}
|
java
|
@NonNull
@Override
public Iterator<AdminRow> iterator() {
return new AbstractIterator<AdminRow>() {
@Override
protected AdminRow computeNext() {
List<ByteBuffer> rowData = data.poll();
return (rowData == null)
? endOfData()
: new AdminRow(columnSpecs, rowData, protocolVersion);
}
};
}
|
java
|
protected TypeCodec<?> createCodec(GenericType<?> javaType, boolean isJavaCovariant) {
TypeToken<?> token = javaType.__getToken();
if (List.class.isAssignableFrom(token.getRawType())
&& token.getType() instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) token.getType()).getActualTypeArguments();
GenericType<?> elementType = GenericType.of(typeArguments[0]);
TypeCodec<?> elementCodec = codecFor(elementType, isJavaCovariant);
return TypeCodecs.listOf(elementCodec);
} else if (Set.class.isAssignableFrom(token.getRawType())
&& token.getType() instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) token.getType()).getActualTypeArguments();
GenericType<?> elementType = GenericType.of(typeArguments[0]);
TypeCodec<?> elementCodec = codecFor(elementType, isJavaCovariant);
return TypeCodecs.setOf(elementCodec);
} else if (Map.class.isAssignableFrom(token.getRawType())
&& token.getType() instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) token.getType()).getActualTypeArguments();
GenericType<?> keyType = GenericType.of(typeArguments[0]);
GenericType<?> valueType = GenericType.of(typeArguments[1]);
TypeCodec<?> keyCodec = codecFor(keyType, isJavaCovariant);
TypeCodec<?> valueCodec = codecFor(valueType, isJavaCovariant);
return TypeCodecs.mapOf(keyCodec, valueCodec);
}
throw new CodecNotFoundException(null, javaType);
}
|
java
|
protected TypeCodec<?> createCodec(DataType cqlType) {
if (cqlType instanceof ListType) {
DataType elementType = ((ListType) cqlType).getElementType();
TypeCodec<Object> elementCodec = codecFor(elementType);
return TypeCodecs.listOf(elementCodec);
} else if (cqlType instanceof SetType) {
DataType elementType = ((SetType) cqlType).getElementType();
TypeCodec<Object> elementCodec = codecFor(elementType);
return TypeCodecs.setOf(elementCodec);
} else if (cqlType instanceof MapType) {
DataType keyType = ((MapType) cqlType).getKeyType();
DataType valueType = ((MapType) cqlType).getValueType();
TypeCodec<Object> keyCodec = codecFor(keyType);
TypeCodec<Object> valueCodec = codecFor(valueType);
return TypeCodecs.mapOf(keyCodec, valueCodec);
} else if (cqlType instanceof TupleType) {
return TypeCodecs.tupleOf((TupleType) cqlType);
} else if (cqlType instanceof UserDefinedType) {
return TypeCodecs.udtOf((UserDefinedType) cqlType);
} else if (cqlType instanceof CustomType) {
return TypeCodecs.custom(cqlType);
}
throw new CodecNotFoundException(cqlType, null);
}
|
java
|
private static <DeclaredT, RuntimeT> TypeCodec<DeclaredT> uncheckedCast(
TypeCodec<RuntimeT> codec) {
@SuppressWarnings("unchecked")
TypeCodec<DeclaredT> result = (TypeCodec<DeclaredT>) codec;
return result;
}
|
java
|
protected long computeNext(long last) {
long currentTick = clock.currentTimeMicros();
if (last >= currentTick) {
maybeLog(currentTick, last);
return last + 1;
}
return currentTick;
}
|
java
|
public static int skipSpaces(String toParse, int idx) {
while (isBlank(toParse.charAt(idx)) && idx < toParse.length()) ++idx;
return idx;
}
|
java
|
public static int skipCQLValue(String toParse, int idx) {
if (idx >= toParse.length()) throw new IllegalArgumentException();
if (isBlank(toParse.charAt(idx))) throw new IllegalArgumentException();
int cbrackets = 0;
int sbrackets = 0;
int parens = 0;
boolean inString = false;
do {
char c = toParse.charAt(idx);
if (inString) {
if (c == '\'') {
if (idx + 1 < toParse.length() && toParse.charAt(idx + 1) == '\'') {
++idx; // this is an escaped quote, skip it
} else {
inString = false;
if (cbrackets == 0 && sbrackets == 0 && parens == 0) return idx + 1;
}
}
// Skip any other character
} else if (c == '\'') {
inString = true;
} else if (c == '{') {
++cbrackets;
} else if (c == '[') {
++sbrackets;
} else if (c == '(') {
++parens;
} else if (c == '}') {
if (cbrackets == 0) return idx;
--cbrackets;
if (cbrackets == 0 && sbrackets == 0 && parens == 0) return idx + 1;
} else if (c == ']') {
if (sbrackets == 0) return idx;
--sbrackets;
if (cbrackets == 0 && sbrackets == 0 && parens == 0) return idx + 1;
} else if (c == ')') {
if (parens == 0) return idx;
--parens;
if (cbrackets == 0 && sbrackets == 0 && parens == 0) return idx + 1;
} else if (isBlank(c) || !isCqlIdentifierChar(c)) {
if (cbrackets == 0 && sbrackets == 0 && parens == 0) return idx;
}
} while (++idx < toParse.length());
if (inString || cbrackets != 0 || sbrackets != 0 || parens != 0)
throw new IllegalArgumentException();
return idx;
}
|
java
|
public static int skipCQLId(String toParse, int idx) {
if (idx >= toParse.length()) throw new IllegalArgumentException();
char c = toParse.charAt(idx);
if (isCqlIdentifierChar(c)) {
while (idx < toParse.length() && isCqlIdentifierChar(toParse.charAt(idx))) idx++;
return idx;
}
if (c != '"') throw new IllegalArgumentException();
while (++idx < toParse.length()) {
c = toParse.charAt(idx);
if (c != '"') continue;
if (idx + 1 < toParse.length() && toParse.charAt(idx + 1) == '\"')
++idx; // this is an escaped double quote, skip it
else return idx + 1;
}
throw new IllegalArgumentException();
}
|
java
|
public <EventT> Object register(Class<EventT> eventClass, Consumer<EventT> listener) {
LOG.debug("[{}] Registering {} for {}", logPrefix, listener, eventClass);
listeners.put(eventClass, listener);
// The reason for the key mechanism is that this will often be used with method references,
// and you get a different object every time you reference a method, so register(Foo::bar)
// followed by unregister(Foo::bar) wouldn't work as expected.
return listener;
}
|
java
|
public <EventT> boolean unregister(Object key, Class<EventT> eventClass) {
LOG.debug("[{}] Unregistering {} for {}", logPrefix, key, eventClass);
return listeners.remove(eventClass, key);
}
|
java
|
public void fire(Object event) {
LOG.debug("[{}] Firing an instance of {}: {}", logPrefix, event.getClass(), event);
// if the exact match thing gets too cumbersome, we can reconsider, but I'd like to avoid
// scanning all the keys with instanceof checks.
Class<?> eventClass = event.getClass();
for (Consumer<?> l : listeners.get(eventClass)) {
@SuppressWarnings("unchecked")
Consumer<Object> listener = (Consumer<Object>) l;
LOG.debug("[{}] Notifying {} of {}", logPrefix, listener, event);
listener.accept(event);
}
}
|
java
|
public static boolean needsDoubleQuotes(String s) {
// this method should only be called for C*-provided identifiers,
// so we expect it to be non-null and non-empty.
assert s != null && !s.isEmpty();
char c = s.charAt(0);
if (!(c >= 97 && c <= 122)) // a-z
return true;
for (int i = 1; i < s.length(); i++) {
c = s.charAt(i);
if (!((c >= 48 && c <= 57) // 0-9
|| (c == 95) // _
|| (c >= 97 && c <= 122) // a-z
)) {
return true;
}
}
return isReservedCqlKeyword(s);
}
|
java
|
public static boolean isLongLiteral(String str) {
if (str == null || str.isEmpty()) return false;
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if ((c < '0' && (i != 0 || c != '-')) || c > '9') return false;
}
return true;
}
|
java
|
@NonNull
public String asCql(boolean pretty) {
if (pretty) {
return Strings.needsDoubleQuotes(internal) ? Strings.doubleQuote(internal) : internal;
} else {
return Strings.doubleQuote(internal);
}
}
|
java
|
public Map<String, String> build() {
NullAllowingImmutableMap.Builder<String, String> builder = NullAllowingImmutableMap.builder(3);
// add compression (if configured) and driver name and version
String compressionAlgorithm = context.getCompressor().algorithm();
if (compressionAlgorithm != null && !compressionAlgorithm.trim().isEmpty()) {
builder.put(Startup.COMPRESSION_KEY, compressionAlgorithm.trim());
}
return builder
.put(DRIVER_NAME_KEY, getDriverName())
.put(DRIVER_VERSION_KEY, getDriverVersion())
.build();
}
|
java
|
private void connect() {
session = CqlSession.builder().build();
System.out.printf("Connected to session: %s%n", session.getName());
}
|
java
|
private void write(ConsistencyLevel cl, int retryCount) {
System.out.printf("Writing at %s (retry count: %d)%n", cl, retryCount);
BatchStatement batch =
BatchStatement.newInstance(UNLOGGED)
.add(
SimpleStatement.newInstance(
"INSERT INTO downgrading.sensor_data "
+ "(sensor_id, date, timestamp, value) "
+ "VALUES ("
+ "756716f7-2e54-4715-9f00-91dcbea6cf50,"
+ "'2018-02-26',"
+ "'2018-02-26T13:53:46.345+01:00',"
+ "2.34)"))
.add(
SimpleStatement.newInstance(
"INSERT INTO downgrading.sensor_data "
+ "(sensor_id, date, timestamp, value) "
+ "VALUES ("
+ "756716f7-2e54-4715-9f00-91dcbea6cf50,"
+ "'2018-02-26',"
+ "'2018-02-26T13:54:27.488+01:00',"
+ "2.47)"))
.add(
SimpleStatement.newInstance(
"INSERT INTO downgrading.sensor_data "
+ "(sensor_id, date, timestamp, value) "
+ "VALUES ("
+ "756716f7-2e54-4715-9f00-91dcbea6cf50,"
+ "'2018-02-26',"
+ "'2018-02-26T13:56:33.739+01:00',"
+ "2.52)"))
.setConsistencyLevel(cl);
try {
session.execute(batch);
System.out.println("Write succeeded at " + cl);
} catch (DriverException e) {
if (retryCount == maxRetries) {
throw e;
}
e = unwrapAllNodesFailedException(e);
System.out.println("Write failed: " + e);
// General intent:
// 1) If we know the write has been fully persisted on at least one replica,
// ignore the exception since the write will be eventually propagated to other replicas.
// 2) If the write couldn't be persisted at all, abort as it is unlikely that a retry would
// succeed.
// 3) If the write was only partially persisted, retry at the highest consistency
// level that is likely to succeed.
if (e instanceof UnavailableException) {
// With an UnavailableException, we know that the write wasn't even attempted.
// Downgrade to the number of replicas reported alive and retry.
int aliveReplicas = ((UnavailableException) e).getAlive();
ConsistencyLevel downgraded = downgrade(cl, aliveReplicas, e);
write(downgraded, retryCount + 1);
} else if (e instanceof WriteTimeoutException) {
DefaultWriteType writeType = (DefaultWriteType) ((WriteTimeoutException) e).getWriteType();
int acknowledgements = ((WriteTimeoutException) e).getReceived();
switch (writeType) {
case SIMPLE:
case BATCH:
// For simple and batch writes, as long as one replica acknowledged the write,
// ignore the exception; if none responded however, abort as it is unlikely that
// a retry would ever succeed.
if (acknowledgements == 0) {
throw e;
}
break;
case UNLOGGED_BATCH:
// For unlogged batches, the write might have been persisted only partially,
// so we can't simply ignore the exception: instead, we need to retry with
// consistency level equal to the number of acknowledged writes.
ConsistencyLevel downgraded = downgrade(cl, acknowledgements, e);
write(downgraded, retryCount + 1);
break;
case BATCH_LOG:
// Rare edge case: the peers that were chosen by the coordinator
// to receive the distributed batch log failed to respond.
// Simply retry with same consistency level.
write(cl, retryCount + 1);
break;
default:
// Other write types are uncommon and should not be retried.
throw e;
}
} else {
// Unexpected error: just retry with same consistency level
// and hope to talk to a healthier coordinator.
write(cl, retryCount + 1);
}
}
}
|
java
|
private ResultSet read(ConsistencyLevel cl, int retryCount) {
System.out.printf("Reading at %s (retry count: %d)%n", cl, retryCount);
Statement stmt =
SimpleStatement.newInstance(
"SELECT sensor_id, date, timestamp, value "
+ "FROM downgrading.sensor_data "
+ "WHERE "
+ "sensor_id = 756716f7-2e54-4715-9f00-91dcbea6cf50 AND "
+ "date = '2018-02-26' AND "
+ "timestamp > '2018-02-26+01:00'")
.setConsistencyLevel(cl);
try {
ResultSet rows = session.execute(stmt);
System.out.println("Read succeeded at " + cl);
return rows;
} catch (DriverException e) {
if (retryCount == maxRetries) {
throw e;
}
e = unwrapAllNodesFailedException(e);
System.out.println("Read failed: " + e);
// General intent: downgrade and retry at the highest consistency level
// that is likely to succeed.
if (e instanceof UnavailableException) {
// Downgrade to the number of replicas reported alive and retry.
int aliveReplicas = ((UnavailableException) e).getAlive();
ConsistencyLevel downgraded = downgrade(cl, aliveReplicas, e);
return read(downgraded, retryCount + 1);
} else if (e instanceof ReadTimeoutException) {
ReadTimeoutException readTimeout = (ReadTimeoutException) e;
int received = readTimeout.getReceived();
int required = readTimeout.getBlockFor();
// If fewer replicas responded than required by the consistency level
// (but at least one replica did respond), retry with a consistency level
// equal to the number of received acknowledgements.
if (received < required) {
ConsistencyLevel downgraded = downgrade(cl, received, e);
return read(downgraded, retryCount + 1);
}
// If we received enough replies to meet the consistency level,
// but the actual data was not present among the received responses,
// then retry with the initial consistency level, we might be luckier next time
// and get the data back.
if (!readTimeout.wasDataPresent()) {
return read(cl, retryCount + 1);
}
// Otherwise, abort since the read timeout is unlikely to be solved by a retry.
throw e;
} else {
// Unexpected error: just retry with same consistency level
// and hope to talk to a healthier coordinator.
return read(cl, retryCount + 1);
}
}
}
|
java
|
private void display(ResultSet rows) {
final int width1 = 38;
final int width2 = 12;
final int width3 = 30;
final int width4 = 21;
String format = "%-" + width1 + "s%-" + width2 + "s%-" + width3 + "s%-" + width4 + "s%n";
// headings
System.out.printf(format, "sensor_id", "date", "timestamp", "value");
// separators
drawLine(width1, width2, width3, width4);
// data
for (Row row : rows) {
System.out.printf(
format,
row.getUuid("sensor_id"),
row.getLocalDate("date"),
row.getInstant("timestamp"),
row.getDouble("value"));
}
}
|
java
|
private static ConsistencyLevel downgrade(
ConsistencyLevel current, int acknowledgements, DriverException original) {
if (acknowledgements >= 3) {
return DefaultConsistencyLevel.THREE;
}
if (acknowledgements == 2) {
return DefaultConsistencyLevel.TWO;
}
if (acknowledgements == 1) {
return DefaultConsistencyLevel.ONE;
}
// Edge case: EACH_QUORUM does not report a global number of alive replicas
// so even if we get 0 alive replicas, there might be
// a node up in some other datacenter, so retry at ONE.
if (current == DefaultConsistencyLevel.EACH_QUORUM) {
return DefaultConsistencyLevel.ONE;
}
throw original;
}
|
java
|
private static void drawLine(int... widths) {
for (int width : widths) {
for (int i = 1; i < width; i++) {
System.out.print('-');
}
System.out.print('+');
}
System.out.println();
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.