Hey. Nothing obvious leaps out to me but it would be easier to look at in a sample project (I'm interested in the build configuration for example). That kind of problem seems pretty fundamental which suggests a config thing - or maybe a modules thing, are you attempting to build using Java9+ module packaging/resolution of the dependencies? The absolute simplest thing would be raise a https://github.com/eclipse/org.aspectj/issues with a sample project attached that exhibits the problem, but I understand that can be a bit of work. At minimum it would be good to see the pom/equivalent.
cheers, Andy On Fri, 14 Jan 2022 at 03:20, Mikael Petterson <mikaelpetter...@hotmail.com> wrote: > Hi, > > I have tried 1.9.7 and 1.9.8 up to RC3 but with no success to compile with > the new elastic search client 7.16.2. > > I have added class content here. > > Do you see anything odd? > > br. > > //mike > > > [INFO] Join point 'method-call(java.lang.Object > java.lang.Class.newInstance())' in Type > 'com.ericsson.commonlibrary.statisticscollectorframework.listeners.DataInjector' > (DataInjector.java:183) advised by before advice from > 'com.ericsson.commonlibrary.statisticscollectorframework.aspectj.DeprecatedMethodsAspect' > (DeprecatedMethodsAspect.aj:30) [with runtime test] > [ERROR] The import org.elasticsearch.common.unit.TimeValue cannot be > resolved > > C:\Users\eraonel\git\statistics-collector-framework\src\main\java\com\company\commonlibrary\statisticscollectorframework\service\ElasticSearchService.java:42 > import org.elasticsearch.common.unit.TimeValue; > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ > > [ERROR] The import org.elasticsearch.common.xcontent.XContentType cannot > be resolved > > C:\Users\eraonel\git\statistics-collector-framework\src\main\java\com\company\commonlibrary\statisticscollectorframework\service\ElasticSearchService.java:43 > import org.elasticsearch.common.xcontent.XContentType; > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ > > [ERROR] XContentType cannot be resolved to a variable > > C:\Users\eraonel\git\statistics-collector-framework\src\main\java\com\company\commonlibrary\statisticscollectorframework\service\ElasticSearchService.java:267 > indexRequest = new IndexRequest(indexName, type).source(document, > XContentType.JSON); > > > [ERROR] TimeValue cannot be resolved > > C:\Users\eraonel\git\statistics-collector-framework\src\main\java\com\company\commonlibrary\statisticscollectorframework\service\ElasticSearchService.java:268 > indexRequest.timeout(TimeValue.timeValueSeconds(10)); > > > [ERROR] XContentType cannot be resolved to a variable > > C:\Users\eraonel\git\statistics-collector-framework\src\main\java\com\company\commonlibrary\statisticscollectorframework\service\ElasticSearchService.java:280 > indexRequest = new IndexRequest(indexName).source(document, > XContentType.JSON); > > > > This is Timevalue class: > > > /* > * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. > under one > * or more contributor license agreements. Licensed under the Elastic > License > * 2.0 and the Server Side Public License, v 1; you may not use this file > except > * in compliance with, at your election, the Elastic License 2.0 or the > Server > * Side Public License, v 1. > */ > > package org.elasticsearch.core; > > import java.util.Locale; > import java.util.Objects; > import java.util.concurrent.TimeUnit; > > public class TimeValue implements Comparable<TimeValue> { > > /** How many nano-seconds in one milli-second */ > public static final long NSEC_PER_MSEC = > TimeUnit.NANOSECONDS.convert(1, TimeUnit.MILLISECONDS); > > public static final TimeValue MINUS_ONE = timeValueMillis(-1); > public static final TimeValue ZERO = timeValueMillis(0); > public static final TimeValue MAX_VALUE = > TimeValue.timeValueNanos(Long.MAX_VALUE); > > private static final long C0 = 1L; > private static final long C1 = C0 * 1000L; > private static final long C2 = C1 * 1000L; > private static final long C3 = C2 * 1000L; > private static final long C4 = C3 * 60L; > private static final long C5 = C4 * 60L; > private static final long C6 = C5 * 24L; > > private final long duration; > private final TimeUnit timeUnit; > > public TimeValue(long millis) { > this(millis, TimeUnit.MILLISECONDS); > } > > public TimeValue(long duration, TimeUnit timeUnit) { > if (duration < -1) { > throw new IllegalArgumentException("duration cannot be > negative, was given [" + duration + "]"); > } > this.duration = duration; > this.timeUnit = timeUnit; > } > > public static TimeValue timeValueNanos(long nanos) { > return new TimeValue(nanos, TimeUnit.NANOSECONDS); > } > > public static TimeValue timeValueMillis(long millis) { > return new TimeValue(millis, TimeUnit.MILLISECONDS); > } > > public static TimeValue timeValueSeconds(long seconds) { > return new TimeValue(seconds, TimeUnit.SECONDS); > } > > public static TimeValue timeValueMinutes(long minutes) { > return new TimeValue(minutes, TimeUnit.MINUTES); > } > > public static TimeValue timeValueHours(long hours) { > return new TimeValue(hours, TimeUnit.HOURS); > } > > public static TimeValue timeValueDays(long days) { > // 106751.9 days is Long.MAX_VALUE nanoseconds, so we cannot store > 106752 days > if (days > 106751) { > throw new IllegalArgumentException("time value cannot store > values greater than 106751 days"); > } > return new TimeValue(days, TimeUnit.DAYS); > } > > /** > * @return the unit used for the this time value, see {@link > #duration()} > */ > public TimeUnit timeUnit() { > return timeUnit; > } > > /** > * @return the number of {@link #timeUnit()} units this value contains > */ > public long duration() { > return duration; > } > > public long nanos() { > return timeUnit.toNanos(duration); > } > > public long getNanos() { > return nanos(); > } > > public long micros() { > return timeUnit.toMicros(duration); > } > > public long getMicros() { > return micros(); > } > > public long millis() { > return timeUnit.toMillis(duration); > } > > public long getMillis() { > return millis(); > } > > public long seconds() { > return timeUnit.toSeconds(duration); > } > > public long getSeconds() { > return seconds(); > } > > public long minutes() { > return timeUnit.toMinutes(duration); > } > > public long getMinutes() { > return minutes(); > } > > public long hours() { > return timeUnit.toHours(duration); > } > > public long getHours() { > return hours(); > } > > public long days() { > return timeUnit.toDays(duration); > } > > public long getDays() { > return days(); > } > > public double microsFrac() { > return ((double) nanos()) / C1; > } > > public double getMicrosFrac() { > return microsFrac(); > } > > public double millisFrac() { > return ((double) nanos()) / C2; > } > > public double getMillisFrac() { > return millisFrac(); > } > > public double secondsFrac() { > return ((double) nanos()) / C3; > } > > public double getSecondsFrac() { > return secondsFrac(); > } > > public double minutesFrac() { > return ((double) nanos()) / C4; > } > > public double getMinutesFrac() { > return minutesFrac(); > } > > public double hoursFrac() { > return ((double) nanos()) / C5; > } > > public double getHoursFrac() { > return hoursFrac(); > } > > public double daysFrac() { > return ((double) nanos()) / C6; > } > > public double getDaysFrac() { > return daysFrac(); > } > > /** > * Returns a {@link String} representation of the current {@link > TimeValue}. > * > * Note that this method might produce fractional time values (ex > 1.6m) which cannot be > * parsed by method like {@link TimeValue#parse(String, String, > String, String)}. > * > * Also note that the maximum string value that will be generated is > * {@code 106751.9d} due to the way that values are internally > converted > * to nanoseconds (106751.9 days is Long.MAX_VALUE nanoseconds) > */ > @Override > public String toString() { > return this.toHumanReadableString(1); > } > > /** > * Returns a {@link String} representation of the current {@link > TimeValue}. > * > * Note that this method might produce fractional time values (ex > 1.6m) which cannot be > * parsed by method like {@link TimeValue#parse(String, String, > String, String)}. The number of > * fractional decimals (up to 10 maximum) are truncated to the number > of fraction pieces > * specified. > * > * Also note that the maximum string value that will be generated is > * {@code 106751.9d} due to the way that values are internally > converted > * to nanoseconds (106751.9 days is Long.MAX_VALUE nanoseconds) > * > * @param fractionPieces the number of decimal places to include > */ > public String toHumanReadableString(int fractionPieces) { > if (duration < 0) { > return Long.toString(duration); > } > long nanos = nanos(); > if (nanos == 0) { > return "0s"; > } > double value = nanos; > String suffix = "nanos"; > if (nanos >= C6) { > value = daysFrac(); > suffix = "d"; > } else if (nanos >= C5) { > value = hoursFrac(); > suffix = "h"; > } else if (nanos >= C4) { > value = minutesFrac(); > suffix = "m"; > } else if (nanos >= C3) { > value = secondsFrac(); > suffix = "s"; > } else if (nanos >= C2) { > value = millisFrac(); > suffix = "ms"; > } else if (nanos >= C1) { > value = microsFrac(); > suffix = "micros"; > } > // Limit fraction pieces to a min of 0 and maximum of 10 > return formatDecimal(value, Math.min(10, Math.max(0, > fractionPieces))) + suffix; > } > > private static String formatDecimal(double value, int fractionPieces) { > String p = String.valueOf(value); > int totalLength = p.length(); > int ix = p.indexOf('.') + 1; > int ex = p.indexOf('E'); > // Location where the fractional values end > int fractionEnd = ex == -1 ? Math.min(ix + fractionPieces, > totalLength) : ex; > > // Determine the value of the fraction, so if it were .000 the > // actual long value is 0, in which case, it can be elided. > long fractionValue; > try { > fractionValue = Long.parseLong(p.substring(ix, fractionEnd)); > } catch (NumberFormatException e) { > fractionValue = 0; > } > > if (fractionValue == 0 || fractionPieces <= 0) { > // Either the part of the fraction we were asked to report is > // zero, or the user requested 0 fraction pieces, so return > // only the integral value > if (ex != -1) { > return p.substring(0, ix - 1) + p.substring(ex); > } else { > return p.substring(0, ix - 1); > } > } else { > // Build up an array of fraction characters, without going past > // the end of the string. This keeps track of trailing '0' > chars > // that should be truncated from the end to avoid getting a > // string like "1.3000d" (returning "1.3d" instead) when the > // value is 1.30000009 > char[] fractions = new char[fractionPieces]; > int fracCount = 0; > int truncateCount = 0; > for (int i = 0; i < fractionPieces; i++) { > int position = ix + i; > if (position >= fractionEnd) { > // No more pieces, the fraction has ended > break; > } > char fraction = p.charAt(position); > if (fraction == '0') { > truncateCount++; > } else { > truncateCount = 0; > } > fractions[i] = fraction; > fracCount++; > } > > // Generate the fraction string from the char array, > truncating any trailing zeros > String fractionStr = new String(fractions, 0, fracCount - > truncateCount); > > if (ex != -1) { > return p.substring(0, ix) + fractionStr + p.substring(ex); > } else { > return p.substring(0, ix) + fractionStr; > } > } > } > > public String getStringRep() { > if (duration < 0) { > return Long.toString(duration); > } > switch (timeUnit) { > case NANOSECONDS: > return duration + "nanos"; > case MICROSECONDS: > return duration + "micros"; > case MILLISECONDS: > return duration + "ms"; > case SECONDS: > return duration + "s"; > case MINUTES: > return duration + "m"; > case HOURS: > return duration + "h"; > case DAYS: > return duration + "d"; > default: > throw new IllegalArgumentException("unknown time unit: " + > timeUnit.name()); > } > } > > public static TimeValue parseTimeValue(String sValue, String > settingName) { > Objects.requireNonNull(settingName); > Objects.requireNonNull(sValue); > return parseTimeValue(sValue, null, settingName); > } > > public static TimeValue parseTimeValue(String sValue, TimeValue > defaultValue, String settingName) { > settingName = Objects.requireNonNull(settingName); > if (sValue == null) { > return defaultValue; > } > final String normalized = sValue.toLowerCase(Locale.ROOT).trim(); > if (normalized.endsWith("nanos")) { > return new TimeValue(parse(sValue, normalized, "nanos", > settingName), TimeUnit.NANOSECONDS); > } else if (normalized.endsWith("micros")) { > return new TimeValue(parse(sValue, normalized, "micros", > settingName), TimeUnit.MICROSECONDS); > } else if (normalized.endsWith("ms")) { > return new TimeValue(parse(sValue, normalized, "ms", > settingName), TimeUnit.MILLISECONDS); > } else if (normalized.endsWith("s")) { > return new TimeValue(parse(sValue, normalized, "s", > settingName), TimeUnit.SECONDS); > } else if (sValue.endsWith("m")) { > // parsing minutes should be case-sensitive as 'M' means > "months", not "minutes"; this is the only special case. > return new TimeValue(parse(sValue, normalized, "m", > settingName), TimeUnit.MINUTES); > } else if (normalized.endsWith("h")) { > return new TimeValue(parse(sValue, normalized, "h", > settingName), TimeUnit.HOURS); > } else if (normalized.endsWith("d")) { > return new TimeValue(parse(sValue, normalized, "d", > settingName), TimeUnit.DAYS); > } else if (normalized.matches("-0*1")) { > return TimeValue.MINUS_ONE; > } else if (normalized.matches("0+")) { > return TimeValue.ZERO; > } else { > // Missing units: > throw new IllegalArgumentException( > "failed to parse setting [" + settingName + "] with value > [" + sValue + "] as a time value: unit is missing or unrecognized" > ); > } > } > > private static long parse(final String initialInput, final String > normalized, final String suffix, String settingName) { > final String s = normalized.substring(0, normalized.length() - > suffix.length()).trim(); > try { > final long value = Long.parseLong(s); > if (value < -1) { > // -1 is magic, but reject any other negative values > throw new IllegalArgumentException( > "failed to parse setting [" > + settingName > + "] with value [" > + initialInput > + "] as a time value: negative durations are not > supported" > ); > } > return value; > } catch (final NumberFormatException e) { > try { > @SuppressWarnings("unused") > final double ignored = Double.parseDouble(s); > throw new IllegalArgumentException("failed to parse [" + > initialInput + "], fractional time values are not supported", e); > } catch (final NumberFormatException ignored) { > throw new IllegalArgumentException("failed to parse [" + > initialInput + "]", e); > } > } > } > > @Override > public boolean equals(Object o) { > if (this == o) return true; > if (o == null || getClass() != o.getClass()) return false; > > return this.compareTo(((TimeValue) o)) == 0; > } > > @Override > public int hashCode() { > return Double.hashCode(((double) duration) * timeUnit.toNanos(1)); > } > > public static long nsecToMSec(long ns) { > return ns / NSEC_PER_MSEC; > } > > @Override > public int compareTo(TimeValue timeValue) { > double thisValue = ((double) duration) * timeUnit.toNanos(1); > double otherValue = ((double) timeValue.duration) * > timeValue.timeUnit.toNanos(1); > return Double.compare(thisValue, otherValue); > } > } > > > And this is the XContentType class. > > /* > * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. > under one > * or more contributor license agreements. Licensed under the Elastic > License > * 2.0 and the Server Side Public License, v 1; you may not use this file > except > * in compliance with, at your election, the Elastic License 2.0 or the > Server > * Side Public License, v 1. > */ > > package org.elasticsearch.xcontent; > > import org.elasticsearch.xcontent.cbor.CborXContent; > import org.elasticsearch.xcontent.json.JsonXContent; > import org.elasticsearch.xcontent.smile.SmileXContent; > import org.elasticsearch.xcontent.yaml.YamlXContent; > > import java.util.Locale; > import java.util.Objects; > > /** > * The content type of {@link org.elasticsearch.xcontent.XContent}. > */ > public enum XContentType { > > /** > * A JSON based content type. > */ > JSON(0) { > @Override > public String mediaTypeWithoutParameters() { > return "application/json"; > } > > @Override > public String mediaType() { > return "application/json; charset=UTF-8"; > } > > @Override > public String shortName() { > return "json"; > } > > @Override > public XContent xContent() { > return JsonXContent.jsonXContent; > } > }, > /** > * The jackson based smile binary format. Fast and compact binary > format. > */ > SMILE(1) { > @Override > public String mediaTypeWithoutParameters() { > return "application/smile"; > } > > @Override > public String shortName() { > return "smile"; > } > > @Override > public XContent xContent() { > return SmileXContent.smileXContent; > } > }, > /** > * A YAML based content type. > */ > YAML(2) { > @Override > public String mediaTypeWithoutParameters() { > return "application/yaml"; > } > > @Override > public String shortName() { > return "yaml"; > } > > @Override > public XContent xContent() { > return YamlXContent.yamlXContent; > } > }, > /** > * A CBOR based content type. > */ > CBOR(3) { > @Override > public String mediaTypeWithoutParameters() { > return "application/cbor"; > } > > @Override > public String shortName() { > return "cbor"; > } > > @Override > public XContent xContent() { > return CborXContent.cborXContent; > } > }; > > /** > * Accepts either a format string, which is equivalent to {@link > XContentType#shortName()} or a media type that optionally has > * parameters and attempts to match the value to an {@link > XContentType}. The comparisons are done in lower case format and this method > * also supports a wildcard accept for {@code application/*}. This > method can be used to parse the {@code Accept} HTTP header or a > * format query string parameter. This method will return {@code null} > if no match is found > */ > public static XContentType fromMediaTypeOrFormat(String mediaType) { > if (mediaType == null) { > return null; > } > > mediaType = removeVersionInMediaType(mediaType); > for (XContentType type : values()) { > if (isSameMediaTypeOrFormatAs(mediaType, type)) { > return type; > } > } > final String lowercaseMediaType = > mediaType.toLowerCase(Locale.ROOT); > if (lowercaseMediaType.startsWith("application/*")) { > return JSON; > } > > return null; > } > > /** > * Clients compatible with ES 7.x might start sending media types with > versioned media type > * in a form of application/vnd.elasticsearch+json;compatible-with=7. > * This has to be removed in order to be used in 7.x server. > * The same client connecting using that media type will be able to > communicate with ES 8 thanks to compatible API. > * @param mediaType - a media type used on Content-Type header, might > contain versioned media type. > * > * @return a media type string without > */ > private static String removeVersionInMediaType(String mediaType) { > if (mediaType.contains("vnd.elasticsearch")) { > return mediaType.replaceAll("vnd.elasticsearch\\+", "") > .replaceAll("\\s*;\\s*compatible-with=\\d+", "") > .replaceAll("\\s*;\\s*", ";"); // to allow matching using > startsWith > } > return mediaType; > } > > /** > * Attempts to match the given media type with the known {@link > XContentType} values. This match is done in a case-insensitive manner. > * The provided media type should not include any parameters. This > method is suitable for parsing part of the {@code Content-Type} > * HTTP header. This method will return {@code null} if no match is > found > */ > public static XContentType fromMediaType(String mediaType) { > String lowercaseMediaType = Objects.requireNonNull(mediaType, > "mediaType cannot be null").toLowerCase(Locale.ROOT); > lowercaseMediaType = removeVersionInMediaType(lowercaseMediaType); > > for (XContentType type : values()) { > if > (type.mediaTypeWithoutParameters().equals(lowercaseMediaType)) { > return type; > } > } > // we also support newline delimited JSON: > http://specs.okfnlabs.org/ndjson/ > if > (lowercaseMediaType.toLowerCase(Locale.ROOT).equals("application/x-ndjson")) > { > return XContentType.JSON; > } > > return null; > } > > private static boolean isSameMediaTypeOrFormatAs(String stringType, > XContentType type) { > return > type.mediaTypeWithoutParameters().equalsIgnoreCase(stringType) > || > stringType.toLowerCase(Locale.ROOT).startsWith(type.mediaTypeWithoutParameters().toLowerCase(Locale.ROOT) > + ";") > || type.shortName().equalsIgnoreCase(stringType); > } > > private int index; > > XContentType(int index) { > this.index = index; > } > > public int index() { > return index; > } > > public String mediaType() { > return mediaTypeWithoutParameters(); > } > > public abstract String shortName(); > > public abstract XContent xContent(); > > public abstract String mediaTypeWithoutParameters(); > > } > _______________________________________________ > aspectj-users mailing list > aspectj-users@eclipse.org > To unsubscribe from this list, visit > https://www.eclipse.org/mailman/listinfo/aspectj-users >
_______________________________________________ aspectj-users mailing list aspectj-users@eclipse.org To unsubscribe from this list, visit https://www.eclipse.org/mailman/listinfo/aspectj-users