Migrating from joda to java.time. Watcher plugin (#35809)
part of the migrating joda time work. Migrating watcher plugin to use JDK's java-time refers #27330
This commit is contained in:
Przemyslaw Gomulka
GitHub
parent
d975f93967
commit
9b64558efb
|
|
@ -23,10 +23,10 @@ import org.elasticsearch.ElasticsearchParseException;
|
|||
import org.elasticsearch.common.Nullable;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Locale;
|
||||
import java.util.Objects;
|
||||
|
||||
|
|
@ -119,15 +119,16 @@ public class ActionStatus {
|
|||
ACKED;
|
||||
}
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final State state;
|
||||
|
||||
public AckStatus(DateTime timestamp, State state) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
public AckStatus(ZonedDateTime timestamp, State state) {
|
||||
assert timestamp.getOffset() == ZoneOffset.UTC;
|
||||
this.timestamp = timestamp;
|
||||
this.state = state;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -151,7 +152,7 @@ public class ActionStatus {
|
|||
}
|
||||
|
||||
public static AckStatus parse(String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
State state = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
|
|
@ -181,25 +182,25 @@ public class ActionStatus {
|
|||
|
||||
public static class Execution {
|
||||
|
||||
public static Execution successful(DateTime timestamp) {
|
||||
public static Execution successful(ZonedDateTime timestamp) {
|
||||
return new Execution(timestamp, true, null);
|
||||
}
|
||||
|
||||
public static Execution failure(DateTime timestamp, String reason) {
|
||||
public static Execution failure(ZonedDateTime timestamp, String reason) {
|
||||
return new Execution(timestamp, false, reason);
|
||||
}
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final boolean successful;
|
||||
private final String reason;
|
||||
|
||||
private Execution(DateTime timestamp, boolean successful, String reason) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
private Execution(ZonedDateTime timestamp, boolean successful, String reason) {
|
||||
this.timestamp = timestamp.withZoneSameInstant(ZoneOffset.UTC);
|
||||
this.successful = successful;
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -229,7 +230,7 @@ public class ActionStatus {
|
|||
}
|
||||
|
||||
public static Execution parse(String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
Boolean successful = null;
|
||||
String reason = null;
|
||||
|
||||
|
|
@ -269,15 +270,15 @@ public class ActionStatus {
|
|||
|
||||
public static class Throttle {
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final String reason;
|
||||
|
||||
public Throttle(DateTime timestamp, String reason) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
public Throttle(ZonedDateTime timestamp, String reason) {
|
||||
this.timestamp = timestamp.withZoneSameInstant(ZoneOffset.UTC);
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -300,7 +301,7 @@ public class ActionStatus {
|
|||
}
|
||||
|
||||
public static Throttle parse(String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
String reason = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
|
|
|
|||
|
|
@ -23,9 +23,10 @@ import org.elasticsearch.ElasticsearchParseException;
|
|||
import org.elasticsearch.common.Nullable;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -35,15 +36,14 @@ import static java.util.Collections.emptyMap;
|
|||
import static java.util.Collections.unmodifiableMap;
|
||||
import static org.elasticsearch.client.watcher.WatchStatusDateParser.parseDate;
|
||||
import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class WatchStatus {
|
||||
|
||||
private final State state;
|
||||
|
||||
private final ExecutionState executionState;
|
||||
private final DateTime lastChecked;
|
||||
private final DateTime lastMetCondition;
|
||||
private final ZonedDateTime lastChecked;
|
||||
private final ZonedDateTime lastMetCondition;
|
||||
private final long version;
|
||||
private final Map<String, ActionStatus> actions;
|
||||
@Nullable private Map<String, String> headers;
|
||||
|
|
@ -51,8 +51,8 @@ public class WatchStatus {
|
|||
public WatchStatus(long version,
|
||||
State state,
|
||||
ExecutionState executionState,
|
||||
DateTime lastChecked,
|
||||
DateTime lastMetCondition,
|
||||
ZonedDateTime lastChecked,
|
||||
ZonedDateTime lastMetCondition,
|
||||
Map<String, ActionStatus> actions,
|
||||
Map<String, String> headers) {
|
||||
this.version = version;
|
||||
|
|
@ -72,11 +72,11 @@ public class WatchStatus {
|
|||
return lastChecked != null;
|
||||
}
|
||||
|
||||
public DateTime lastChecked() {
|
||||
public ZonedDateTime lastChecked() {
|
||||
return lastChecked;
|
||||
}
|
||||
|
||||
public DateTime lastMetCondition() {
|
||||
public ZonedDateTime lastMetCondition() {
|
||||
return lastMetCondition;
|
||||
}
|
||||
|
||||
|
|
@ -123,8 +123,8 @@ public class WatchStatus {
|
|||
public static WatchStatus parse(XContentParser parser) throws IOException {
|
||||
State state = null;
|
||||
ExecutionState executionState = null;
|
||||
DateTime lastChecked = null;
|
||||
DateTime lastMetCondition = null;
|
||||
ZonedDateTime lastChecked = null;
|
||||
ZonedDateTime lastMetCondition = null;
|
||||
Map<String, ActionStatus> actions = null;
|
||||
Map<String, String> headers = Collections.emptyMap();
|
||||
long version = -1;
|
||||
|
|
@ -203,9 +203,9 @@ public class WatchStatus {
|
|||
public static class State {
|
||||
|
||||
private final boolean active;
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
|
||||
public State(boolean active, DateTime timestamp) {
|
||||
public State(boolean active, ZonedDateTime timestamp) {
|
||||
this.active = active;
|
||||
this.timestamp = timestamp;
|
||||
}
|
||||
|
|
@ -214,7 +214,7 @@ public class WatchStatus {
|
|||
return active;
|
||||
}
|
||||
|
||||
public DateTime getTimestamp() {
|
||||
public ZonedDateTime getTimestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -223,7 +223,7 @@ public class WatchStatus {
|
|||
throw new ElasticsearchParseException("expected an object but found [{}] instead", parser.currentToken());
|
||||
}
|
||||
boolean active = true;
|
||||
DateTime timestamp = DateTime.now(UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
String currentFieldName = null;
|
||||
XContentParser.Token token;
|
||||
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
|
||||
|
|
|
|||
|
|
@ -21,12 +21,14 @@ package org.elasticsearch.client.watcher;
|
|||
|
||||
import org.elasticsearch.ElasticsearchParseException;
|
||||
import org.elasticsearch.common.time.DateFormatter;
|
||||
import org.elasticsearch.common.time.DateFormatters;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.elasticsearch.index.mapper.DateFieldMapper;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
public final class WatchStatusDateParser {
|
||||
|
||||
|
|
@ -36,14 +38,14 @@ public final class WatchStatusDateParser {
|
|||
// Prevent instantiation.
|
||||
}
|
||||
|
||||
public static DateTime parseDate(String fieldName, XContentParser parser) throws IOException {
|
||||
public static ZonedDateTime parseDate(String fieldName, XContentParser parser) throws IOException {
|
||||
XContentParser.Token token = parser.currentToken();
|
||||
if (token == XContentParser.Token.VALUE_NUMBER) {
|
||||
return new DateTime(parser.longValue(), DateTimeZone.UTC);
|
||||
return Instant.ofEpochMilli(parser.longValue()).atZone(ZoneOffset.UTC);
|
||||
}
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
DateTime dateTime = parseDate(parser.text());
|
||||
return dateTime.toDateTime(DateTimeZone.UTC);
|
||||
ZonedDateTime dateTime = parseDate(parser.text());
|
||||
return dateTime.withZoneSameInstant(ZoneOffset.UTC);
|
||||
}
|
||||
if (token == XContentParser.Token.VALUE_NULL) {
|
||||
return null;
|
||||
|
|
@ -52,7 +54,7 @@ public final class WatchStatusDateParser {
|
|||
"to be either a number or a string but found [{}] instead", fieldName, token);
|
||||
}
|
||||
|
||||
public static DateTime parseDate(String text) {
|
||||
return FORMATTER.parseJoda(text);
|
||||
public static ZonedDateTime parseDate(String text) {
|
||||
return DateFormatters.from(FORMATTER.parse(text));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,10 +27,11 @@ import org.elasticsearch.common.xcontent.XContentParser;
|
|||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.elasticsearch.test.ESTestCase;
|
||||
import org.elasticsearch.test.XContentTestUtils;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
public class WatchStatusTests extends ESTestCase {
|
||||
|
|
@ -50,32 +51,32 @@ public class WatchStatusTests extends ESTestCase {
|
|||
assertEquals(expectedVersion, watchStatus.version());
|
||||
assertEquals(expectedExecutionState, watchStatus.getExecutionState());
|
||||
|
||||
assertEquals(new DateTime(1432663467763L, DateTimeZone.UTC), watchStatus.lastChecked());
|
||||
assertEquals(DateTime.parse("2015-05-26T18:04:27.763Z"), watchStatus.lastMetCondition());
|
||||
assertEquals(Instant.ofEpochMilli(1432663467763L).atZone(ZoneOffset.UTC), watchStatus.lastChecked());
|
||||
assertEquals(ZonedDateTime.parse("2015-05-26T18:04:27.763Z"), watchStatus.lastMetCondition());
|
||||
|
||||
WatchStatus.State watchState = watchStatus.state();
|
||||
assertEquals(expectedActive, watchState.isActive());
|
||||
assertEquals(DateTime.parse("2015-05-26T18:04:27.723Z"), watchState.getTimestamp());
|
||||
assertEquals(ZonedDateTime.parse("2015-05-26T18:04:27.723Z"), watchState.getTimestamp());
|
||||
|
||||
ActionStatus actionStatus = watchStatus.actionStatus("test_index");
|
||||
assertNotNull(actionStatus);
|
||||
|
||||
ActionStatus.AckStatus ackStatus = actionStatus.ackStatus();
|
||||
assertEquals(DateTime.parse("2015-05-26T18:04:27.763Z"), ackStatus.timestamp());
|
||||
assertEquals(ZonedDateTime.parse("2015-05-26T18:04:27.763Z"), ackStatus.timestamp());
|
||||
assertEquals(expectedAckState, ackStatus.state());
|
||||
|
||||
ActionStatus.Execution lastExecution = actionStatus.lastExecution();
|
||||
assertEquals(DateTime.parse("2015-05-25T18:04:27.733Z"), lastExecution.timestamp());
|
||||
assertEquals(ZonedDateTime.parse("2015-05-25T18:04:27.733Z"), lastExecution.timestamp());
|
||||
assertFalse(lastExecution.successful());
|
||||
assertEquals("failed to send email", lastExecution.reason());
|
||||
|
||||
ActionStatus.Execution lastSuccessfulExecution = actionStatus.lastSuccessfulExecution();
|
||||
assertEquals(DateTime.parse("2015-05-25T18:04:27.773Z"), lastSuccessfulExecution.timestamp());
|
||||
assertEquals(ZonedDateTime.parse("2015-05-25T18:04:27.773Z"), lastSuccessfulExecution.timestamp());
|
||||
assertTrue(lastSuccessfulExecution.successful());
|
||||
assertNull(lastSuccessfulExecution.reason());
|
||||
|
||||
ActionStatus.Throttle lastThrottle = actionStatus.lastThrottle();
|
||||
assertEquals(DateTime.parse("2015-04-25T18:05:23.445Z"), lastThrottle.timestamp());
|
||||
assertEquals(ZonedDateTime.parse("2015-04-25T18:05:23.445Z"), lastThrottle.timestamp());
|
||||
assertEquals("throttling interval is set to [5 seconds] ...", lastThrottle.reason());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -204,6 +204,7 @@ public class DateFormattersTests extends ESTestCase {
|
|||
assertRoundupFormatter("strict_date_optional_time||epoch_millis", "2018-10-10T12:13:14.123Z", 1539173594123L);
|
||||
assertRoundupFormatter("strict_date_optional_time||epoch_millis", "1234567890", 1234567890L);
|
||||
assertRoundupFormatter("strict_date_optional_time||epoch_millis", "2018-10-10", 1539215999999L);
|
||||
assertRoundupFormatter("strict_date_optional_time||epoch_millis", "2019-01-25T15:37:17.346928Z", 1548430637346L);
|
||||
assertRoundupFormatter("uuuu-MM-dd'T'HH:mm:ss.SSS||epoch_millis", "2018-10-10T12:13:14.123", 1539173594123L);
|
||||
assertRoundupFormatter("uuuu-MM-dd'T'HH:mm:ss.SSS||epoch_millis", "1234567890", 1234567890L);
|
||||
|
||||
|
|
|
|||
|
|
@ -10,13 +10,15 @@ import org.elasticsearch.common.Nullable;
|
|||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.io.stream.StreamInput;
|
||||
import org.elasticsearch.common.io.stream.StreamOutput;
|
||||
import org.elasticsearch.common.time.DateFormatters;
|
||||
import org.elasticsearch.common.xcontent.ToXContentObject;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Locale;
|
||||
import java.util.Objects;
|
||||
|
||||
|
|
@ -30,7 +32,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
@Nullable private Execution lastSuccessfulExecution;
|
||||
@Nullable private Throttle lastThrottle;
|
||||
|
||||
public ActionStatus(DateTime now) {
|
||||
public ActionStatus(ZonedDateTime now) {
|
||||
this(new AckStatus(now, AckStatus.State.AWAITS_SUCCESSFUL_EXECUTION), null, null, null);
|
||||
}
|
||||
|
||||
|
|
@ -76,7 +78,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
return Objects.hash(ackStatus, lastExecution, lastSuccessfulExecution, lastThrottle);
|
||||
}
|
||||
|
||||
public void update(DateTime timestamp, Action.Result result) {
|
||||
public void update(ZonedDateTime timestamp, Action.Result result) {
|
||||
switch (result.status()) {
|
||||
|
||||
case FAILURE:
|
||||
|
|
@ -99,7 +101,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
}
|
||||
|
||||
public boolean onAck(DateTime timestamp) {
|
||||
public boolean onAck(ZonedDateTime timestamp) {
|
||||
if (ackStatus.state == AckStatus.State.ACKABLE) {
|
||||
ackStatus = new AckStatus(timestamp, AckStatus.State.ACKED);
|
||||
return true;
|
||||
|
|
@ -107,7 +109,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
return false;
|
||||
}
|
||||
|
||||
public boolean resetAckStatus(DateTime timestamp) {
|
||||
public boolean resetAckStatus(ZonedDateTime timestamp) {
|
||||
if (ackStatus.state != AckStatus.State.AWAITS_SUCCESSFUL_EXECUTION) {
|
||||
ackStatus = new AckStatus(timestamp, AckStatus.State.AWAITS_SUCCESSFUL_EXECUTION);
|
||||
return true;
|
||||
|
|
@ -210,15 +212,15 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
}
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final State state;
|
||||
|
||||
public AckStatus(DateTime timestamp, State state) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
public AckStatus(ZonedDateTime timestamp, State state) {
|
||||
this.timestamp = timestamp;
|
||||
this.state = state;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -244,13 +246,13 @@ public class ActionStatus implements ToXContentObject {
|
|||
@Override
|
||||
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
|
||||
return builder.startObject()
|
||||
.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.formatJoda(timestamp))
|
||||
.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.format(timestamp))
|
||||
.field(Field.ACK_STATUS_STATE.getPreferredName(), state.name().toLowerCase(Locale.ROOT))
|
||||
.endObject();
|
||||
}
|
||||
|
||||
public static AckStatus parse(String watchId, String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
State state = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
|
|
@ -259,7 +261,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
if (token == XContentParser.Token.FIELD_NAME) {
|
||||
currentFieldName = parser.currentName();
|
||||
} else if (Field.TIMESTAMP.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
timestamp = dateTimeFormatter.parseJoda(parser.text());
|
||||
timestamp = DateFormatters.from(dateTimeFormatter.parse(parser.text()));
|
||||
} else if (Field.ACK_STATUS_STATE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
state = State.valueOf(parser.text().toUpperCase(Locale.ROOT));
|
||||
} else {
|
||||
|
|
@ -279,12 +281,12 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
|
||||
static void writeTo(AckStatus status, StreamOutput out) throws IOException {
|
||||
out.writeLong(status.timestamp.getMillis());
|
||||
out.writeLong(status.timestamp.toInstant().toEpochMilli());
|
||||
out.writeByte(status.state.value);
|
||||
}
|
||||
|
||||
static AckStatus readFrom(StreamInput in) throws IOException {
|
||||
DateTime timestamp = new DateTime(in.readLong(), DateTimeZone.UTC);
|
||||
ZonedDateTime timestamp = Instant.ofEpochMilli(in.readLong()).atZone(ZoneOffset.UTC);
|
||||
State state = State.resolve(in.readByte());
|
||||
return new AckStatus(timestamp, state);
|
||||
}
|
||||
|
|
@ -292,25 +294,25 @@ public class ActionStatus implements ToXContentObject {
|
|||
|
||||
public static class Execution implements ToXContentObject {
|
||||
|
||||
public static Execution successful(DateTime timestamp) {
|
||||
public static Execution successful(ZonedDateTime timestamp) {
|
||||
return new Execution(timestamp, true, null);
|
||||
}
|
||||
|
||||
public static Execution failure(DateTime timestamp, String reason) {
|
||||
public static Execution failure(ZonedDateTime timestamp, String reason) {
|
||||
return new Execution(timestamp, false, reason);
|
||||
}
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final boolean successful;
|
||||
private final String reason;
|
||||
|
||||
private Execution(DateTime timestamp, boolean successful, String reason) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
private Execution(ZonedDateTime timestamp, boolean successful, String reason) {
|
||||
this.timestamp = timestamp.withZoneSameInstant(ZoneOffset.UTC);
|
||||
this.successful = successful;
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -342,7 +344,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
@Override
|
||||
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
|
||||
builder.startObject();
|
||||
builder.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.formatJoda(timestamp));
|
||||
builder.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.format(timestamp));
|
||||
builder.field(Field.EXECUTION_SUCCESSFUL.getPreferredName(), successful);
|
||||
if (reason != null) {
|
||||
builder.field(Field.REASON.getPreferredName(), reason);
|
||||
|
|
@ -351,7 +353,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
|
||||
public static Execution parse(String watchId, String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
Boolean successful = null;
|
||||
String reason = null;
|
||||
|
||||
|
|
@ -361,7 +363,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
if (token == XContentParser.Token.FIELD_NAME) {
|
||||
currentFieldName = parser.currentName();
|
||||
} else if (Field.TIMESTAMP.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
timestamp = dateTimeFormatter.parseJoda(parser.text());
|
||||
timestamp = DateFormatters.from(dateTimeFormatter.parse(parser.text()));
|
||||
} else if (Field.EXECUTION_SUCCESSFUL.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
successful = parser.booleanValue();
|
||||
} else if (Field.REASON.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
|
|
@ -390,7 +392,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
|
||||
public static void writeTo(Execution execution, StreamOutput out) throws IOException {
|
||||
out.writeLong(execution.timestamp.getMillis());
|
||||
out.writeLong(execution.timestamp.toInstant().toEpochMilli());
|
||||
out.writeBoolean(execution.successful);
|
||||
if (!execution.successful) {
|
||||
out.writeString(execution.reason);
|
||||
|
|
@ -398,7 +400,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
|
||||
public static Execution readFrom(StreamInput in) throws IOException {
|
||||
DateTime timestamp = new DateTime(in.readLong(), DateTimeZone.UTC);
|
||||
ZonedDateTime timestamp = Instant.ofEpochMilli(in.readLong()).atZone(ZoneOffset.UTC);
|
||||
boolean successful = in.readBoolean();
|
||||
if (successful) {
|
||||
return successful(timestamp);
|
||||
|
|
@ -409,15 +411,15 @@ public class ActionStatus implements ToXContentObject {
|
|||
|
||||
public static class Throttle implements ToXContentObject {
|
||||
|
||||
private final DateTime timestamp;
|
||||
private final ZonedDateTime timestamp;
|
||||
private final String reason;
|
||||
|
||||
public Throttle(DateTime timestamp, String reason) {
|
||||
this.timestamp = timestamp.toDateTime(DateTimeZone.UTC);
|
||||
public Throttle(ZonedDateTime timestamp, String reason) {
|
||||
this.timestamp = timestamp.withZoneSameInstant(ZoneOffset.UTC);
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public DateTime timestamp() {
|
||||
public ZonedDateTime timestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -442,13 +444,13 @@ public class ActionStatus implements ToXContentObject {
|
|||
@Override
|
||||
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
|
||||
return builder.startObject()
|
||||
.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.formatJoda(timestamp))
|
||||
.field(Field.TIMESTAMP.getPreferredName()).value(dateTimeFormatter.format(timestamp))
|
||||
.field(Field.REASON.getPreferredName(), reason)
|
||||
.endObject();
|
||||
}
|
||||
|
||||
public static Throttle parse(String watchId, String actionId, XContentParser parser) throws IOException {
|
||||
DateTime timestamp = null;
|
||||
ZonedDateTime timestamp = null;
|
||||
String reason = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
|
|
@ -457,7 +459,7 @@ public class ActionStatus implements ToXContentObject {
|
|||
if (token == XContentParser.Token.FIELD_NAME) {
|
||||
currentFieldName = parser.currentName();
|
||||
} else if (Field.TIMESTAMP.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
timestamp = dateTimeFormatter.parseJoda(parser.text());
|
||||
timestamp = DateFormatters.from(dateTimeFormatter.parse(parser.text()));
|
||||
} else if (Field.REASON.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
reason = parser.text();
|
||||
} else {
|
||||
|
|
@ -477,12 +479,12 @@ public class ActionStatus implements ToXContentObject {
|
|||
}
|
||||
|
||||
static void writeTo(Throttle throttle, StreamOutput out) throws IOException {
|
||||
out.writeLong(throttle.timestamp.getMillis());
|
||||
out.writeLong(throttle.timestamp.toInstant().toEpochMilli());
|
||||
out.writeString(throttle.reason);
|
||||
}
|
||||
|
||||
static Throttle readFrom(StreamInput in) throws IOException {
|
||||
DateTime timestamp = new DateTime(in.readLong(), DateTimeZone.UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.ofInstant(Instant.ofEpochMilli(in.readLong()), ZoneOffset.UTC);
|
||||
return new Throttle(timestamp, in.readString());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,11 +25,11 @@ import org.elasticsearch.xpack.core.watcher.transform.ExecutableTransform;
|
|||
import org.elasticsearch.xpack.core.watcher.transform.Transform;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchField;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Objects;
|
||||
|
||||
import static org.elasticsearch.common.unit.TimeValue.timeValueMillis;
|
||||
|
|
@ -109,7 +109,7 @@ public class ActionWrapper implements ToXContentObject {
|
|||
try {
|
||||
conditionResult = condition.execute(ctx);
|
||||
if (conditionResult.met() == false) {
|
||||
ctx.watch().status().actionStatus(id).resetAckStatus(DateTime.now(DateTimeZone.UTC));
|
||||
ctx.watch().status().actionStatus(id).resetAckStatus(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
return new ActionWrapperResult(id, conditionResult, null,
|
||||
new Action.Result.ConditionFailed(action.type(), "condition not met. skipping"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,7 +47,9 @@ public class PeriodThrottler implements Throttler {
|
|||
if (status.lastSuccessfulExecution() == null) {
|
||||
return Result.NO;
|
||||
}
|
||||
TimeValue timeElapsed = TimeValue.timeValueMillis(clock.millis() - status.lastSuccessfulExecution().timestamp().getMillis());
|
||||
long now = clock.millis();
|
||||
long executionTime = status.lastSuccessfulExecution().timestamp().toInstant().toEpochMilli();
|
||||
TimeValue timeElapsed = TimeValue.timeValueMillis(now - executionTime);
|
||||
if (timeElapsed.getMillis() <= period.getMillis()) {
|
||||
return Result.throttle(PERIOD, "throttling interval is set to [{}] but time elapsed since last execution is [{}]",
|
||||
period, timeElapsed);
|
||||
|
|
|
|||
|
|
@ -10,17 +10,18 @@ import org.elasticsearch.common.io.stream.StreamOutput;
|
|||
import org.elasticsearch.common.io.stream.Streamable;
|
||||
import org.elasticsearch.common.xcontent.ToXContentObject;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
public class QueuedWatch implements Streamable, ToXContentObject {
|
||||
|
||||
private String watchId;
|
||||
private String watchRecordId;
|
||||
private DateTime triggeredTime;
|
||||
private DateTime executionTime;
|
||||
private ZonedDateTime triggeredTime;
|
||||
private ZonedDateTime executionTime;
|
||||
|
||||
public QueuedWatch() {
|
||||
}
|
||||
|
|
@ -36,19 +37,19 @@ public class QueuedWatch implements Streamable, ToXContentObject {
|
|||
return watchId;
|
||||
}
|
||||
|
||||
public DateTime triggeredTime() {
|
||||
public ZonedDateTime triggeredTime() {
|
||||
return triggeredTime;
|
||||
}
|
||||
|
||||
public void triggeredTime(DateTime triggeredTime) {
|
||||
public void triggeredTime(ZonedDateTime triggeredTime) {
|
||||
this.triggeredTime = triggeredTime;
|
||||
}
|
||||
|
||||
public DateTime executionTime() {
|
||||
public ZonedDateTime executionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
|
||||
public void executionTime(DateTime executionTime) {
|
||||
public void executionTime(ZonedDateTime executionTime) {
|
||||
this.executionTime = executionTime;
|
||||
}
|
||||
|
||||
|
|
@ -56,16 +57,16 @@ public class QueuedWatch implements Streamable, ToXContentObject {
|
|||
public void readFrom(StreamInput in) throws IOException {
|
||||
watchId = in.readString();
|
||||
watchRecordId = in.readString();
|
||||
triggeredTime = new DateTime(in.readVLong(), DateTimeZone.UTC);
|
||||
executionTime = new DateTime(in.readVLong(), DateTimeZone.UTC);
|
||||
triggeredTime = Instant.ofEpochMilli(in.readVLong()).atZone(ZoneOffset.UTC);
|
||||
executionTime = Instant.ofEpochMilli(in.readVLong()).atZone(ZoneOffset.UTC);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTo(StreamOutput out) throws IOException {
|
||||
out.writeString(watchId);
|
||||
out.writeString(watchRecordId);
|
||||
out.writeVLong(triggeredTime.getMillis());
|
||||
out.writeVLong(executionTime.getMillis());
|
||||
out.writeVLong(triggeredTime.toInstant().toEpochMilli());
|
||||
out.writeVLong(executionTime.toInstant().toEpochMilli());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@ import org.elasticsearch.xpack.core.watcher.transform.Transform;
|
|||
import org.elasticsearch.xpack.core.watcher.trigger.TriggerEvent;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -30,7 +30,7 @@ import java.util.concurrent.TimeUnit;
|
|||
public abstract class WatchExecutionContext {
|
||||
|
||||
private final Wid id;
|
||||
private final DateTime executionTime;
|
||||
private final ZonedDateTime executionTime;
|
||||
private final TriggerEvent triggerEvent;
|
||||
private final TimeValue defaultThrottlePeriod;
|
||||
|
||||
|
|
@ -48,7 +48,7 @@ public abstract class WatchExecutionContext {
|
|||
private String nodeId;
|
||||
private String user;
|
||||
|
||||
public WatchExecutionContext(String watchId, DateTime executionTime, TriggerEvent triggerEvent, TimeValue defaultThrottlePeriod) {
|
||||
public WatchExecutionContext(String watchId, ZonedDateTime executionTime, TriggerEvent triggerEvent, TimeValue defaultThrottlePeriod) {
|
||||
this.id = new Wid(watchId, executionTime);
|
||||
this.executionTime = executionTime;
|
||||
this.triggerEvent = triggerEvent;
|
||||
|
|
@ -97,7 +97,7 @@ public abstract class WatchExecutionContext {
|
|||
return id;
|
||||
}
|
||||
|
||||
public DateTime executionTime() {
|
||||
public ZonedDateTime executionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,14 +14,14 @@ import org.elasticsearch.xpack.core.watcher.condition.Condition;
|
|||
import org.elasticsearch.xpack.core.watcher.input.Input;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.elasticsearch.xpack.core.watcher.transform.Transform;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
|
||||
public class WatchExecutionResult implements ToXContentObject {
|
||||
|
||||
private final DateTime executionTime;
|
||||
private final ZonedDateTime executionTime;
|
||||
private final long executionDurationMs;
|
||||
@Nullable private final Input.Result inputResult;
|
||||
@Nullable private final Condition.Result conditionResult;
|
||||
|
|
@ -33,7 +33,7 @@ public class WatchExecutionResult implements ToXContentObject {
|
|||
context.actionsResults());
|
||||
}
|
||||
|
||||
private WatchExecutionResult(DateTime executionTime, long executionDurationMs, Input.Result inputResult,
|
||||
private WatchExecutionResult(ZonedDateTime executionTime, long executionDurationMs, Input.Result inputResult,
|
||||
Condition.Result conditionResult, @Nullable Transform.Result transformResult,
|
||||
Map<String, ActionWrapperResult> actionsResults) {
|
||||
this.executionTime = executionTime;
|
||||
|
|
@ -44,7 +44,7 @@ public class WatchExecutionResult implements ToXContentObject {
|
|||
this.executionDurationMs = executionDurationMs;
|
||||
}
|
||||
|
||||
public DateTime executionTime() {
|
||||
public ZonedDateTime executionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,18 +11,19 @@ import org.elasticsearch.common.io.stream.Streamable;
|
|||
import org.elasticsearch.common.xcontent.ToXContentObject;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.xpack.core.watcher.actions.ActionWrapperResult;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
|
||||
public class WatchExecutionSnapshot implements Streamable, ToXContentObject {
|
||||
|
||||
private String watchId;
|
||||
private String watchRecordId;
|
||||
private DateTime triggeredTime;
|
||||
private DateTime executionTime;
|
||||
private ZonedDateTime triggeredTime;
|
||||
private ZonedDateTime executionTime;
|
||||
private ExecutionPhase phase;
|
||||
private String[] executedActions;
|
||||
private StackTraceElement[] executionStackTrace;
|
||||
|
|
@ -55,11 +56,11 @@ public class WatchExecutionSnapshot implements Streamable, ToXContentObject {
|
|||
return watchRecordId;
|
||||
}
|
||||
|
||||
public DateTime triggeredTime() {
|
||||
public ZonedDateTime triggeredTime() {
|
||||
return triggeredTime;
|
||||
}
|
||||
|
||||
public DateTime executionTime() {
|
||||
public ZonedDateTime executionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
|
||||
|
|
@ -75,8 +76,8 @@ public class WatchExecutionSnapshot implements Streamable, ToXContentObject {
|
|||
public void readFrom(StreamInput in) throws IOException {
|
||||
watchId = in.readString();
|
||||
watchRecordId = in.readString();
|
||||
triggeredTime = new DateTime(in.readVLong(), DateTimeZone.UTC);
|
||||
executionTime = new DateTime(in.readVLong(), DateTimeZone.UTC);
|
||||
triggeredTime = Instant.ofEpochMilli(in.readVLong()).atZone(ZoneOffset.UTC);
|
||||
executionTime = Instant.ofEpochMilli(in.readVLong()).atZone(ZoneOffset.UTC);
|
||||
phase = ExecutionPhase.resolve(in.readString());
|
||||
int size = in.readVInt();
|
||||
executionStackTrace = new StackTraceElement[size];
|
||||
|
|
@ -93,8 +94,8 @@ public class WatchExecutionSnapshot implements Streamable, ToXContentObject {
|
|||
public void writeTo(StreamOutput out) throws IOException {
|
||||
out.writeString(watchId);
|
||||
out.writeString(watchRecordId);
|
||||
out.writeVLong(triggeredTime.getMillis());
|
||||
out.writeVLong(executionTime.getMillis());
|
||||
out.writeVLong(triggeredTime.toInstant().toEpochMilli());
|
||||
out.writeVLong(executionTime.toInstant().toEpochMilli());
|
||||
out.writeString(phase.id());
|
||||
out.writeVInt(executionStackTrace.length);
|
||||
for (StackTraceElement element : executionStackTrace) {
|
||||
|
|
|
|||
|
|
@ -5,10 +5,9 @@
|
|||
*/
|
||||
package org.elasticsearch.xpack.core.watcher.execution;
|
||||
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.format.DateTimeFormatter;
|
||||
import org.joda.time.format.ISODateTimeFormat;
|
||||
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.elasticsearch.xpack.core.watcher.support.Exceptions.illegalArgument;
|
||||
|
|
@ -26,14 +25,14 @@ import static org.elasticsearch.xpack.core.watcher.support.Exceptions.illegalArg
|
|||
*/
|
||||
public class Wid {
|
||||
|
||||
private static final DateTimeFormatter formatter = ISODateTimeFormat.dateTime();
|
||||
private static final DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
|
||||
|
||||
private final String watchId;
|
||||
private final String value;
|
||||
|
||||
public Wid(String watchId, DateTime executionTime) {
|
||||
public Wid(String watchId, ZonedDateTime executionTime) {
|
||||
this.watchId = watchId;
|
||||
this.value = watchId + "_" + UUID.randomUUID().toString() + "-" + formatter.print(executionTime);
|
||||
this.value = watchId + "_" + UUID.randomUUID().toString() + "-" + formatter.format(executionTime);
|
||||
}
|
||||
|
||||
public Wid(String value) {
|
||||
|
|
|
|||
|
|
@ -5,21 +5,21 @@
|
|||
*/
|
||||
package org.elasticsearch.xpack.core.watcher.history;
|
||||
|
||||
import org.elasticsearch.common.time.DateFormatter;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherIndexTemplateRegistryField;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.format.DateTimeFormat;
|
||||
import org.joda.time.format.DateTimeFormatter;
|
||||
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
public final class HistoryStoreField {
|
||||
|
||||
public static final String INDEX_PREFIX = ".watcher-history-";
|
||||
public static final String INDEX_PREFIX_WITH_TEMPLATE = INDEX_PREFIX + WatcherIndexTemplateRegistryField.INDEX_TEMPLATE_VERSION + "-";
|
||||
static final DateTimeFormatter indexTimeFormat = DateTimeFormat.forPattern("YYYY.MM.dd");
|
||||
private static final DateFormatter indexTimeFormat = DateFormatter.forPattern("yyyy.MM.dd");
|
||||
|
||||
/**
|
||||
* Calculates the correct history index name for a given time
|
||||
*/
|
||||
public static String getHistoryIndexNameForTime(DateTime time) {
|
||||
return INDEX_PREFIX_WITH_TEMPLATE + indexTimeFormat.print(time);
|
||||
public static String getHistoryIndexNameForTime(ZonedDateTime time) {
|
||||
return INDEX_PREFIX_WITH_TEMPLATE + indexTimeFormat.format(time);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,17 +10,20 @@ import org.elasticsearch.common.Nullable;
|
|||
import org.elasticsearch.common.io.stream.StreamInput;
|
||||
import org.elasticsearch.common.io.stream.StreamOutput;
|
||||
import org.elasticsearch.common.time.DateFormatter;
|
||||
import org.elasticsearch.common.time.DateFormatters;
|
||||
import org.elasticsearch.common.time.DateMathParser;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.elasticsearch.index.mapper.DateFieldMapper;
|
||||
import org.elasticsearch.script.JodaCompatibleZonedDateTime;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Locale;
|
||||
import java.util.Objects;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
|
@ -29,39 +32,40 @@ public class WatcherDateTimeUtils {
|
|||
public static final DateFormatter dateTimeFormatter = DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER;
|
||||
public static final DateMathParser dateMathParser = dateTimeFormatter.toDateMathParser();
|
||||
|
||||
|
||||
private WatcherDateTimeUtils() {
|
||||
}
|
||||
|
||||
public static DateTime convertToDate(Object value, Clock clock) {
|
||||
if (value instanceof DateTime) {
|
||||
return (DateTime) value;
|
||||
public static ZonedDateTime convertToDate(Object value, Clock clock) {
|
||||
if (value instanceof ZonedDateTime) {
|
||||
return (ZonedDateTime) value;
|
||||
}
|
||||
if (value instanceof JodaCompatibleZonedDateTime) {
|
||||
return new DateTime(((JodaCompatibleZonedDateTime) value).toInstant().toEpochMilli(), DateTimeZone.UTC);
|
||||
return ((JodaCompatibleZonedDateTime) value).getZonedDateTime();
|
||||
}
|
||||
if (value instanceof String) {
|
||||
return parseDateMath((String) value, DateTimeZone.UTC, clock);
|
||||
return parseDateMath((String) value, ZoneOffset.UTC, clock);
|
||||
}
|
||||
if (value instanceof Number) {
|
||||
return new DateTime(((Number) value).longValue(), DateTimeZone.UTC);
|
||||
return Instant.ofEpochMilli(((Number) value).longValue()).atZone(ZoneOffset.UTC);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static DateTime parseDate(String dateAsText) {
|
||||
public static ZonedDateTime parseDate(String dateAsText) {
|
||||
return parseDate(dateAsText, null);
|
||||
}
|
||||
|
||||
public static DateTime parseDate(String format, DateTimeZone timeZone) {
|
||||
DateTime dateTime = dateTimeFormatter.parseJoda(format);
|
||||
return timeZone != null ? dateTime.toDateTime(timeZone) : dateTime;
|
||||
public static ZonedDateTime parseDate(String format, ZoneId timeZone) {
|
||||
ZonedDateTime zonedDateTime = DateFormatters.from(dateTimeFormatter.parse(format));
|
||||
return timeZone != null ? zonedDateTime.withZoneSameInstant(timeZone) : zonedDateTime;
|
||||
}
|
||||
|
||||
public static String formatDate(DateTime date) {
|
||||
return dateTimeFormatter.formatJoda(date);
|
||||
public static String formatDate(ZonedDateTime date) {
|
||||
return dateTimeFormatter.format(date);
|
||||
}
|
||||
|
||||
public static DateTime parseDateMath(String fieldName, XContentParser parser, DateTimeZone timeZone, Clock clock) throws IOException {
|
||||
public static ZonedDateTime parseDateMath(String fieldName, XContentParser parser, ZoneId timeZone, Clock clock) throws IOException {
|
||||
if (parser.currentToken() == XContentParser.Token.VALUE_NULL) {
|
||||
throw new ElasticsearchParseException("could not parse date/time expected date field [{}] to not be null but was null",
|
||||
fieldName);
|
||||
|
|
@ -69,11 +73,11 @@ public class WatcherDateTimeUtils {
|
|||
return parseDateMathOrNull(fieldName, parser, timeZone, clock);
|
||||
}
|
||||
|
||||
public static DateTime parseDateMathOrNull(String fieldName, XContentParser parser, DateTimeZone timeZone,
|
||||
public static ZonedDateTime parseDateMathOrNull(String fieldName, XContentParser parser, ZoneId timeZone,
|
||||
Clock clock) throws IOException {
|
||||
XContentParser.Token token = parser.currentToken();
|
||||
if (token == XContentParser.Token.VALUE_NUMBER) {
|
||||
return new DateTime(parser.longValue(), timeZone);
|
||||
return Instant.ofEpochMilli(parser.longValue()).atZone(timeZone);
|
||||
}
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
try {
|
||||
|
|
@ -90,14 +94,14 @@ public class WatcherDateTimeUtils {
|
|||
"found [{}] instead", fieldName, token);
|
||||
}
|
||||
|
||||
public static DateTime parseDateMath(String valueString, DateTimeZone timeZone, final Clock clock) {
|
||||
return new DateTime(dateMathParser.parse(valueString, clock::millis).toEpochMilli(), timeZone);
|
||||
public static ZonedDateTime parseDateMath(String valueString, ZoneId timeZone, final Clock clock) {
|
||||
return dateMathParser.parse(valueString, clock::millis).atZone(timeZone);
|
||||
}
|
||||
|
||||
public static DateTime parseDate(String fieldName, XContentParser parser, DateTimeZone timeZone) throws IOException {
|
||||
public static ZonedDateTime parseDate(String fieldName, XContentParser parser, ZoneId timeZone) throws IOException {
|
||||
XContentParser.Token token = parser.currentToken();
|
||||
if (token == XContentParser.Token.VALUE_NUMBER) {
|
||||
return new DateTime(parser.longValue(), timeZone);
|
||||
return Instant.ofEpochMilli(parser.longValue()).atZone(timeZone);
|
||||
}
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
return parseDate(parser.text(), timeZone);
|
||||
|
|
@ -109,32 +113,28 @@ public class WatcherDateTimeUtils {
|
|||
"found [{}] instead", fieldName, token);
|
||||
}
|
||||
|
||||
public static XContentBuilder writeDate(String fieldName, XContentBuilder builder, DateTime date) throws IOException {
|
||||
public static XContentBuilder writeDate(String fieldName, XContentBuilder builder, ZonedDateTime date) throws IOException {
|
||||
if (date == null) {
|
||||
return builder.nullField(fieldName);
|
||||
}
|
||||
return builder.field(fieldName, formatDate(date));
|
||||
}
|
||||
|
||||
public static void writeDate(StreamOutput out, DateTime date) throws IOException {
|
||||
out.writeLong(date.getMillis());
|
||||
public static void writeDate(StreamOutput out, ZonedDateTime date) throws IOException {
|
||||
out.writeLong(date.toInstant().toEpochMilli());
|
||||
}
|
||||
|
||||
public static DateTime readDate(StreamInput in, DateTimeZone timeZone) throws IOException {
|
||||
return new DateTime(in.readLong(), timeZone);
|
||||
}
|
||||
|
||||
public static void writeOptionalDate(StreamOutput out, DateTime date) throws IOException {
|
||||
public static void writeOptionalDate(StreamOutput out, ZonedDateTime date) throws IOException {
|
||||
if (date == null) {
|
||||
out.writeBoolean(false);
|
||||
return;
|
||||
}
|
||||
out.writeBoolean(true);
|
||||
out.writeLong(date.getMillis());
|
||||
out.writeLong(date.toInstant().toEpochMilli());
|
||||
}
|
||||
|
||||
public static DateTime readOptionalDate(StreamInput in, DateTimeZone timeZone) throws IOException {
|
||||
return in.readBoolean() ? new DateTime(in.readLong(), timeZone) : null;
|
||||
public static ZonedDateTime readOptionalDate(StreamInput in) throws IOException {
|
||||
return in.readBoolean() ? Instant.ofEpochMilli(in.readLong()).atZone(ZoneOffset.UTC) : null;
|
||||
}
|
||||
|
||||
public static TimeValue parseTimeValue(XContentParser parser, String settingName) throws IOException {
|
||||
|
|
|
|||
|
|
@ -11,10 +11,10 @@ import org.elasticsearch.common.xcontent.ToXContent;
|
|||
import org.elasticsearch.common.xcontent.ToXContentObject;
|
||||
import org.elasticsearch.common.xcontent.XContentHelper;
|
||||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Array;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Pattern;
|
||||
|
|
@ -67,8 +67,8 @@ public final class WatcherUtils {
|
|||
}
|
||||
return;
|
||||
}
|
||||
if (value instanceof DateTime) {
|
||||
result.put(key, formatDate((DateTime) value));
|
||||
if (value instanceof ZonedDateTime) {
|
||||
result.put(key, formatDate((ZonedDateTime) value));
|
||||
return;
|
||||
}
|
||||
if (value instanceof TimeValue) {
|
||||
|
|
|
|||
|
|
@ -14,11 +14,11 @@ import org.elasticsearch.common.xcontent.XContentParser;
|
|||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.elasticsearch.xpack.core.watcher.common.secret.Secret;
|
||||
import org.elasticsearch.xpack.core.watcher.crypto.CryptoService;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.CharBuffer;
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -63,12 +63,12 @@ public class WatcherXContentParser implements XContentParser {
|
|||
return new Secret(chars);
|
||||
}
|
||||
|
||||
private final DateTime parseTime;
|
||||
private final ZonedDateTime parseTime;
|
||||
private final XContentParser parser;
|
||||
@Nullable private final CryptoService cryptoService;
|
||||
private final boolean allowRedactedPasswords;
|
||||
|
||||
public WatcherXContentParser(XContentParser parser, DateTime parseTime, @Nullable CryptoService cryptoService,
|
||||
public WatcherXContentParser(XContentParser parser, ZonedDateTime parseTime, @Nullable CryptoService cryptoService,
|
||||
boolean allowRedactedPasswords) {
|
||||
this.parseTime = parseTime;
|
||||
this.parser = parser;
|
||||
|
|
@ -76,7 +76,7 @@ public class WatcherXContentParser implements XContentParser {
|
|||
this.allowRedactedPasswords = allowRedactedPasswords;
|
||||
}
|
||||
|
||||
public DateTime getParseDateTime() { return parseTime; }
|
||||
public ZonedDateTime getParseDateTime() { return parseTime; }
|
||||
|
||||
@Override
|
||||
public XContentType contentType() {
|
||||
|
|
|
|||
|
|
@ -10,26 +10,25 @@ import org.elasticsearch.common.xcontent.ToXContentObject;
|
|||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.script.JodaCompatibleZonedDateTime;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public abstract class TriggerEvent implements ToXContentObject {
|
||||
|
||||
private final String jobName;
|
||||
protected final DateTime triggeredTime;
|
||||
protected final ZonedDateTime triggeredTime;
|
||||
protected final Map<String, Object> data;
|
||||
|
||||
public TriggerEvent(String jobName, DateTime triggeredTime) {
|
||||
public TriggerEvent(String jobName, ZonedDateTime triggeredTime) {
|
||||
this.jobName = jobName;
|
||||
this.triggeredTime = triggeredTime;
|
||||
this.data = new HashMap<>();
|
||||
data.put(Field.TRIGGERED_TIME.getPreferredName(),
|
||||
new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(triggeredTime.getMillis()), ZoneOffset.UTC));
|
||||
new JodaCompatibleZonedDateTime(triggeredTime.toInstant(), ZoneOffset.UTC));
|
||||
}
|
||||
|
||||
public String jobName() {
|
||||
|
|
@ -38,7 +37,7 @@ public abstract class TriggerEvent implements ToXContentObject {
|
|||
|
||||
public abstract String type();
|
||||
|
||||
public DateTime triggeredTime() {
|
||||
public ZonedDateTime triggeredTime() {
|
||||
return triggeredTime;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ import org.elasticsearch.xpack.core.watcher.condition.ExecutableCondition;
|
|||
import org.elasticsearch.xpack.core.watcher.input.ExecutableInput;
|
||||
import org.elasticsearch.xpack.core.watcher.transform.ExecutableTransform;
|
||||
import org.elasticsearch.xpack.core.watcher.trigger.Trigger;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -112,7 +112,7 @@ public class Watch implements ToXContentObject {
|
|||
*
|
||||
* @return {@code true} if the status of this watch changed, {@code false} otherwise.
|
||||
*/
|
||||
public boolean setState(boolean active, DateTime now) {
|
||||
public boolean setState(boolean active, ZonedDateTime now) {
|
||||
return status.setActive(active, now);
|
||||
}
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ public class Watch implements ToXContentObject {
|
|||
*
|
||||
* @return {@code true} if the status of this watch changed, {@code false} otherwise.
|
||||
*/
|
||||
public boolean ack(DateTime now, String... actions) {
|
||||
public boolean ack(ZonedDateTime now, String... actions) {
|
||||
return status.onAck(now, actions);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,9 +19,11 @@ import org.elasticsearch.xpack.core.watcher.actions.ActionStatus;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.ExecutionState;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.WatcherParams;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.WatcherXContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -30,11 +32,9 @@ import java.util.Objects;
|
|||
import static java.util.Collections.emptyMap;
|
||||
import static java.util.Collections.unmodifiableMap;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.parseDate;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.readDate;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.readOptionalDate;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.writeDate;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.writeOptionalDate;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class WatchStatus implements ToXContentObject, Streamable {
|
||||
|
||||
|
|
@ -43,8 +43,8 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
private State state;
|
||||
|
||||
@Nullable private ExecutionState executionState;
|
||||
@Nullable private DateTime lastChecked;
|
||||
@Nullable private DateTime lastMetCondition;
|
||||
@Nullable private ZonedDateTime lastChecked;
|
||||
@Nullable private ZonedDateTime lastMetCondition;
|
||||
@Nullable private long version;
|
||||
@Nullable private Map<String, String> headers;
|
||||
private Map<String, ActionStatus> actions;
|
||||
|
|
@ -53,11 +53,11 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
private WatchStatus() {
|
||||
}
|
||||
|
||||
public WatchStatus(DateTime now, Map<String, ActionStatus> actions) {
|
||||
public WatchStatus(ZonedDateTime now, Map<String, ActionStatus> actions) {
|
||||
this(-1, new State(true, now), null, null, null, actions, Collections.emptyMap());
|
||||
}
|
||||
|
||||
public WatchStatus(long version, State state, ExecutionState executionState, DateTime lastChecked, DateTime lastMetCondition,
|
||||
public WatchStatus(long version, State state, ExecutionState executionState, ZonedDateTime lastChecked, ZonedDateTime lastMetCondition,
|
||||
Map<String, ActionStatus> actions, Map<String, String> headers) {
|
||||
this.version = version;
|
||||
this.lastChecked = lastChecked;
|
||||
|
|
@ -76,7 +76,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
return lastChecked != null;
|
||||
}
|
||||
|
||||
public DateTime lastChecked() {
|
||||
public ZonedDateTime lastChecked() {
|
||||
return lastChecked;
|
||||
}
|
||||
|
||||
|
|
@ -134,7 +134,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
*
|
||||
* @param metCondition indicates whether the watch's condition was met.
|
||||
*/
|
||||
public void onCheck(boolean metCondition, DateTime timestamp) {
|
||||
public void onCheck(boolean metCondition, ZonedDateTime timestamp) {
|
||||
lastChecked = timestamp;
|
||||
if (metCondition) {
|
||||
lastMetCondition = timestamp;
|
||||
|
|
@ -145,7 +145,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
}
|
||||
}
|
||||
|
||||
public void onActionResult(String actionId, DateTime timestamp, Action.Result result) {
|
||||
public void onActionResult(String actionId, ZonedDateTime timestamp, Action.Result result) {
|
||||
ActionStatus status = actions.get(actionId);
|
||||
status.update(timestamp, result);
|
||||
}
|
||||
|
|
@ -159,7 +159,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
*
|
||||
* @return {@code true} if the state of changed due to the ack, {@code false} otherwise.
|
||||
*/
|
||||
boolean onAck(DateTime timestamp, String... actionIds) {
|
||||
boolean onAck(ZonedDateTime timestamp, String... actionIds) {
|
||||
boolean changed = false;
|
||||
boolean containsAll = false;
|
||||
for (String actionId : actionIds) {
|
||||
|
|
@ -185,7 +185,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
return changed;
|
||||
}
|
||||
|
||||
boolean setActive(boolean active, DateTime now) {
|
||||
boolean setActive(boolean active, ZonedDateTime now) {
|
||||
boolean change = this.state.active != active;
|
||||
if (change) {
|
||||
this.state = new State(active, now);
|
||||
|
|
@ -219,15 +219,15 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
@Override
|
||||
public void readFrom(StreamInput in) throws IOException {
|
||||
version = in.readLong();
|
||||
lastChecked = readOptionalDate(in, UTC);
|
||||
lastMetCondition = readOptionalDate(in, UTC);
|
||||
lastChecked = readOptionalDate(in);
|
||||
lastMetCondition = readOptionalDate(in);
|
||||
int count = in.readInt();
|
||||
Map<String, ActionStatus> actions = new HashMap<>(count);
|
||||
for (int i = 0; i < count; i++) {
|
||||
actions.put(in.readString(), ActionStatus.readFrom(in));
|
||||
}
|
||||
this.actions = unmodifiableMap(actions);
|
||||
state = new State(in.readBoolean(), readDate(in, UTC));
|
||||
state = new State(in.readBoolean(), Instant.ofEpochMilli(in.readLong()).atZone(ZoneOffset.UTC));
|
||||
boolean executionStateExists = in.readBoolean();
|
||||
if (executionStateExists) {
|
||||
executionState = ExecutionState.resolve(in.readString());
|
||||
|
|
@ -277,8 +277,8 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
public static WatchStatus parse(String watchId, WatcherXContentParser parser) throws IOException {
|
||||
State state = null;
|
||||
ExecutionState executionState = null;
|
||||
DateTime lastChecked = null;
|
||||
DateTime lastMetCondition = null;
|
||||
ZonedDateTime lastChecked = null;
|
||||
ZonedDateTime lastMetCondition = null;
|
||||
Map<String, ActionStatus> actions = null;
|
||||
long version = -1;
|
||||
Map<String, String> headers = Collections.emptyMap();
|
||||
|
|
@ -304,14 +304,14 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
}
|
||||
} else if (Field.LAST_CHECKED.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
if (token.isValue()) {
|
||||
lastChecked = parseDate(currentFieldName, parser, UTC);
|
||||
lastChecked = parseDate(currentFieldName, parser, ZoneOffset.UTC);
|
||||
} else {
|
||||
throw new ElasticsearchParseException("could not parse watch status for [{}]. expecting field [{}] to hold a date " +
|
||||
"value, found [{}] instead", watchId, currentFieldName, token);
|
||||
}
|
||||
} else if (Field.LAST_MET_CONDITION.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
if (token.isValue()) {
|
||||
lastMetCondition = parseDate(currentFieldName, parser, UTC);
|
||||
lastMetCondition = parseDate(currentFieldName, parser, ZoneOffset.UTC);
|
||||
} else {
|
||||
throw new ElasticsearchParseException("could not parse watch status for [{}]. expecting field [{}] to hold a date " +
|
||||
"value, found [{}] instead", watchId, currentFieldName, token);
|
||||
|
|
@ -361,9 +361,9 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
public static class State implements ToXContentObject {
|
||||
|
||||
final boolean active;
|
||||
final DateTime timestamp;
|
||||
final ZonedDateTime timestamp;
|
||||
|
||||
public State(boolean active, DateTime timestamp) {
|
||||
public State(boolean active, ZonedDateTime timestamp) {
|
||||
this.active = active;
|
||||
this.timestamp = timestamp;
|
||||
}
|
||||
|
|
@ -372,7 +372,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
return active;
|
||||
}
|
||||
|
||||
public DateTime getTimestamp() {
|
||||
public ZonedDateTime getTimestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
|
|
@ -389,7 +389,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
throw new ElasticsearchParseException("expected an object but found [{}] instead", parser.currentToken());
|
||||
}
|
||||
boolean active = true;
|
||||
DateTime timestamp = DateTime.now(UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
String currentFieldName = null;
|
||||
XContentParser.Token token;
|
||||
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
|
||||
|
|
@ -398,7 +398,7 @@ public class WatchStatus implements ToXContentObject, Streamable {
|
|||
} else if (Field.ACTIVE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
active = parser.booleanValue();
|
||||
} else if (Field.TIMESTAMP.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
timestamp = parseDate(currentFieldName, parser, UTC);
|
||||
timestamp = parseDate(currentFieldName, parser, ZoneOffset.UTC);
|
||||
} else {
|
||||
parser.skipChildren();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,11 +20,11 @@ import org.elasticsearch.xpack.core.watcher.execution.ExecutionState;
|
|||
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.get.GetWatchResponse;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -124,15 +124,15 @@ public class GetWatchResponseTests extends
|
|||
|
||||
private static WatchStatus randomWatchStatus() {
|
||||
long version = randomLongBetween(-1, Long.MAX_VALUE);
|
||||
WatchStatus.State state = new WatchStatus.State(randomBoolean(), DateTime.now(DateTimeZone.UTC));
|
||||
WatchStatus.State state = new WatchStatus.State(randomBoolean(), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
ExecutionState executionState = randomFrom(ExecutionState.values());
|
||||
DateTime lastChecked = rarely() ? null : DateTime.now(DateTimeZone.UTC);
|
||||
DateTime lastMetCondition = rarely() ? null : DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime lastChecked = rarely() ? null : ZonedDateTime.now(ZoneOffset.UTC);
|
||||
ZonedDateTime lastMetCondition = rarely() ? null : ZonedDateTime.now(ZoneOffset.UTC);
|
||||
int size = randomIntBetween(0, 5);
|
||||
Map<String, ActionStatus> actionMap = new HashMap<>();
|
||||
for (int i = 0; i < size; i++) {
|
||||
ActionStatus.AckStatus ack = new ActionStatus.AckStatus(
|
||||
DateTime.now(DateTimeZone.UTC),
|
||||
ZonedDateTime.now(ZoneOffset.UTC),
|
||||
randomFrom(ActionStatus.AckStatus.State.values())
|
||||
);
|
||||
ActionStatus actionStatus = new ActionStatus(
|
||||
|
|
@ -152,16 +152,16 @@ public class GetWatchResponseTests extends
|
|||
}
|
||||
|
||||
private static ActionStatus.Throttle randomThrottle() {
|
||||
return new ActionStatus.Throttle(DateTime.now(DateTimeZone.UTC), randomAlphaOfLengthBetween(10, 20));
|
||||
return new ActionStatus.Throttle(ZonedDateTime.now(ZoneOffset.UTC), randomAlphaOfLengthBetween(10, 20));
|
||||
}
|
||||
|
||||
private static ActionStatus.Execution randomExecution() {
|
||||
if (randomBoolean()) {
|
||||
return null;
|
||||
} else if (randomBoolean()) {
|
||||
return ActionStatus.Execution.failure(DateTime.now(DateTimeZone.UTC), randomAlphaOfLengthBetween(10, 20));
|
||||
return ActionStatus.Execution.failure(ZonedDateTime.now(ZoneOffset.UTC), randomAlphaOfLengthBetween(10, 20));
|
||||
} else {
|
||||
return ActionStatus.Execution.successful(DateTime.now(DateTimeZone.UTC));
|
||||
return ActionStatus.Execution.successful(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -139,9 +139,9 @@ import org.elasticsearch.xpack.core.watcher.transport.actions.put.PutWatchAction
|
|||
import org.elasticsearch.xpack.core.watcher.transport.actions.service.WatcherServiceAction;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.stats.WatcherStatsAction;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
|
|
@ -1011,7 +1011,7 @@ public class ReservedRolesStoreTests extends ESTestCase {
|
|||
|
||||
assertThat(role.indices().allowedIndicesMatcher(IndexAction.NAME).test("foo"), is(false));
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
String historyIndex = HistoryStoreField.getHistoryIndexNameForTime(now);
|
||||
for (String index : new String[]{ Watch.INDEX, historyIndex, TriggeredWatchStoreField.INDEX_NAME }) {
|
||||
assertOnlyReadAllowed(role, index);
|
||||
|
|
@ -1041,7 +1041,7 @@ public class ReservedRolesStoreTests extends ESTestCase {
|
|||
assertThat(role.indices().allowedIndicesMatcher(IndexAction.NAME).test("foo"), is(false));
|
||||
assertThat(role.indices().allowedIndicesMatcher(IndexAction.NAME).test(TriggeredWatchStoreField.INDEX_NAME), is(false));
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
String historyIndex = HistoryStoreField.getHistoryIndexNameForTime(now);
|
||||
for (String index : new String[]{ Watch.INDEX, historyIndex }) {
|
||||
assertOnlyReadAllowed(role, index);
|
||||
|
|
|
|||
|
|
@ -6,11 +6,11 @@
|
|||
package org.elasticsearch.xpack.core.watcher.watch;
|
||||
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
/**
|
||||
* A clock that can be modified for testing.
|
||||
|
|
@ -58,8 +58,8 @@ public class ClockMock extends Clock {
|
|||
return wrappedClock.instant();
|
||||
}
|
||||
|
||||
public synchronized void setTime(DateTime now) {
|
||||
setTime(Instant.ofEpochMilli(now.getMillis()));
|
||||
public synchronized void setTime(ZonedDateTime now) {
|
||||
setTime(now.toInstant());
|
||||
}
|
||||
|
||||
private void setTime(Instant now) {
|
||||
|
|
|
|||
|
|
@ -14,11 +14,12 @@ import org.elasticsearch.common.xcontent.XContentParser;
|
|||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.elasticsearch.test.ESTestCase;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.WatcherXContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class WatcherXContentParserTests extends ESTestCase {
|
||||
|
||||
|
|
@ -34,11 +35,13 @@ public class WatcherXContentParserTests extends ESTestCase {
|
|||
assertThat(xContentParser.currentName(), is(fieldName));
|
||||
xContentParser.nextToken();
|
||||
assertThat(xContentParser.currentToken(), is(XContentParser.Token.VALUE_STRING));
|
||||
WatcherXContentParser parser = new WatcherXContentParser(xContentParser, DateTime.now(UTC), null, false);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
WatcherXContentParser parser = new WatcherXContentParser(xContentParser, now, null, false);
|
||||
ElasticsearchParseException e = expectThrows(ElasticsearchParseException.class,
|
||||
() -> WatcherXContentParser.secretOrNull(parser));
|
||||
assertThat(e.getMessage(), is("found redacted password in field [" + fieldName + "]"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -176,12 +176,12 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.WeeklySchedule;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.YearlySchedule;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.engine.TickerScheduleTriggerEngine;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.UncheckedIOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
|
|
@ -609,7 +609,7 @@ public class Watcher extends Plugin implements ActionPlugin, ScriptPlugin, Reloa
|
|||
List<String> indices = new ArrayList<>();
|
||||
indices.add(".watches");
|
||||
indices.add(".triggered_watches");
|
||||
DateTime now = new DateTime(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
indices.add(HistoryStoreField.getHistoryIndexNameForTime(now));
|
||||
indices.add(HistoryStoreField.getHistoryIndexNameForTime(now.plusDays(1)));
|
||||
indices.add(HistoryStoreField.getHistoryIndexNameForTime(now.plusMonths(1)));
|
||||
|
|
@ -645,7 +645,7 @@ public class Watcher extends Plugin implements ActionPlugin, ScriptPlugin, Reloa
|
|||
logger.warn("the [action.auto_create_index] setting is configured to be restrictive [{}]. " +
|
||||
" for the next 6 months daily history indices are allowed to be created, but please make sure" +
|
||||
" that any future history indices after 6 months with the pattern " +
|
||||
"[.watcher-history-YYYY.MM.dd] are allowed to be created", value);
|
||||
"[.watcher-history-yyyy.MM.dd] are allowed to be created", value);
|
||||
}
|
||||
|
||||
// These are all old templates from pre 6.0 era, that need to be deleted
|
||||
|
|
|
|||
|
|
@ -29,10 +29,12 @@ import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
|||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchStoreUtils;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
|
|
@ -45,7 +47,6 @@ import java.util.stream.Collectors;
|
|||
|
||||
import static org.elasticsearch.cluster.routing.ShardRoutingState.RELOCATING;
|
||||
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
/**
|
||||
* This index listener ensures, that watches that are being indexed are put into the trigger service
|
||||
|
|
@ -101,7 +102,7 @@ final class WatcherIndexingListener implements IndexingOperationListener, Cluste
|
|||
@Override
|
||||
public Engine.Index preIndex(ShardId shardId, Engine.Index operation) {
|
||||
if (isWatchDocument(shardId.getIndexName(), operation.type())) {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = Instant.ofEpochMilli(clock.millis()).atZone(ZoneOffset.UTC);
|
||||
try {
|
||||
Watch watch = parser.parseWithSecrets(operation.id(), true, operation.source(), now, XContentType.JSON,
|
||||
operation.getIfSeqNo(), operation.getIfPrimaryTerm());
|
||||
|
|
|
|||
|
|
@ -26,9 +26,9 @@ import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
|||
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.support.ArrayObjectIterator;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Stream;
|
||||
|
|
@ -158,7 +158,7 @@ public class ExecutableIndexAction extends ExecutableAction<IndexAction> {
|
|||
}
|
||||
}
|
||||
|
||||
private Map<String, Object> addTimestampToDocument(Map<String, Object> data, DateTime executionTime) {
|
||||
private Map<String, Object> addTimestampToDocument(Map<String, Object> data, ZonedDateTime executionTime) {
|
||||
if (action.executionTimeField != null) {
|
||||
data = mutableMap(data);
|
||||
data.put(action.executionTimeField, WatcherDateTimeUtils.formatDate(executionTime));
|
||||
|
|
|
|||
|
|
@ -11,15 +11,16 @@ import org.elasticsearch.action.support.WriteRequest.RefreshPolicy;
|
|||
import org.elasticsearch.common.Nullable;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.logging.DeprecationLogger;
|
||||
import org.elasticsearch.common.time.DateUtils;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.elasticsearch.xpack.core.watcher.actions.Action;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneId;
|
||||
import java.util.Objects;
|
||||
|
||||
import static org.elasticsearch.common.unit.TimeValue.timeValueMillis;
|
||||
|
|
@ -33,7 +34,7 @@ public class IndexAction implements Action {
|
|||
@Nullable final String docId;
|
||||
@Nullable final String executionTimeField;
|
||||
@Nullable final TimeValue timeout;
|
||||
@Nullable final DateTimeZone dynamicNameTimeZone;
|
||||
@Nullable final ZoneId dynamicNameTimeZone;
|
||||
@Nullable final RefreshPolicy refreshPolicy;
|
||||
|
||||
private static final DeprecationLogger deprecationLogger = new DeprecationLogger(LogManager.getLogger(IndexAction.class));
|
||||
|
|
@ -41,7 +42,7 @@ public class IndexAction implements Action {
|
|||
|
||||
public IndexAction(@Nullable String index, @Nullable String docType, @Nullable String docId,
|
||||
@Nullable String executionTimeField,
|
||||
@Nullable TimeValue timeout, @Nullable DateTimeZone dynamicNameTimeZone, @Nullable RefreshPolicy refreshPolicy) {
|
||||
@Nullable TimeValue timeout, @Nullable ZoneId dynamicNameTimeZone, @Nullable RefreshPolicy refreshPolicy) {
|
||||
this.index = index;
|
||||
this.docType = docType;
|
||||
this.docId = docId;
|
||||
|
|
@ -72,7 +73,7 @@ public class IndexAction implements Action {
|
|||
return executionTimeField;
|
||||
}
|
||||
|
||||
public DateTimeZone getDynamicNameTimeZone() {
|
||||
public ZoneId getDynamicNameTimeZone() {
|
||||
return dynamicNameTimeZone;
|
||||
}
|
||||
|
||||
|
|
@ -132,7 +133,7 @@ public class IndexAction implements Action {
|
|||
String docId = null;
|
||||
String executionTimeField = null;
|
||||
TimeValue timeout = null;
|
||||
DateTimeZone dynamicNameTimeZone = null;
|
||||
ZoneId dynamicNameTimeZone = null;
|
||||
RefreshPolicy refreshPolicy = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
|
|
@ -167,7 +168,7 @@ public class IndexAction implements Action {
|
|||
timeout = WatcherDateTimeUtils.parseTimeValue(parser, Field.TIMEOUT_HUMAN.toString());
|
||||
} else if (Field.DYNAMIC_NAME_TIMEZONE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
dynamicNameTimeZone = DateTimeZone.forID(parser.text());
|
||||
dynamicNameTimeZone = DateUtils.of(parser.text());
|
||||
} else {
|
||||
throw new ElasticsearchParseException("could not parse [{}] action for watch [{}]. failed to parse [{}]. must be " +
|
||||
"a string value (e.g. 'UTC' or '+01:00').", TYPE, watchId, currentFieldName);
|
||||
|
|
@ -274,7 +275,7 @@ public class IndexAction implements Action {
|
|||
String docId;
|
||||
String executionTimeField;
|
||||
TimeValue timeout;
|
||||
DateTimeZone dynamicNameTimeZone;
|
||||
ZoneId dynamicNameTimeZone;
|
||||
RefreshPolicy refreshPolicy;
|
||||
|
||||
private Builder(String index, String docType) {
|
||||
|
|
@ -297,7 +298,7 @@ public class IndexAction implements Action {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder setDynamicNameTimeZone(DateTimeZone dynamicNameTimeZone) {
|
||||
public Builder setDynamicNameTimeZone(ZoneId dynamicNameTimeZone) {
|
||||
this.dynamicNameTimeZone = dynamicNameTimeZone;
|
||||
return this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,17 +5,17 @@
|
|||
*/
|
||||
package org.elasticsearch.xpack.watcher.condition;
|
||||
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.xpack.core.watcher.condition.ExecutableCondition;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.xpack.watcher.support.Variables;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
|
|
@ -47,8 +47,8 @@ abstract class AbstractCompareCondition implements ExecutableCondition {
|
|||
Matcher matcher = DATE_MATH_PATTERN.matcher((String) configuredValue);
|
||||
if (matcher.matches()) {
|
||||
String dateMath = matcher.group(1);
|
||||
configuredValue = WatcherDateTimeUtils.parseDateMath(dateMath, DateTimeZone.UTC, clock);
|
||||
resolvedValues.put(dateMath, WatcherDateTimeUtils.formatDate((DateTime) configuredValue));
|
||||
configuredValue = WatcherDateTimeUtils.parseDateMath(dateMath, ZoneOffset.UTC, clock);
|
||||
resolvedValues.put(dateMath, WatcherDateTimeUtils.formatDate((ZonedDateTime) configuredValue));
|
||||
} else {
|
||||
// checking if the given value is a path expression
|
||||
matcher = PATH_PATTERN.matcher((String) configuredValue);
|
||||
|
|
|
|||
|
|
@ -6,9 +6,10 @@
|
|||
package org.elasticsearch.xpack.watcher.condition;
|
||||
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Objects;
|
||||
|
||||
public class LenientCompare {
|
||||
|
|
@ -53,9 +54,9 @@ public class LenientCompare {
|
|||
}
|
||||
|
||||
// special case for date/times. If v1 is not a dateTime, we'll try to convert it to a datetime
|
||||
if (v2 instanceof DateTime) {
|
||||
if (v1 instanceof DateTime) {
|
||||
return ((DateTime) v1).compareTo((DateTime) v2);
|
||||
if (v2 instanceof ZonedDateTime) {
|
||||
if (v1 instanceof ZonedDateTime) {
|
||||
return ((ZonedDateTime) v1).compareTo((ZonedDateTime) v2);
|
||||
}
|
||||
if (v1 instanceof String) {
|
||||
try {
|
||||
|
|
@ -64,12 +65,12 @@ public class LenientCompare {
|
|||
return null;
|
||||
}
|
||||
} else if (v1 instanceof Number) {
|
||||
v1 = new DateTime(((Number) v1).longValue(), DateTimeZone.UTC);
|
||||
v1 = Instant.ofEpochMilli(((Number) v1).longValue()).atZone(ZoneOffset.UTC);
|
||||
} else {
|
||||
// cannot convert to date...
|
||||
return null;
|
||||
}
|
||||
return ((DateTime) v1).compareTo((DateTime) v2);
|
||||
return ((ZonedDateTime) v1).compareTo((ZonedDateTime) v2);
|
||||
}
|
||||
|
||||
if (v1.getClass() != v2.getClass() || Comparable.class.isAssignableFrom(v1.getClass())) {
|
||||
|
|
|
|||
|
|
@ -53,10 +53,11 @@ import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
|||
import org.elasticsearch.xpack.watcher.Watcher;
|
||||
import org.elasticsearch.xpack.watcher.history.HistoryStore;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
|
|
@ -72,7 +73,6 @@ import java.util.concurrent.atomic.AtomicReference;
|
|||
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.stashWithOrigin;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class ExecutionService {
|
||||
|
||||
|
|
@ -233,7 +233,7 @@ public class ExecutionService {
|
|||
final LinkedList<TriggeredWatch> triggeredWatches = new LinkedList<>();
|
||||
final LinkedList<TriggeredExecutionContext> contexts = new LinkedList<>();
|
||||
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
for (TriggerEvent event : events) {
|
||||
GetResponse response = getWatch(event.jobName());
|
||||
if (response.isExists() == false) {
|
||||
|
|
@ -484,7 +484,7 @@ public class ExecutionService {
|
|||
historyStore.forcePut(record);
|
||||
triggeredWatchStore.delete(triggeredWatch.id());
|
||||
} else {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
TriggeredExecutionContext ctx = new TriggeredExecutionContext(triggeredWatch.id().watchId(), now,
|
||||
triggeredWatch.triggerEvent(), defaultThrottlePeriod, true);
|
||||
executeAsync(ctx, triggeredWatch);
|
||||
|
|
|
|||
|
|
@ -15,9 +15,9 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.input.Input;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.watcher.trigger.manual.ManualTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ public class ManualExecutionContext extends WatchExecutionContext {
|
|||
private final boolean recordExecution;
|
||||
private final boolean knownWatch;
|
||||
|
||||
ManualExecutionContext(Watch watch, boolean knownWatch, DateTime executionTime, ManualTriggerEvent triggerEvent,
|
||||
ManualExecutionContext(Watch watch, boolean knownWatch, ZonedDateTime executionTime, ManualTriggerEvent triggerEvent,
|
||||
TimeValue defaultThrottlePeriod, Input.Result inputResult, Condition.Result conditionResult,
|
||||
Map<String, ActionExecutionMode> actionModes, boolean recordExecution) throws Exception {
|
||||
|
||||
|
|
@ -113,7 +113,7 @@ public class ManualExecutionContext extends WatchExecutionContext {
|
|||
private final boolean knownWatch;
|
||||
private final ManualTriggerEvent triggerEvent;
|
||||
private final TimeValue defaultThrottlePeriod;
|
||||
protected DateTime executionTime;
|
||||
protected ZonedDateTime executionTime;
|
||||
private boolean recordExecution = false;
|
||||
private Map<String, ActionExecutionMode> actionModes = new HashMap<>();
|
||||
private Input.Result inputResult;
|
||||
|
|
@ -127,7 +127,7 @@ public class ManualExecutionContext extends WatchExecutionContext {
|
|||
this.defaultThrottlePeriod = defaultThrottlePeriod;
|
||||
}
|
||||
|
||||
public Builder executionTime(DateTime executionTime) {
|
||||
public Builder executionTime(ZonedDateTime executionTime) {
|
||||
this.executionTime = executionTime;
|
||||
return this;
|
||||
}
|
||||
|
|
@ -164,7 +164,7 @@ public class ManualExecutionContext extends WatchExecutionContext {
|
|||
|
||||
public ManualExecutionContext build() throws Exception {
|
||||
if (executionTime == null) {
|
||||
executionTime = DateTime.now(DateTimeZone.UTC);
|
||||
executionTime = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
}
|
||||
ManualExecutionContext context = new ManualExecutionContext(watch, knownWatch, executionTime, triggerEvent,
|
||||
defaultThrottlePeriod, inputResult, conditionResult, unmodifiableMap(actionModes), recordExecution);
|
||||
|
|
|
|||
|
|
@ -8,17 +8,19 @@ package org.elasticsearch.xpack.watcher.execution;
|
|||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.trigger.TriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
public class TriggeredExecutionContext extends WatchExecutionContext {
|
||||
|
||||
private final boolean overrideOnConflict;
|
||||
|
||||
public TriggeredExecutionContext(String watchId, DateTime executionTime, TriggerEvent triggerEvent, TimeValue defaultThrottlePeriod) {
|
||||
public TriggeredExecutionContext(String watchId, ZonedDateTime executionTime, TriggerEvent triggerEvent,
|
||||
TimeValue defaultThrottlePeriod) {
|
||||
this(watchId, executionTime, triggerEvent, defaultThrottlePeriod, false);
|
||||
}
|
||||
|
||||
TriggeredExecutionContext(String watchId, DateTime executionTime, TriggerEvent triggerEvent, TimeValue defaultThrottlePeriod,
|
||||
TriggeredExecutionContext(String watchId, ZonedDateTime executionTime, TriggerEvent triggerEvent, TimeValue defaultThrottlePeriod,
|
||||
boolean overrideOnConflict) {
|
||||
super(watchId, executionTime, triggerEvent, defaultThrottlePeriod);
|
||||
this.overrideOnConflict = overrideOnConflict;
|
||||
|
|
|
|||
|
|
@ -19,10 +19,10 @@ import org.elasticsearch.xpack.core.watcher.history.HistoryStoreField;
|
|||
import org.elasticsearch.xpack.core.watcher.history.WatchRecord;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.WatcherParams;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchStoreUtils;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.xpack.core.watcher.support.Exceptions.ioException;
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ public class HistoryStore {
|
|||
* @return true, if history store is ready to be started
|
||||
*/
|
||||
public static boolean validate(ClusterState state) {
|
||||
String currentIndex = HistoryStoreField.getHistoryIndexNameForTime(DateTime.now(DateTimeZone.UTC));
|
||||
String currentIndex = HistoryStoreField.getHistoryIndexNameForTime(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
IndexMetaData indexMetaData = WatchStoreUtils.getConcreteIndex(currentIndex, state.metaData());
|
||||
return indexMetaData == null || (indexMetaData.getState() == IndexMetaData.State.OPEN &&
|
||||
state.routingTable().index(indexMetaData.getIndex()).allPrimaryShardsActive());
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ package org.elasticsearch.xpack.watcher.input.search;
|
|||
import org.elasticsearch.ElasticsearchParseException;
|
||||
import org.elasticsearch.common.Nullable;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.time.DateUtils;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
|
|
@ -15,9 +16,9 @@ import org.elasticsearch.xpack.core.watcher.input.Input;
|
|||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.support.search.WatcherSearchTemplateRequest;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneId;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
|
|
@ -33,10 +34,10 @@ public class SearchInput implements Input {
|
|||
private final WatcherSearchTemplateRequest request;
|
||||
@Nullable private final Set<String> extractKeys;
|
||||
@Nullable private final TimeValue timeout;
|
||||
@Nullable private final DateTimeZone dynamicNameTimeZone;
|
||||
@Nullable private final ZoneId dynamicNameTimeZone;
|
||||
|
||||
public SearchInput(WatcherSearchTemplateRequest request, @Nullable Set<String> extractKeys,
|
||||
@Nullable TimeValue timeout, @Nullable DateTimeZone dynamicNameTimeZone) {
|
||||
@Nullable TimeValue timeout, @Nullable ZoneId dynamicNameTimeZone) {
|
||||
this.request = request;
|
||||
this.extractKeys = extractKeys;
|
||||
this.timeout = timeout;
|
||||
|
|
@ -82,7 +83,7 @@ public class SearchInput implements Input {
|
|||
return timeout;
|
||||
}
|
||||
|
||||
public DateTimeZone getDynamicNameTimeZone() {
|
||||
public ZoneId getDynamicNameTimeZone() {
|
||||
return dynamicNameTimeZone;
|
||||
}
|
||||
|
||||
|
|
@ -109,7 +110,7 @@ public class SearchInput implements Input {
|
|||
WatcherSearchTemplateRequest request = null;
|
||||
Set<String> extract = null;
|
||||
TimeValue timeout = null;
|
||||
DateTimeZone dynamicNameTimeZone = null;
|
||||
ZoneId dynamicNameTimeZone = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
XContentParser.Token token;
|
||||
|
|
@ -145,7 +146,7 @@ public class SearchInput implements Input {
|
|||
timeout = WatcherDateTimeUtils.parseTimeValue(parser, Field.TIMEOUT_HUMAN.toString());
|
||||
} else if (Field.DYNAMIC_NAME_TIMEZONE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
dynamicNameTimeZone = DateTimeZone.forID(parser.text());
|
||||
dynamicNameTimeZone = DateUtils.of(parser.text());
|
||||
} else {
|
||||
throw new ElasticsearchParseException("could not parse [{}] input for watch [{}]. failed to parse [{}]. must be a " +
|
||||
"string value (e.g. 'UTC' or '+01:00').", TYPE, watchId, currentFieldName);
|
||||
|
|
@ -201,7 +202,7 @@ public class SearchInput implements Input {
|
|||
private final WatcherSearchTemplateRequest request;
|
||||
private final Set<String> extractKeys = new HashSet<>();
|
||||
private TimeValue timeout;
|
||||
private DateTimeZone dynamicNameTimeZone;
|
||||
private ZoneId dynamicNameTimeZone;
|
||||
|
||||
private Builder(WatcherSearchTemplateRequest request) {
|
||||
this.request = request;
|
||||
|
|
@ -222,7 +223,7 @@ public class SearchInput implements Input {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder dynamicNameTimeZone(DateTimeZone dynamicNameTimeZone) {
|
||||
public Builder dynamicNameTimeZone(ZoneId dynamicNameTimeZone) {
|
||||
this.dynamicNameTimeZone = dynamicNameTimeZone;
|
||||
return this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,16 +8,22 @@ package org.elasticsearch.xpack.watcher.notification.email;
|
|||
import org.elasticsearch.ElasticsearchParseException;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.settings.Settings;
|
||||
import org.elasticsearch.common.time.DateFormatter;
|
||||
import org.elasticsearch.common.time.DateFormatters;
|
||||
import org.elasticsearch.common.xcontent.ToXContentFragment;
|
||||
import org.elasticsearch.common.xcontent.ToXContentObject;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import javax.mail.MessagingException;
|
||||
import javax.mail.internet.AddressException;
|
||||
import javax.mail.internet.InternetAddress;
|
||||
import javax.mail.internet.MimeMessage;
|
||||
import java.io.IOException;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
|
@ -26,20 +32,15 @@ import java.util.List;
|
|||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
|
||||
import javax.mail.MessagingException;
|
||||
import javax.mail.internet.AddressException;
|
||||
import javax.mail.internet.InternetAddress;
|
||||
import javax.mail.internet.MimeMessage;
|
||||
|
||||
import static java.util.Collections.unmodifiableMap;
|
||||
|
||||
public class Email implements ToXContentObject {
|
||||
|
||||
private static final DateFormatter DATE_TIME_FORMATTER = DateFormatter.forPattern("strict_date_time").withZone(ZoneOffset.UTC);
|
||||
final String id;
|
||||
final Address from;
|
||||
final AddressList replyTo;
|
||||
final Priority priority;
|
||||
final DateTime sentDate;
|
||||
final ZonedDateTime sentDate;
|
||||
final AddressList to;
|
||||
final AddressList cc;
|
||||
final AddressList bcc;
|
||||
|
|
@ -48,7 +49,7 @@ public class Email implements ToXContentObject {
|
|||
final String htmlBody;
|
||||
final Map<String, Attachment> attachments;
|
||||
|
||||
public Email(String id, Address from, AddressList replyTo, Priority priority, DateTime sentDate,
|
||||
public Email(String id, Address from, AddressList replyTo, Priority priority, ZonedDateTime sentDate,
|
||||
AddressList to, AddressList cc, AddressList bcc, String subject, String textBody, String htmlBody,
|
||||
Map<String, Attachment> attachments) {
|
||||
|
||||
|
|
@ -56,7 +57,7 @@ public class Email implements ToXContentObject {
|
|||
this.from = from;
|
||||
this.replyTo = replyTo;
|
||||
this.priority = priority;
|
||||
this.sentDate = sentDate != null ? sentDate : new DateTime(DateTimeZone.UTC);
|
||||
this.sentDate = sentDate != null ? sentDate : ZonedDateTime.now(ZoneOffset.UTC);
|
||||
this.to = to;
|
||||
this.cc = cc;
|
||||
this.bcc = bcc;
|
||||
|
|
@ -82,7 +83,7 @@ public class Email implements ToXContentObject {
|
|||
return priority;
|
||||
}
|
||||
|
||||
public DateTime sentDate() {
|
||||
public ZonedDateTime sentDate() {
|
||||
return sentDate;
|
||||
}
|
||||
|
||||
|
|
@ -196,7 +197,7 @@ public class Email implements ToXContentObject {
|
|||
} else if (Field.PRIORITY.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
email.priority(Email.Priority.resolve(parser.text()));
|
||||
} else if (Field.SENT_DATE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
email.sentDate(new DateTime(parser.text(), DateTimeZone.UTC));
|
||||
email.sentDate(DateFormatters.from(DATE_TIME_FORMATTER.parse(parser.text())));
|
||||
} else if (Field.SUBJECT.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
email.subject(parser.text());
|
||||
} else if (Field.BODY.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
|
|
@ -233,7 +234,7 @@ public class Email implements ToXContentObject {
|
|||
private Address from;
|
||||
private AddressList replyTo;
|
||||
private Priority priority;
|
||||
private DateTime sentDate;
|
||||
private ZonedDateTime sentDate;
|
||||
private AddressList to;
|
||||
private AddressList cc;
|
||||
private AddressList bcc;
|
||||
|
|
@ -289,7 +290,7 @@ public class Email implements ToXContentObject {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder sentDate(DateTime sentDate) {
|
||||
public Builder sentDate(ZonedDateTime sentDate) {
|
||||
this.sentDate = sentDate;
|
||||
return this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ package org.elasticsearch.xpack.watcher.notification.email;
|
|||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.sql.Date;
|
||||
import java.util.Locale;
|
||||
|
||||
import javax.mail.Message;
|
||||
|
|
@ -182,7 +183,7 @@ public enum Profile {
|
|||
if (email.priority != null) {
|
||||
email.priority.applyTo(message);
|
||||
}
|
||||
message.setSentDate(email.sentDate.toDate());
|
||||
message.setSentDate(Date.from(email.sentDate.toInstant()));
|
||||
message.setRecipients(Message.RecipientType.TO, email.to.toArray());
|
||||
if (email.cc != null) {
|
||||
message.setRecipients(Message.RecipientType.CC, email.cc.toArray());
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ import org.elasticsearch.script.JodaCompatibleZonedDateTime;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -38,7 +37,7 @@ public final class Variables {
|
|||
ctxModel.put(ID, ctx.id().value());
|
||||
ctxModel.put(WATCH_ID, ctx.id().watchId());
|
||||
ctxModel.put(EXECUTION_TIME,
|
||||
new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(ctx.executionTime().getMillis()), ZoneOffset.UTC));
|
||||
new JodaCompatibleZonedDateTime(ctx.executionTime().toInstant(), ZoneOffset.UTC));
|
||||
ctxModel.put(TRIGGER, ctx.triggerEvent().data());
|
||||
if (payload != null) {
|
||||
ctxModel.put(PAYLOAD, payload.data());
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ package org.elasticsearch.xpack.watcher.transform.search;
|
|||
import org.elasticsearch.ElasticsearchParseException;
|
||||
import org.elasticsearch.common.Nullable;
|
||||
import org.elasticsearch.common.ParseField;
|
||||
import org.elasticsearch.common.time.DateUtils;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
|
|
@ -15,9 +16,9 @@ import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
|||
import org.elasticsearch.xpack.core.watcher.transform.Transform;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.support.search.WatcherSearchTemplateRequest;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneId;
|
||||
|
||||
import static org.elasticsearch.common.unit.TimeValue.timeValueMillis;
|
||||
|
||||
|
|
@ -27,9 +28,9 @@ public class SearchTransform implements Transform {
|
|||
|
||||
private final WatcherSearchTemplateRequest request;
|
||||
@Nullable private final TimeValue timeout;
|
||||
@Nullable private final DateTimeZone dynamicNameTimeZone;
|
||||
@Nullable private final ZoneId dynamicNameTimeZone;
|
||||
|
||||
public SearchTransform(WatcherSearchTemplateRequest request, @Nullable TimeValue timeout, @Nullable DateTimeZone dynamicNameTimeZone) {
|
||||
public SearchTransform(WatcherSearchTemplateRequest request, @Nullable TimeValue timeout, @Nullable ZoneId dynamicNameTimeZone) {
|
||||
this.request = request;
|
||||
this.timeout = timeout;
|
||||
this.dynamicNameTimeZone = dynamicNameTimeZone;
|
||||
|
|
@ -48,7 +49,7 @@ public class SearchTransform implements Transform {
|
|||
return timeout;
|
||||
}
|
||||
|
||||
public DateTimeZone getDynamicNameTimeZone() {
|
||||
public ZoneId getDynamicNameTimeZone() {
|
||||
return dynamicNameTimeZone;
|
||||
}
|
||||
|
||||
|
|
@ -91,7 +92,7 @@ public class SearchTransform implements Transform {
|
|||
public static SearchTransform parse(String watchId, XContentParser parser) throws IOException {
|
||||
WatcherSearchTemplateRequest request = null;
|
||||
TimeValue timeout = null;
|
||||
DateTimeZone dynamicNameTimeZone = null;
|
||||
ZoneId dynamicNameTimeZone = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
XContentParser.Token token;
|
||||
|
|
@ -112,7 +113,7 @@ public class SearchTransform implements Transform {
|
|||
timeout = WatcherDateTimeUtils.parseTimeValue(parser, Field.TIMEOUT_HUMAN.toString());
|
||||
} else if (Field.DYNAMIC_NAME_TIMEZONE.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
if (token == XContentParser.Token.VALUE_STRING) {
|
||||
dynamicNameTimeZone = DateTimeZone.forID(parser.text());
|
||||
dynamicNameTimeZone = DateUtils.of(parser.text());
|
||||
} else {
|
||||
throw new ElasticsearchParseException("could not parse [{}] transform for watch [{}]. failed to parse [{}]. must be a" +
|
||||
" string value (e.g. 'UTC' or '+01:00').", TYPE, watchId, currentFieldName);
|
||||
|
|
@ -167,7 +168,7 @@ public class SearchTransform implements Transform {
|
|||
|
||||
private final WatcherSearchTemplateRequest request;
|
||||
private TimeValue timeout;
|
||||
private DateTimeZone dynamicNameTimeZone;
|
||||
private ZoneId dynamicNameTimeZone;
|
||||
|
||||
public Builder(WatcherSearchTemplateRequest request) {
|
||||
this.request = request;
|
||||
|
|
@ -178,7 +179,7 @@ public class SearchTransform implements Transform {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder dynamicNameTimeZone(DateTimeZone dynamicNameTimeZone) {
|
||||
public Builder dynamicNameTimeZone(ZoneId dynamicNameTimeZone) {
|
||||
this.dynamicNameTimeZone = dynamicNameTimeZone;
|
||||
return this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,16 +34,16 @@ import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.WatchField;
|
||||
import org.elasticsearch.xpack.watcher.transport.actions.WatcherTransportAction;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class TransportAckWatchAction extends WatcherTransportAction<AckWatchRequest, AckWatchResponse> {
|
||||
|
||||
|
|
@ -83,7 +83,7 @@ public class TransportAckWatchAction extends WatcherTransportAction<AckWatchRequ
|
|||
if (getResponse.isExists() == false) {
|
||||
listener.onFailure(new ResourceNotFoundException("Watch with id [{}] does not exist", request.getWatchId()));
|
||||
} else {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
Watch watch = parser.parseWithSecrets(request.getWatchId(), true, getResponse.getSourceAsBytesRef(),
|
||||
now, XContentType.JSON, getResponse.getSeqNo(), getResponse.getPrimaryTerm());
|
||||
watch.status().version(getResponse.getVersion());
|
||||
|
|
|
|||
|
|
@ -28,16 +28,16 @@ import org.elasticsearch.xpack.core.watcher.watch.WatchField;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.elasticsearch.xpack.watcher.transport.actions.WatcherTransportAction;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.writeDate;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
/**
|
||||
* Performs the watch de/activation operation.
|
||||
|
|
@ -60,7 +60,7 @@ public class TransportActivateWatchAction extends WatcherTransportAction<Activat
|
|||
@Override
|
||||
protected void doExecute(ActivateWatchRequest request, ActionListener<ActivateWatchResponse> listener) {
|
||||
try {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
UpdateRequest updateRequest = new UpdateRequest(Watch.INDEX, Watch.DOC_TYPE, request.getWatchId());
|
||||
updateRequest.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
|
||||
XContentBuilder builder = activateWatchBuilder(request.isActivate(), now);
|
||||
|
|
@ -93,7 +93,7 @@ public class TransportActivateWatchAction extends WatcherTransportAction<Activat
|
|||
}
|
||||
}
|
||||
|
||||
private XContentBuilder activateWatchBuilder(boolean active, DateTime now) throws IOException {
|
||||
private XContentBuilder activateWatchBuilder(boolean active, ZonedDateTime now) throws IOException {
|
||||
try (XContentBuilder builder = jsonBuilder()) {
|
||||
builder.startObject()
|
||||
.startObject(WatchField.STATUS.getPreferredName())
|
||||
|
|
|
|||
|
|
@ -41,16 +41,16 @@ import org.elasticsearch.xpack.watcher.transport.actions.WatcherTransportAction;
|
|||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.elasticsearch.xpack.watcher.trigger.manual.ManualTriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
/**
|
||||
* Performs the watch execution operation.
|
||||
|
|
@ -133,7 +133,7 @@ public class TransportExecuteWatchAction extends WatcherTransportAction<ExecuteW
|
|||
ManualExecutionContext.Builder ctxBuilder = ManualExecutionContext.builder(watch, knownWatch,
|
||||
new ManualTriggerEvent(triggerEvent.jobName(), triggerEvent), executionService.defaultThrottlePeriod());
|
||||
|
||||
DateTime executionTime = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime executionTime = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ctxBuilder.executionTime(executionTime);
|
||||
for (Map.Entry<String, ActionExecutionMode> entry : request.getActionModes().entrySet()) {
|
||||
ctxBuilder.actionMode(entry.getKey(), entry.getValue());
|
||||
|
|
|
|||
|
|
@ -26,14 +26,14 @@ import org.elasticsearch.xpack.core.watcher.transport.actions.get.GetWatchRespon
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.watcher.transport.actions.WatcherTransportAction;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class TransportGetWatchAction extends WatcherTransportAction<GetWatchRequest, GetWatchResponse> {
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ public class TransportGetWatchAction extends WatcherTransportAction<GetWatchRequ
|
|||
// When we return the watch via the Get Watch REST API, we want to return the watch as was specified in
|
||||
// the put api, we don't include the status in the watch source itself, but as a separate top level field,
|
||||
// so that it indicates the the status is managed by watcher itself.
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
Watch watch = parser.parseWithSecrets(request.getId(), true, getResponse.getSourceAsBytesRef(), now,
|
||||
XContentType.JSON, getResponse.getSeqNo(), getResponse.getPrimaryTerm());
|
||||
watch.toXContent(builder, WatcherParams.builder()
|
||||
|
|
|
|||
|
|
@ -29,16 +29,16 @@ import org.elasticsearch.xpack.core.watcher.transport.actions.put.PutWatchAction
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.watcher.transport.actions.WatcherTransportAction;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.WATCHER_ORIGIN;
|
||||
import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
/**
|
||||
* This action internally has two modes of operation - an insert and an update mode
|
||||
|
|
@ -77,10 +77,11 @@ public class TransportPutWatchAction extends WatcherTransportAction<PutWatchRequ
|
|||
@Override
|
||||
protected void doExecute(PutWatchRequest request, ActionListener<PutWatchResponse> listener) {
|
||||
try {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
boolean isUpdate = request.getVersion() > 0 || request.getIfSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO;
|
||||
Watch watch = parser.parseWithSecrets(request.getId(), false, request.getSource(), now, request.xContentType(),
|
||||
isUpdate, request.getIfSeqNo(), request.getIfPrimaryTerm());
|
||||
|
||||
watch.setState(request.isActive(), now);
|
||||
|
||||
// ensure we only filter for the allowed headers
|
||||
|
|
|
|||
|
|
@ -11,17 +11,17 @@ import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
|||
import org.elasticsearch.xpack.core.watcher.trigger.TriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.trigger.TriggerEngine;
|
||||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import static org.elasticsearch.xpack.core.watcher.support.Exceptions.illegalArgument;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public abstract class ScheduleTriggerEngine implements TriggerEngine<ScheduleTrigger, ScheduleTriggerEvent> {
|
||||
|
||||
|
|
@ -49,19 +49,19 @@ public abstract class ScheduleTriggerEngine implements TriggerEngine<ScheduleTri
|
|||
|
||||
@Override
|
||||
public ScheduleTriggerEvent simulateEvent(String jobId, @Nullable Map<String, Object> data, TriggerService service) {
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
if (data == null) {
|
||||
return new ScheduleTriggerEvent(jobId, now, now);
|
||||
}
|
||||
|
||||
Object value = data.get(ScheduleTriggerEvent.Field.TRIGGERED_TIME.getPreferredName());
|
||||
DateTime triggeredTime = value != null ? WatcherDateTimeUtils.convertToDate(value, clock) : now;
|
||||
ZonedDateTime triggeredTime = value != null ? WatcherDateTimeUtils.convertToDate(value, clock) : now;
|
||||
if (triggeredTime == null) {
|
||||
throw illegalArgument("could not simulate schedule event. could not convert provided triggered time [{}] to date/time", value);
|
||||
}
|
||||
|
||||
value = data.get(ScheduleTriggerEvent.Field.SCHEDULED_TIME.getPreferredName());
|
||||
DateTime scheduledTime = value != null ? WatcherDateTimeUtils.convertToDate(value, clock) : triggeredTime;
|
||||
ZonedDateTime scheduledTime = value != null ? WatcherDateTimeUtils.convertToDate(value, clock) : triggeredTime;
|
||||
if (scheduledTime == null) {
|
||||
throw illegalArgument("could not simulate schedule event. could not convert provided scheduled time [{}] to date/time", value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,27 +12,25 @@ import org.elasticsearch.common.xcontent.XContentParser;
|
|||
import org.elasticsearch.script.JodaCompatibleZonedDateTime;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils;
|
||||
import org.elasticsearch.xpack.core.watcher.trigger.TriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
public class ScheduleTriggerEvent extends TriggerEvent {
|
||||
|
||||
private final DateTime scheduledTime;
|
||||
private final ZonedDateTime scheduledTime;
|
||||
|
||||
public ScheduleTriggerEvent(DateTime triggeredTime, DateTime scheduledTime) {
|
||||
public ScheduleTriggerEvent(ZonedDateTime triggeredTime, ZonedDateTime scheduledTime) {
|
||||
this(null, triggeredTime, scheduledTime);
|
||||
}
|
||||
|
||||
public ScheduleTriggerEvent(String jobName, DateTime triggeredTime, DateTime scheduledTime) {
|
||||
public ScheduleTriggerEvent(String jobName, ZonedDateTime triggeredTime, ZonedDateTime scheduledTime) {
|
||||
super(jobName, triggeredTime);
|
||||
this.scheduledTime = scheduledTime;
|
||||
data.put(Field.SCHEDULED_TIME.getPreferredName(),
|
||||
new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(scheduledTime.getMillis()), ZoneOffset.UTC));
|
||||
new JodaCompatibleZonedDateTime(scheduledTime.toInstant(), ZoneOffset.UTC));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -40,7 +38,7 @@ public class ScheduleTriggerEvent extends TriggerEvent {
|
|||
return ScheduleTrigger.TYPE;
|
||||
}
|
||||
|
||||
public DateTime scheduledTime() {
|
||||
public ZonedDateTime scheduledTime() {
|
||||
return scheduledTime;
|
||||
}
|
||||
|
||||
|
|
@ -60,8 +58,8 @@ public class ScheduleTriggerEvent extends TriggerEvent {
|
|||
}
|
||||
|
||||
public static ScheduleTriggerEvent parse(XContentParser parser, String watchId, String context, Clock clock) throws IOException {
|
||||
DateTime triggeredTime = null;
|
||||
DateTime scheduledTime = null;
|
||||
ZonedDateTime triggeredTime = null;
|
||||
ZonedDateTime scheduledTime = null;
|
||||
|
||||
String currentFieldName = null;
|
||||
XContentParser.Token token;
|
||||
|
|
@ -70,7 +68,7 @@ public class ScheduleTriggerEvent extends TriggerEvent {
|
|||
currentFieldName = parser.currentName();
|
||||
} else if (Field.TRIGGERED_TIME.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
try {
|
||||
triggeredTime = WatcherDateTimeUtils.parseDateMath(currentFieldName, parser, DateTimeZone.UTC, clock);
|
||||
triggeredTime = WatcherDateTimeUtils.parseDateMath(currentFieldName, parser, ZoneOffset.UTC, clock);
|
||||
} catch (ElasticsearchParseException pe) {
|
||||
//Failed to parse as a date try datemath parsing
|
||||
throw new ElasticsearchParseException("could not parse [{}] trigger event for [{}] for watch [{}]. failed to parse " +
|
||||
|
|
@ -78,7 +76,7 @@ public class ScheduleTriggerEvent extends TriggerEvent {
|
|||
}
|
||||
} else if (Field.SCHEDULED_TIME.match(currentFieldName, parser.getDeprecationHandler())) {
|
||||
try {
|
||||
scheduledTime = WatcherDateTimeUtils.parseDateMath(currentFieldName, parser, DateTimeZone.UTC, clock);
|
||||
scheduledTime = WatcherDateTimeUtils.parseDateMath(currentFieldName, parser, ZoneOffset.UTC, clock);
|
||||
} catch (ElasticsearchParseException pe) {
|
||||
throw new ElasticsearchParseException("could not parse [{}] trigger event for [{}] for watch [{}]. failed to parse " +
|
||||
"date field [{}]", pe, ScheduleTriggerEngine.TYPE, context, watchId, currentFieldName);
|
||||
|
|
|
|||
|
|
@ -19,9 +19,11 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleRegistry;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTrigger;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEngine;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
|
|
@ -32,7 +34,6 @@ import java.util.concurrent.ConcurrentHashMap;
|
|||
import java.util.concurrent.CountDownLatch;
|
||||
|
||||
import static org.elasticsearch.common.settings.Setting.positiveTimeSetting;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class TickerScheduleTriggerEngine extends ScheduleTriggerEngine {
|
||||
|
||||
|
|
@ -109,9 +110,10 @@ public class TickerScheduleTriggerEngine extends ScheduleTriggerEngine {
|
|||
for (ActiveSchedule schedule : schedules.values()) {
|
||||
long scheduledTime = schedule.check(triggeredTime);
|
||||
if (scheduledTime > 0) {
|
||||
DateTime triggeredDateTime = new DateTime(triggeredTime, UTC);
|
||||
DateTime scheduledDateTime = new DateTime(scheduledTime, UTC);
|
||||
logger.debug("triggered job [{}] at [{}] (scheduled time was [{}])", schedule.name, triggeredDateTime, scheduledDateTime);
|
||||
ZonedDateTime triggeredDateTime = utcDateTimeAtEpochMillis(triggeredTime);
|
||||
ZonedDateTime scheduledDateTime = utcDateTimeAtEpochMillis(scheduledTime);
|
||||
logger.debug("triggered job [{}] at [{}] (scheduled time was [{}])", schedule.name,
|
||||
triggeredDateTime, scheduledDateTime);
|
||||
events.add(new ScheduleTriggerEvent(schedule.name, triggeredDateTime, scheduledDateTime));
|
||||
if (events.size() >= 1000) {
|
||||
notifyListeners(events);
|
||||
|
|
@ -124,6 +126,10 @@ public class TickerScheduleTriggerEngine extends ScheduleTriggerEngine {
|
|||
}
|
||||
}
|
||||
|
||||
private ZonedDateTime utcDateTimeAtEpochMillis(long triggeredTime) {
|
||||
return Instant.ofEpochMilli(triggeredTime).atZone(ZoneOffset.UTC);
|
||||
}
|
||||
|
||||
// visible for testing
|
||||
Map<String, ActiveSchedule> getSchedules() {
|
||||
return Collections.unmodifiableMap(schedules);
|
||||
|
|
@ -181,7 +187,7 @@ public class TickerScheduleTriggerEngine extends ScheduleTriggerEngine {
|
|||
@Override
|
||||
public void run() {
|
||||
while (active) {
|
||||
logger.trace("checking jobs [{}]", new DateTime(clock.millis(), UTC));
|
||||
logger.trace("checking jobs [{}]", clock.instant().atZone(ZoneOffset.UTC));
|
||||
checkJobs();
|
||||
try {
|
||||
sleep(tickInterval.millis());
|
||||
|
|
|
|||
|
|
@ -11,12 +11,13 @@ import org.elasticsearch.cli.ExitCodes;
|
|||
import org.elasticsearch.cli.LoggingAwareCommand;
|
||||
import org.elasticsearch.cli.Terminal;
|
||||
import org.elasticsearch.cli.UserException;
|
||||
import org.elasticsearch.common.time.DateFormatter;
|
||||
import org.elasticsearch.xpack.core.scheduler.Cron;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.joda.time.format.DateTimeFormat;
|
||||
import org.joda.time.format.DateTimeFormatter;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
|
|
@ -27,10 +28,12 @@ public class CronEvalTool extends LoggingAwareCommand {
|
|||
exit(new CronEvalTool().main(args, Terminal.DEFAULT));
|
||||
}
|
||||
|
||||
private static final DateTimeFormatter UTC_FORMATTER = DateTimeFormat.forPattern("EEE, d MMM yyyy HH:mm:ss")
|
||||
.withZone(DateTimeZone.UTC).withLocale(Locale.ROOT);
|
||||
private static final DateTimeFormatter LOCAL_FORMATTER = DateTimeFormat.forPattern("EEE, d MMM yyyy HH:mm:ss Z")
|
||||
.withZone(DateTimeZone.forTimeZone(null));
|
||||
private static final DateFormatter UTC_FORMATTER = DateFormatter.forPattern("EEE, d MMM yyyy HH:mm:ss")
|
||||
.withZone(ZoneOffset.UTC)
|
||||
.withLocale(Locale.ROOT);
|
||||
|
||||
private static final DateFormatter LOCAL_FORMATTER = DateFormatter.forPattern("EEE, d MMM yyyy HH:mm:ss Z")
|
||||
.withZone(ZoneId.systemDefault());
|
||||
|
||||
private final OptionSpec<Integer> countOption;
|
||||
private final OptionSpec<String> arguments;
|
||||
|
|
@ -57,18 +60,18 @@ public class CronEvalTool extends LoggingAwareCommand {
|
|||
Cron.validate(expression);
|
||||
terminal.println("Valid!");
|
||||
|
||||
final DateTime date = DateTime.now(DateTimeZone.UTC);
|
||||
final boolean isLocalTimeUTC = UTC_FORMATTER.getZone().equals(LOCAL_FORMATTER.getZone());
|
||||
final ZonedDateTime date = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
final boolean isLocalTimeUTC = UTC_FORMATTER.zone().equals(LOCAL_FORMATTER.zone());
|
||||
if (isLocalTimeUTC) {
|
||||
terminal.println("Now is [" + UTC_FORMATTER.print(date) + "] in UTC");
|
||||
terminal.println("Now is [" + UTC_FORMATTER.format(date) + "] in UTC");
|
||||
} else {
|
||||
terminal.println("Now is [" + UTC_FORMATTER.print(date) + "] in UTC, local time is [" + LOCAL_FORMATTER.print(date) + "]");
|
||||
terminal.println("Now is [" + UTC_FORMATTER.format(date) + "] in UTC, local time is [" + LOCAL_FORMATTER.format(date) + "]");
|
||||
|
||||
}
|
||||
terminal.println("Here are the next " + count + " times this cron expression will trigger:");
|
||||
|
||||
Cron cron = new Cron(expression);
|
||||
long time = date.getMillis();
|
||||
long time = date.toInstant().toEpochMilli();
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
long prevTime = time;
|
||||
|
|
@ -76,16 +79,19 @@ public class CronEvalTool extends LoggingAwareCommand {
|
|||
if (time < 0) {
|
||||
if (i == 0) {
|
||||
throw new UserException(ExitCodes.OK, "Could not compute future times since ["
|
||||
+ UTC_FORMATTER.print(prevTime) + "] " + "(perhaps the cron expression only points to times in the past?)");
|
||||
+ UTC_FORMATTER.format(Instant.ofEpochMilli(prevTime)) + "] " + "(perhaps the cron expression only points to " +
|
||||
"times in the" +
|
||||
" " +
|
||||
"past?)");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (isLocalTimeUTC) {
|
||||
terminal.println((i + 1) + ".\t" + UTC_FORMATTER.print(time));
|
||||
terminal.println((i + 1) + ".\t" + UTC_FORMATTER.format(Instant.ofEpochMilli(time)));
|
||||
} else {
|
||||
terminal.println((i + 1) + ".\t" + UTC_FORMATTER.print(time));
|
||||
terminal.println("\t" + LOCAL_FORMATTER.print(time));
|
||||
terminal.println((i + 1) + ".\t" + UTC_FORMATTER.format(Instant.ofEpochMilli(time)));
|
||||
terminal.println("\t" + LOCAL_FORMATTER.format(Instant.ofEpochMilli(time)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,11 +33,12 @@ import org.elasticsearch.xpack.watcher.condition.InternalAlwaysCondition;
|
|||
import org.elasticsearch.xpack.watcher.input.InputRegistry;
|
||||
import org.elasticsearch.xpack.watcher.input.none.ExecutableNoneInput;
|
||||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
|
@ -46,7 +47,6 @@ import java.util.Map;
|
|||
import static java.util.Collections.unmodifiableMap;
|
||||
import static org.elasticsearch.common.unit.TimeValue.timeValueMillis;
|
||||
import static org.elasticsearch.xpack.core.watcher.support.Exceptions.ioException;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class WatchParser {
|
||||
|
||||
|
|
@ -75,11 +75,13 @@ public class WatchParser {
|
|||
|
||||
public Watch parse(String name, boolean includeStatus, BytesReference source, XContentType xContentType,
|
||||
long sourceSeqNo, long sourcePrimaryTerm) throws IOException {
|
||||
return parse(name, includeStatus, false, source, new DateTime(clock.millis(), UTC), xContentType, false,
|
||||
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
return parse(name, includeStatus, false, source, now, xContentType, false,
|
||||
sourceSeqNo, sourcePrimaryTerm);
|
||||
}
|
||||
|
||||
public Watch parse(String name, boolean includeStatus, BytesReference source, DateTime now,
|
||||
public Watch parse(String name, boolean includeStatus, BytesReference source, ZonedDateTime now,
|
||||
XContentType xContentType, long sourceSeqNo, long sourcePrimaryTerm) throws IOException {
|
||||
return parse(name, includeStatus, false, source, now, xContentType, false, sourceSeqNo, sourcePrimaryTerm);
|
||||
}
|
||||
|
|
@ -95,19 +97,19 @@ public class WatchParser {
|
|||
* of the watch in the system will be use secrets for sensitive data.
|
||||
*
|
||||
*/
|
||||
public Watch parseWithSecrets(String id, boolean includeStatus, BytesReference source, DateTime now,
|
||||
public Watch parseWithSecrets(String id, boolean includeStatus, BytesReference source, ZonedDateTime now,
|
||||
XContentType xContentType, boolean allowRedactedPasswords, long sourceSeqNo, long sourcePrimaryTerm
|
||||
) throws IOException {
|
||||
return parse(id, includeStatus, true, source, now, xContentType, allowRedactedPasswords, sourceSeqNo, sourcePrimaryTerm);
|
||||
}
|
||||
|
||||
|
||||
public Watch parseWithSecrets(String id, boolean includeStatus, BytesReference source, DateTime now,
|
||||
public Watch parseWithSecrets(String id, boolean includeStatus, BytesReference source, ZonedDateTime now,
|
||||
XContentType xContentType, long sourceSeqNo, long sourcePrimaryTerm) throws IOException {
|
||||
return parse(id, includeStatus, true, source, now, xContentType, false, sourceSeqNo, sourcePrimaryTerm);
|
||||
}
|
||||
|
||||
private Watch parse(String id, boolean includeStatus, boolean withSecrets, BytesReference source, DateTime now,
|
||||
private Watch parse(String id, boolean includeStatus, boolean withSecrets, BytesReference source, ZonedDateTime now,
|
||||
XContentType xContentType, boolean allowRedactedPasswords, long sourceSeqNo, long sourcePrimaryTerm)
|
||||
throws IOException {
|
||||
if (logger.isTraceEnabled()) {
|
||||
|
|
|
|||
|
|
@ -38,10 +38,11 @@ import org.elasticsearch.xpack.watcher.WatcherIndexingListener.Configuration;
|
|||
import org.elasticsearch.xpack.watcher.WatcherIndexingListener.ShardAllocationConfiguration;
|
||||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.BitSet;
|
||||
import java.util.Collections;
|
||||
|
|
@ -61,7 +62,6 @@ import static org.hamcrest.Matchers.containsString;
|
|||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.core.Is.is;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Matchers.anyObject;
|
||||
|
|
@ -140,7 +140,7 @@ public class WatcherIndexingListenerTests extends ESTestCase {
|
|||
Engine.Index returnedOperation = listener.preIndex(shardId, operation);
|
||||
assertThat(returnedOperation, is(operation));
|
||||
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
verify(parser).parseWithSecrets(eq(operation.id()), eq(true), eq(BytesArray.EMPTY), eq(now), anyObject(), anyLong(), anyLong());
|
||||
|
||||
if (isNewWatch) {
|
||||
|
|
|
|||
|
|
@ -56,11 +56,11 @@ import org.elasticsearch.xpack.watcher.input.none.ExecutableNoneInput;
|
|||
import org.elasticsearch.xpack.watcher.trigger.TriggerEngine;
|
||||
import org.elasticsearch.xpack.watcher.trigger.TriggerService;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
|
@ -190,7 +190,7 @@ public class WatcherServiceTests extends ESTestCase {
|
|||
if (active) {
|
||||
activeWatchCount++;
|
||||
}
|
||||
WatchStatus.State state = new WatchStatus.State(active, DateTime.now(DateTimeZone.UTC));
|
||||
WatchStatus.State state = new WatchStatus.State(active, ZonedDateTime.now(ZoneOffset.UTC));
|
||||
WatchStatus watchStatus = mock(WatchStatus.class);
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watchStatus.state()).thenReturn(state);
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.elasticsearch.xpack.watcher.condition.NeverCondition;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -30,7 +30,7 @@ import static org.mockito.Mockito.when;
|
|||
|
||||
public class ActionWrapperTests extends ESTestCase {
|
||||
|
||||
private DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
private ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
private Watch watch = mock(Watch.class);
|
||||
@SuppressWarnings("unchecked")
|
||||
private ExecutableAction<Action> executableAction = mock(ExecutableAction.class);
|
||||
|
|
@ -72,4 +72,4 @@ public class ActionWrapperTests extends ESTestCase {
|
|||
ActionStatus.Execution execution = ActionStatus.Execution.successful(now);
|
||||
return new ActionStatus(ackStatus, execution, execution, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,16 +45,14 @@ import org.elasticsearch.xpack.watcher.notification.email.attachment.HttpEmailAt
|
|||
import org.elasticsearch.xpack.watcher.notification.email.attachment.HttpRequestAttachment;
|
||||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.test.MockTextTemplateEngine;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
|
@ -131,8 +129,8 @@ public class EmailActionTests extends ESTestCase {
|
|||
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(now.getMillis()), ZoneOffset.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(now.toInstant(), ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid("watch1", now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder("watch1")
|
||||
|
|
@ -536,7 +534,7 @@ public class EmailActionTests extends ESTestCase {
|
|||
ExecutableEmailAction executableEmailAction = new EmailActionFactory(Settings.EMPTY, emailService, engine, emailAttachmentsParser)
|
||||
.parseExecutable(randomAlphaOfLength(3), randomAlphaOfLength(7), parser);
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder("watch1")
|
||||
|
|
@ -562,7 +560,7 @@ public class EmailActionTests extends ESTestCase {
|
|||
}
|
||||
|
||||
private WatchExecutionContext createWatchExecutionContext() {
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
return mockExecutionContextBuilder("watch1")
|
||||
|
|
|
|||
|
|
@ -31,13 +31,11 @@ import org.elasticsearch.xpack.watcher.notification.hipchat.HipChatAccount;
|
|||
import org.elasticsearch.xpack.watcher.notification.hipchat.HipChatMessage;
|
||||
import org.elasticsearch.xpack.watcher.notification.hipchat.HipChatService;
|
||||
import org.elasticsearch.xpack.watcher.notification.hipchat.SentMessages;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
|
@ -80,8 +78,8 @@ public class HipChatActionTests extends ESTestCase {
|
|||
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(now.getMillis()), ZoneOffset.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(now.toInstant(), ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
|
|||
|
|
@ -31,10 +31,11 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.test.WatcherTestUtils;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
|
|
@ -52,7 +53,6 @@ import static org.hamcrest.Matchers.hasSize;
|
|||
import static org.hamcrest.Matchers.instanceOf;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.startsWith;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ public class IndexActionTests extends ESTestCase {
|
|||
final ExecutableIndexAction executable = new ExecutableIndexAction(action, logger, client,
|
||||
TimeValue.timeValueSeconds(30), TimeValue.timeValueSeconds(30));
|
||||
final Map<String, Object> docWithId = MapBuilder.<String, Object>newMapBuilder().put("foo", "bar").put("_id", "0").immutableMap();
|
||||
final DateTime executionTime = DateTime.now(UTC);
|
||||
final ZonedDateTime executionTime = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
// using doc_id with bulk fails regardless of using ID
|
||||
expectThrows(IllegalStateException.class, () -> {
|
||||
|
|
@ -285,7 +285,7 @@ public class IndexActionTests extends ESTestCase {
|
|||
refreshPolicy);
|
||||
ExecutableIndexAction executable = new ExecutableIndexAction(action, logger, client, TimeValue.timeValueSeconds(30),
|
||||
TimeValue.timeValueSeconds(30));
|
||||
DateTime executionTime = DateTime.now(UTC);
|
||||
ZonedDateTime executionTime = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Payload payload;
|
||||
|
||||
if (customId && docIdAsParam == false) {
|
||||
|
|
@ -344,7 +344,7 @@ public class IndexActionTests extends ESTestCase {
|
|||
docs.add(Collections.singletonMap("foo", Collections.singletonMap("foo", "bar")));
|
||||
Payload payload = new Payload.Simple(Collections.singletonMap("_doc", docs));
|
||||
|
||||
WatchExecutionContext ctx = WatcherTestUtils.mockExecutionContext("_id", DateTime.now(UTC), payload);
|
||||
WatchExecutionContext ctx = WatcherTestUtils.mockExecutionContext("_id", ZonedDateTime.now(ZoneOffset.UTC), payload);
|
||||
|
||||
ArgumentCaptor<BulkRequest> captor = ArgumentCaptor.forClass(BulkRequest.class);
|
||||
PlainActionFuture<BulkResponse> listener = PlainActionFuture.newFuture();
|
||||
|
|
|
|||
|
|
@ -14,19 +14,19 @@ import org.elasticsearch.xpack.core.watcher.actions.Action;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.Wid;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.common.http.BasicAuth;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpClient;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpProxy;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpRequest;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpResponse;
|
||||
import org.elasticsearch.xpack.watcher.common.http.BasicAuth;
|
||||
import org.elasticsearch.xpack.watcher.common.text.TextTemplate;
|
||||
import org.elasticsearch.xpack.watcher.common.text.TextTemplateEngine;
|
||||
import org.elasticsearch.xpack.watcher.notification.jira.JiraAccount;
|
||||
import org.elasticsearch.xpack.watcher.notification.jira.JiraService;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
|
|
@ -77,7 +77,7 @@ public class ExecutableJiraActionTests extends ESTestCase {
|
|||
JiraService service = mock(JiraService.class);
|
||||
when(service.getAccount(eq("account1"))).thenReturn(account);
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
@ -288,7 +288,7 @@ public class ExecutableJiraActionTests extends ESTestCase {
|
|||
}
|
||||
|
||||
private WatchExecutionContext createWatchExecutionContext() {
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
return mockExecutionContextBuilder("watch1")
|
||||
|
|
|
|||
|
|
@ -32,9 +32,9 @@ import org.elasticsearch.xpack.watcher.notification.jira.JiraAccountTests;
|
|||
import org.elasticsearch.xpack.watcher.notification.jira.JiraIssue;
|
||||
import org.elasticsearch.xpack.watcher.notification.jira.JiraService;
|
||||
import org.elasticsearch.xpack.watcher.support.Variables;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -238,7 +238,7 @@ public class JiraActionTests extends ESTestCase {
|
|||
Map<String, Object> data = new HashMap<>();
|
||||
Payload payload = new Payload.Simple(data);
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext context = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
|
|||
|
|
@ -19,12 +19,11 @@ import org.elasticsearch.xpack.watcher.common.text.TextTemplate;
|
|||
import org.elasticsearch.xpack.watcher.common.text.TextTemplateEngine;
|
||||
import org.elasticsearch.xpack.watcher.notification.email.Attachment;
|
||||
import org.elasticsearch.xpack.watcher.test.WatcherTestUtils;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -37,7 +36,6 @@ import static org.hamcrest.CoreMatchers.notNullValue;
|
|||
import static org.hamcrest.Matchers.containsString;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.core.Is.is;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
|
@ -57,8 +55,8 @@ public class LoggingActionTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecute() throws Exception {
|
||||
final DateTime now = DateTime.now(UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(now.getMillis()), ZoneOffset.UTC);
|
||||
final ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(now.toInstant(), ZoneOffset.UTC);
|
||||
|
||||
WatchExecutionContext ctx = WatcherTestUtils.mockExecutionContextBuilder("_watch_id")
|
||||
.time("_watch_id", now)
|
||||
|
|
|
|||
|
|
@ -30,12 +30,10 @@ import org.elasticsearch.xpack.watcher.notification.pagerduty.IncidentEventDefau
|
|||
import org.elasticsearch.xpack.watcher.notification.pagerduty.PagerDutyAccount;
|
||||
import org.elasticsearch.xpack.watcher.notification.pagerduty.PagerDutyService;
|
||||
import org.elasticsearch.xpack.watcher.notification.pagerduty.SentEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -80,8 +78,8 @@ public class PagerDutyActionTests extends ESTestCase {
|
|||
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(now.getMillis()), ZoneOffset.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(now.toInstant(), ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
|
|||
|
|
@ -20,10 +20,11 @@ import org.elasticsearch.xpack.watcher.notification.slack.SlackAccount;
|
|||
import org.elasticsearch.xpack.watcher.notification.slack.SlackService;
|
||||
import org.elasticsearch.xpack.watcher.notification.slack.message.SlackMessage;
|
||||
import org.elasticsearch.xpack.watcher.test.MockTextTemplateEngine;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.xpack.watcher.test.WatcherTestUtils.mockExecutionContextBuilder;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.mockito.Matchers.eq;
|
||||
|
|
@ -49,7 +50,7 @@ public class ExecutableSlackActionTests extends ESTestCase {
|
|||
SlackService service = mock(SlackService.class);
|
||||
when(service.getAccount(eq("account1"))).thenReturn(account);
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
|
|||
|
|
@ -28,12 +28,10 @@ import org.elasticsearch.xpack.watcher.notification.slack.SlackService;
|
|||
import org.elasticsearch.xpack.watcher.notification.slack.message.SlackMessage;
|
||||
import org.elasticsearch.xpack.watcher.notification.slack.message.SlackMessageDefaults;
|
||||
import org.elasticsearch.xpack.watcher.notification.slack.message.SlackMessageTests;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
|
@ -77,8 +75,8 @@ public class SlackActionTests extends ESTestCase {
|
|||
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(now.getMillis()), ZoneOffset.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
JodaCompatibleZonedDateTime jodaJavaNow = new JodaCompatibleZonedDateTime(now.toInstant(), ZoneOffset.UTC);
|
||||
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
WatchExecutionContext ctx = mockExecutionContextBuilder(wid.watchId())
|
||||
|
|
|
|||
|
|
@ -13,21 +13,20 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.xpack.core.watcher.support.WatcherDateTimeUtils.formatDate;
|
||||
import static org.elasticsearch.xpack.watcher.test.WatcherTestUtils.mockExecutionContext;
|
||||
import static org.hamcrest.CoreMatchers.nullValue;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
public class AckThrottlerTests extends ESTestCase {
|
||||
public void testWhenAcked() throws Exception {
|
||||
DateTime timestamp = new DateTime(Clock.systemUTC().millis(), UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
WatchExecutionContext ctx = mockExecutionContext("_watch", Payload.EMPTY);
|
||||
Watch watch = ctx.watch();
|
||||
ActionStatus actionStatus = mock(ActionStatus.class);
|
||||
|
|
@ -43,7 +42,7 @@ public class AckThrottlerTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testThrottleWhenAwaitsSuccessfulExecution() throws Exception {
|
||||
DateTime timestamp = new DateTime(Clock.systemUTC().millis(), UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
WatchExecutionContext ctx = mockExecutionContext("_watch", Payload.EMPTY);
|
||||
Watch watch = ctx.watch();
|
||||
ActionStatus actionStatus = mock(ActionStatus.class);
|
||||
|
|
@ -59,7 +58,7 @@ public class AckThrottlerTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testThrottleWhenAckable() throws Exception {
|
||||
DateTime timestamp = new DateTime(Clock.systemUTC().millis(), UTC);
|
||||
ZonedDateTime timestamp = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
WatchExecutionContext ctx = mockExecutionContext("_watch", Payload.EMPTY);
|
||||
Watch watch = ctx.watch();
|
||||
ActionStatus actionStatus = mock(ActionStatus.class);
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ package org.elasticsearch.xpack.watcher.actions.throttler;
|
|||
import org.elasticsearch.ElasticsearchException;
|
||||
import org.elasticsearch.common.Strings;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.common.xcontent.XContentFactory;
|
||||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.elasticsearch.protocol.xpack.watcher.PutWatchRequest;
|
||||
|
|
@ -15,7 +16,6 @@ import org.elasticsearch.xpack.core.watcher.actions.Action;
|
|||
import org.elasticsearch.xpack.core.watcher.client.WatchSourceBuilder;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.ActionExecutionMode;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.ExecutionState;
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.execute.ExecuteWatchRequestBuilder;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.execute.ExecuteWatchResponse;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
|
|
@ -32,10 +32,10 @@ import org.elasticsearch.xpack.watcher.trigger.manual.ManualTriggerEvent;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.IntervalSchedule;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTrigger;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
|
|
@ -134,7 +134,7 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
}
|
||||
|
||||
public void testDifferentThrottlePeriods() throws Exception {
|
||||
timeWarp().clock().setTime(DateTime.now(DateTimeZone.UTC));
|
||||
timeWarp().clock().setTime(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
WatchSourceBuilder watchSourceBuilder = watchBuilder()
|
||||
.trigger(schedule(interval("60m")));
|
||||
|
||||
|
|
@ -185,11 +185,11 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
watchSourceBuilder.buildAsBytes(XContentType.JSON), XContentType.JSON)).actionGet();
|
||||
refresh(Watch.INDEX);
|
||||
|
||||
timeWarp().clock().setTime(new DateTime(DateTimeZone.UTC));
|
||||
timeWarp().clock().setTime(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
|
||||
ExecuteWatchResponse executeWatchResponse = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
@ -201,7 +201,7 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
|
||||
executeWatchResponse = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
@ -214,7 +214,7 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
try {
|
||||
ExecuteWatchResponse executeWatchResponse1 = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
@ -238,11 +238,11 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
watchSourceBuilder.buildAsBytes(XContentType.JSON), XContentType.JSON)).actionGet();
|
||||
refresh(Watch.INDEX);
|
||||
|
||||
timeWarp().clock().setTime(new DateTime(DateTimeZone.UTC));
|
||||
timeWarp().clock().setTime(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
|
||||
ExecuteWatchResponse executeWatchResponse = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
@ -253,7 +253,7 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
|
||||
executeWatchResponse = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
@ -267,7 +267,7 @@ public class ActionThrottleTests extends AbstractWatcherIntegrationTestCase {
|
|||
//Since the default throttle period is 5 seconds but we have overridden the period in the watch this should trigger
|
||||
ExecuteWatchResponse executeWatchResponse1 = watcherClient().prepareExecuteWatch("_id")
|
||||
.setTriggerEvent(new ManualTriggerEvent("execute_id",
|
||||
new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC))))
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC))))
|
||||
.setActionMode("default_global_throttle", ActionExecutionMode.SIMULATE)
|
||||
.setRecordExecution(true)
|
||||
.get();
|
||||
|
|
|
|||
|
|
@ -13,9 +13,10 @@ import org.elasticsearch.xpack.core.watcher.actions.throttler.Throttler;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static org.elasticsearch.xpack.watcher.test.WatcherTestUtils.mockExecutionContext;
|
||||
import static org.hamcrest.CoreMatchers.nullValue;
|
||||
|
|
@ -32,7 +33,7 @@ public class PeriodThrottlerTests extends ESTestCase {
|
|||
|
||||
WatchExecutionContext ctx = mockExecutionContext("_name", Payload.EMPTY);
|
||||
ActionStatus actionStatus = mock(ActionStatus.class);
|
||||
DateTime now = new DateTime(Clock.systemUTC().millis());
|
||||
ZonedDateTime now = Clock.systemUTC().instant().atZone(ZoneOffset.UTC);
|
||||
when(actionStatus.lastSuccessfulExecution())
|
||||
.thenReturn(ActionStatus.Execution.successful(now.minusSeconds((int) period.seconds() - 1)));
|
||||
WatchStatus status = mock(WatchStatus.class);
|
||||
|
|
@ -53,7 +54,7 @@ public class PeriodThrottlerTests extends ESTestCase {
|
|||
|
||||
WatchExecutionContext ctx = mockExecutionContext("_name", Payload.EMPTY);
|
||||
ActionStatus actionStatus = mock(ActionStatus.class);
|
||||
DateTime now = new DateTime(Clock.systemUTC().millis());
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
when(actionStatus.lastSuccessfulExecution())
|
||||
.thenReturn(ActionStatus.Execution.successful(now.minusSeconds((int) period.seconds() + 1)));
|
||||
WatchStatus status = mock(WatchStatus.class);
|
||||
|
|
|
|||
|
|
@ -38,11 +38,12 @@ import org.elasticsearch.xpack.watcher.test.MockTextTemplateEngine;
|
|||
import org.elasticsearch.xpack.watcher.test.WatcherTestUtils;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.hamcrest.Matchers;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
|
||||
import javax.mail.internet.AddressException;
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.elasticsearch.common.unit.TimeValue.timeValueSeconds;
|
||||
|
|
@ -56,7 +57,6 @@ import static org.hamcrest.Matchers.greaterThanOrEqualTo;
|
|||
import static org.hamcrest.Matchers.hasSize;
|
||||
import static org.hamcrest.Matchers.lessThanOrEqualTo;
|
||||
import static org.hamcrest.core.Is.is;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.never;
|
||||
|
|
@ -227,8 +227,10 @@ public class WebhookActionTests extends ESTestCase {
|
|||
|
||||
ExecutableWebhookAction executable = new ExecutableWebhookAction(action, logger, httpClient, templateEngine);
|
||||
String watchId = "test_url_encode" + randomAlphaOfLength(10);
|
||||
TriggeredExecutionContext ctx = new TriggeredExecutionContext(watchId, new DateTime(UTC),
|
||||
new ScheduleTriggerEvent(watchId, new DateTime(UTC), new DateTime(UTC)), timeValueSeconds(5));
|
||||
ScheduleTriggerEvent triggerEvent = new ScheduleTriggerEvent(watchId, ZonedDateTime.now(ZoneOffset.UTC),
|
||||
ZonedDateTime.now(ZoneOffset.UTC));
|
||||
TriggeredExecutionContext ctx = new TriggeredExecutionContext(watchId, ZonedDateTime.now(ZoneOffset.UTC),
|
||||
triggerEvent, timeValueSeconds(5));
|
||||
Watch watch = createWatch(watchId);
|
||||
ctx.ensureWatchExists(() -> watch);
|
||||
executable.execute("_id", ctx, new Payload.Simple());
|
||||
|
|
@ -252,8 +254,10 @@ public class WebhookActionTests extends ESTestCase {
|
|||
|
||||
ExecutableWebhookAction executable = new ExecutableWebhookAction(action, logger, client, templateEngine);
|
||||
|
||||
TriggeredExecutionContext ctx = new TriggeredExecutionContext(watchId, new DateTime(UTC),
|
||||
new ScheduleTriggerEvent(watchId, new DateTime(UTC), new DateTime(UTC)), timeValueSeconds(5));
|
||||
ScheduleTriggerEvent triggerEvent = new ScheduleTriggerEvent(watchId, ZonedDateTime.now(ZoneOffset.UTC),
|
||||
ZonedDateTime.now(ZoneOffset.UTC));
|
||||
TriggeredExecutionContext ctx = new TriggeredExecutionContext(watchId, ZonedDateTime.now(ZoneOffset.UTC),
|
||||
triggerEvent, timeValueSeconds(5));
|
||||
Watch watch = createWatch(watchId);
|
||||
ctx.ensureWatchExists(() -> watch);
|
||||
Action.Result result = executable.execute("_id", ctx, new Payload.Simple());
|
||||
|
|
|
|||
|
|
@ -14,12 +14,12 @@ import org.elasticsearch.test.ESTestCase;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.ClockMock;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Rule;
|
||||
import org.junit.rules.ExpectedException;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
|
|
@ -158,7 +158,7 @@ public class ArrayCompareConditionTests extends ESTestCase {
|
|||
List<Object> values = new ArrayList<>(numberOfValues);
|
||||
for (int i = 0; i < numberOfValues; i++) {
|
||||
clock.fastForwardSeconds(1);
|
||||
values.add(new DateTime(clock.millis()));
|
||||
values.add(clock.instant().atZone(ZoneOffset.UTC));
|
||||
}
|
||||
|
||||
ArrayCompareCondition condition = new ArrayCompareCondition("ctx.payload.value", "", op, value, quantifier, clock);
|
||||
|
|
|
|||
|
|
@ -15,9 +15,10 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.ClockMock;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.condition.CompareCondition.Op;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.Locale;
|
||||
|
||||
|
|
@ -178,7 +179,7 @@ public class CompareConditionTests extends ESTestCase {
|
|||
Op op = met ? randomFrom(CompareCondition.Op.GT, CompareCondition.Op.GTE, CompareCondition.Op.NOT_EQ) :
|
||||
randomFrom(CompareCondition.Op.LT, CompareCondition.Op.LTE, CompareCondition.Op.EQ);
|
||||
String value = "<{now-1d}>";
|
||||
DateTime payloadValue = new DateTime(clock.millis());
|
||||
ZonedDateTime payloadValue = clock.instant().atZone(ZoneId.systemDefault());
|
||||
|
||||
CompareCondition condition = new CompareCondition("ctx.payload.value", op, value, clock);
|
||||
WatchExecutionContext ctx = mockExecutionContext("_name", new Payload.Simple("value", payloadValue));
|
||||
|
|
|
|||
|
|
@ -33,11 +33,11 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.test.WatcherMockScriptPlugin;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -194,7 +194,7 @@ public class ScriptConditionTests extends ESTestCase {
|
|||
mockScript("ctx.trigger.scheduled_time.toInstant().toEpochMill() < new Date().time"), scriptService);
|
||||
SearchResponse response = new SearchResponse(InternalSearchResponse.empty(), "", 3, 3, 0, 500L, ShardSearchFailure.EMPTY_ARRAY,
|
||||
SearchResponse.Clusters.EMPTY);
|
||||
WatchExecutionContext ctx = mockExecutionContext("_name", new DateTime(DateTimeZone.UTC),
|
||||
WatchExecutionContext ctx = mockExecutionContext("_name", ZonedDateTime.now(ZoneOffset.UTC),
|
||||
new Payload.XContent(response, ToXContent.EMPTY_PARAMS));
|
||||
Thread.sleep(10);
|
||||
assertThat(condition.execute(ctx).met(), is(true));
|
||||
|
|
|
|||
|
|
@ -69,12 +69,14 @@ import org.elasticsearch.xpack.watcher.trigger.manual.ManualTrigger;
|
|||
import org.elasticsearch.xpack.watcher.trigger.manual.ManualTriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
|
|
@ -98,8 +100,6 @@ import static org.hamcrest.Matchers.not;
|
|||
import static org.hamcrest.Matchers.notNullValue;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.hamcrest.Matchers.sameInstance;
|
||||
import static org.joda.time.DateTime.now;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Matchers.anyObject;
|
||||
|
|
@ -164,7 +164,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(getResponse.isExists()).thenReturn(true);
|
||||
mockGetWatchResponse(client, "_id", getResponse);
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
when(parser.parseWithSecrets(eq(watch.id()), eq(true), any(), any(), any(), anyLong(), anyLong())).thenReturn(watch);
|
||||
|
|
@ -268,7 +268,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
when(parser.parseWithSecrets(eq(watch.id()), eq(true), any(), any(), any(), anyLong(), anyLong())).thenReturn(watch);
|
||||
|
|
@ -337,7 +337,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(getResponse.isExists()).thenReturn(true);
|
||||
mockGetWatchResponse(client, "_id", getResponse);
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
when(parser.parseWithSecrets(eq(watch.id()), eq(true), any(), any(), any(), anyLong(), anyLong())).thenReturn(watch);
|
||||
|
|
@ -402,7 +402,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(getResponse.isExists()).thenReturn(true);
|
||||
mockGetWatchResponse(client, "_id", getResponse);
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
when(parser.parseWithSecrets(eq(watch.id()), eq(true), any(), any(), any(), anyLong(), anyLong())).thenReturn(watch);
|
||||
|
|
@ -467,7 +467,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
mockGetWatchResponse(client, "_id", getResponse);
|
||||
when(parser.parseWithSecrets(eq(watch.id()), eq(true), any(), any(), any(), anyLong(), anyLong())).thenReturn(watch);
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
|
||||
|
|
@ -543,7 +543,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecuteInner() throws Exception {
|
||||
DateTime now = now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
|
|
@ -595,7 +595,8 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(action.execute("_action", context, payload)).thenReturn(actionResult);
|
||||
|
||||
ActionWrapper actionWrapper = new ActionWrapper("_action", throttler, actionCondition, actionTransform, action);
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), singletonMap("_action", new ActionStatus(now)));
|
||||
ZonedDateTime time = clock.instant().atZone(ZoneOffset.UTC);
|
||||
WatchStatus watchStatus = new WatchStatus(time, singletonMap("_action", new ActionStatus(now)));
|
||||
|
||||
when(watch.input()).thenReturn(input);
|
||||
when(watch.condition()).thenReturn(condition);
|
||||
|
|
@ -619,7 +620,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecuteInnerThrottled() throws Exception {
|
||||
DateTime now = now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
|
|
@ -643,7 +644,8 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
ExecutableAction action = mock(ExecutableAction.class);
|
||||
when(action.type()).thenReturn("_type");
|
||||
ActionWrapper actionWrapper = new ActionWrapper("_action", throttler, actionCondition, actionTransform, action);
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), singletonMap("_action", new ActionStatus(now)));
|
||||
ZonedDateTime time = clock.instant().atZone(ZoneOffset.UTC);
|
||||
WatchStatus watchStatus = new WatchStatus(time, singletonMap("_action", new ActionStatus(now)));
|
||||
|
||||
when(watch.input()).thenReturn(input);
|
||||
when(watch.condition()).thenReturn(condition);
|
||||
|
|
@ -671,7 +673,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecuteInnerConditionNotMet() throws Exception {
|
||||
DateTime now = now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
|
|
@ -705,7 +707,8 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
ExecutableAction action = mock(ExecutableAction.class);
|
||||
when(action.type()).thenReturn("_type");
|
||||
ActionWrapper actionWrapper = new ActionWrapper("_action", throttler, actionCondition, actionTransform, action);
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), singletonMap("_action", new ActionStatus(now)));
|
||||
ZonedDateTime time = clock.instant().atZone(ZoneOffset.UTC);
|
||||
WatchStatus watchStatus = new WatchStatus(time, singletonMap("_action", new ActionStatus(now)));
|
||||
|
||||
when(watch.input()).thenReturn(input);
|
||||
when(watch.condition()).thenReturn(condition);
|
||||
|
|
@ -733,7 +736,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecuteInnerConditionNotMetDueToException() throws Exception {
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn(getTestName());
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
|
|
@ -761,7 +764,8 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(action.type()).thenReturn("_type");
|
||||
when(action.logger()).thenReturn(logger);
|
||||
ActionWrapper actionWrapper = new ActionWrapper("_action", throttler, actionCondition, actionTransform, action);
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), singletonMap("_action", new ActionStatus(now)));
|
||||
ZonedDateTime time = clock.instant().atZone(ZoneOffset.UTC);
|
||||
WatchStatus watchStatus = new WatchStatus(time, singletonMap("_action", new ActionStatus(now)));
|
||||
|
||||
when(watch.input()).thenReturn(input);
|
||||
when(watch.condition()).thenReturn(condition);
|
||||
|
|
@ -789,7 +793,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testExecuteConditionNotMet() throws Exception {
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), now, event, timeValueSeconds(5));
|
||||
|
|
@ -809,7 +813,8 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
ExecutableAction action = mock(ExecutableAction.class);
|
||||
ActionWrapper actionWrapper = new ActionWrapper("_action", throttler, actionCondition, actionTransform, action);
|
||||
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), singletonMap("_action", new ActionStatus(now)));
|
||||
ZonedDateTime time = clock.instant().atZone(ZoneOffset.UTC);
|
||||
WatchStatus watchStatus = new WatchStatus(time, singletonMap("_action", new ActionStatus(now)));
|
||||
|
||||
when(watch.input()).thenReturn(input);
|
||||
when(watch.condition()).thenReturn(condition);
|
||||
|
|
@ -833,7 +838,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
public void testThatTriggeredWatchDeletionWorksOnExecutionRejection() throws Exception {
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("foo");
|
||||
WatchStatus status = new WatchStatus(DateTime.now(UTC), Collections.emptyMap());
|
||||
WatchStatus status = new WatchStatus(ZonedDateTime.now(ZoneOffset.UTC), Collections.emptyMap());
|
||||
when(watch.status()).thenReturn(status);
|
||||
GetResponse getResponse = mock(GetResponse.class);
|
||||
when(getResponse.isExists()).thenReturn(true);
|
||||
|
|
@ -845,9 +850,10 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
doThrow(new EsRejectedExecutionException()).when(executor).execute(any());
|
||||
doThrow(new ElasticsearchException("whatever")).when(historyStore).forcePut(any());
|
||||
|
||||
Wid wid = new Wid(watch.id(), now());
|
||||
Wid wid = new Wid(watch.id(), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
|
||||
TriggeredWatch triggeredWatch = new TriggeredWatch(wid, new ScheduleTriggerEvent(now() ,now()));
|
||||
TriggeredWatch triggeredWatch = new TriggeredWatch(wid,
|
||||
new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC) ,ZonedDateTime.now(ZoneOffset.UTC)));
|
||||
executionService.executeTriggeredWatches(Collections.singleton(triggeredWatch));
|
||||
|
||||
verify(triggeredWatchStore, times(1)).delete(wid);
|
||||
|
|
@ -863,7 +869,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(getResponse.isExists()).thenReturn(true);
|
||||
mockGetWatchResponse(client, "_id", getResponse);
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
WatchExecutionContext context = ManualExecutionContext.builder(watch, false, new ManualTriggerEvent("foo", event),
|
||||
timeValueSeconds(5)).build();
|
||||
|
|
@ -900,7 +906,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
when(ctx.watch()).thenReturn(watch);
|
||||
Wid wid = new Wid(watch.id(), DateTime.now(UTC));
|
||||
Wid wid = new Wid(watch.id(), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
when(ctx.id()).thenReturn(wid);
|
||||
|
||||
executionService.getCurrentExecutions().put("_id", new ExecutionService.WatchExecution(ctx, Thread.currentThread()));
|
||||
|
|
@ -913,9 +919,9 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
public void testExecuteWatchNotFound() throws Exception {
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(),
|
||||
new DateTime(0, UTC),
|
||||
new ScheduleTriggerEvent(watch.id(), new DateTime(0, UTC), new DateTime(0, UTC)),
|
||||
ZonedDateTime epochZeroTime = Instant.EPOCH.atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent triggerEvent = new ScheduleTriggerEvent(watch.id(), epochZeroTime, epochZeroTime);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), epochZeroTime, triggerEvent,
|
||||
TimeValue.timeValueSeconds(5));
|
||||
|
||||
GetResponse notFoundResponse = mock(GetResponse.class);
|
||||
|
|
@ -930,9 +936,9 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
public void testExecuteWatchIndexNotFoundException() {
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(),
|
||||
new DateTime(0, UTC),
|
||||
new ScheduleTriggerEvent(watch.id(), new DateTime(0, UTC), new DateTime(0, UTC)),
|
||||
ZonedDateTime epochZeroTime = Instant.EPOCH.atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent triggerEvent = new ScheduleTriggerEvent(watch.id(), epochZeroTime, epochZeroTime);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), epochZeroTime, triggerEvent,
|
||||
TimeValue.timeValueSeconds(5));
|
||||
|
||||
mockGetWatchException(client, "_id", new IndexNotFoundException(".watch"));
|
||||
|
|
@ -944,9 +950,10 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
public void testExecuteWatchParseWatchException() {
|
||||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
ZonedDateTime epochZeroTime = Instant.EPOCH.atZone(ZoneOffset.UTC);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(),
|
||||
new DateTime(0, UTC),
|
||||
new ScheduleTriggerEvent(watch.id(), new DateTime(0, UTC), new DateTime(0, UTC)),
|
||||
epochZeroTime,
|
||||
new ScheduleTriggerEvent(watch.id(), epochZeroTime, epochZeroTime),
|
||||
TimeValue.timeValueSeconds(5));
|
||||
|
||||
IOException e = new IOException("something went wrong, i.e. index not found");
|
||||
|
|
@ -963,10 +970,10 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
WatchExecutionContext ctx = mock(WatchExecutionContext.class);
|
||||
when(ctx.knownWatch()).thenReturn(true);
|
||||
WatchStatus status = mock(WatchStatus.class);
|
||||
when(status.state()).thenReturn(new WatchStatus.State(false, now()));
|
||||
when(status.state()).thenReturn(new WatchStatus.State(false, ZonedDateTime.now(ZoneOffset.UTC)));
|
||||
when(watch.status()).thenReturn(status);
|
||||
when(ctx.watch()).thenReturn(watch);
|
||||
Wid wid = new Wid(watch.id(), DateTime.now(UTC));
|
||||
Wid wid = new Wid(watch.id(), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
when(ctx.id()).thenReturn(wid);
|
||||
|
||||
GetResponse getResponse = mock(GetResponse.class);
|
||||
|
|
@ -983,7 +990,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testCurrentExecutionSnapshots() throws Exception {
|
||||
DateTime time = DateTime.now(UTC);
|
||||
ZonedDateTime time = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
int snapshotCount = randomIntBetween(2, 8);
|
||||
for (int i = 0; i < snapshotCount; i++) {
|
||||
time = time.minusSeconds(10);
|
||||
|
|
@ -999,7 +1006,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
|
||||
public void testQueuedWatches() throws Exception {
|
||||
Collection<Runnable> tasks = new ArrayList<>();
|
||||
DateTime time = DateTime.now(UTC);
|
||||
ZonedDateTime time = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
int queuedWatchCount = randomIntBetween(2, 8);
|
||||
for (int i = 0; i < queuedWatchCount; i++) {
|
||||
time = time.minusSeconds(10);
|
||||
|
|
@ -1016,7 +1023,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testUpdateWatchStatusDoesNotUpdateState() throws Exception {
|
||||
WatchStatus status = new WatchStatus(DateTime.now(UTC), Collections.emptyMap());
|
||||
WatchStatus status = new WatchStatus(ZonedDateTime.now(ZoneOffset.UTC), Collections.emptyMap());
|
||||
Watch watch = new Watch("_id", new ManualTrigger(), new ExecutableNoneInput(), InternalAlwaysCondition.INSTANCE, null, null,
|
||||
Collections.emptyList(), null, status, 1L, 1L);
|
||||
|
||||
|
|
@ -1046,7 +1053,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
Watch watch = mock(Watch.class);
|
||||
when(watch.id()).thenReturn("_id");
|
||||
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
ManualExecutionContext ctx = ManualExecutionContext.builder(watch, true,
|
||||
new ManualTriggerEvent("foo", event), timeValueSeconds(5)).build();
|
||||
|
|
@ -1071,7 +1078,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
when(watch.actions()).thenReturn(Collections.singletonList(actionWrapper));
|
||||
|
||||
WatchStatus status = mock(WatchStatus.class);
|
||||
when(status.state()).thenReturn(new WatchStatus.State(false, now()));
|
||||
when(status.state()).thenReturn(new WatchStatus.State(false, ZonedDateTime.now(ZoneOffset.UTC)));
|
||||
when(watch.status()).thenReturn(status);
|
||||
|
||||
WatchRecord watchRecord = executionService.execute(ctx);
|
||||
|
|
@ -1079,7 +1086,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testLoadingWatchExecutionUser() throws Exception {
|
||||
DateTime now = now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Watch watch = mock(Watch.class);
|
||||
WatchStatus status = mock(WatchStatus.class);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
|
|
@ -1105,7 +1112,7 @@ public class ExecutionServiceTests extends ESTestCase {
|
|||
assertThat(context.getUser(), equalTo("joe"));
|
||||
}
|
||||
|
||||
private WatchExecutionContext createMockWatchExecutionContext(String watchId, DateTime executionTime) {
|
||||
private WatchExecutionContext createMockWatchExecutionContext(String watchId, ZonedDateTime executionTime) {
|
||||
WatchExecutionContext ctx = mock(WatchExecutionContext.class);
|
||||
when(ctx.id()).thenReturn(new Wid(watchId, executionTime));
|
||||
when(ctx.executionTime()).thenReturn(executionTime);
|
||||
|
|
|
|||
|
|
@ -68,10 +68,10 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.CronSchedule;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleRegistry;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchTests;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
|
|
@ -84,7 +84,6 @@ import static org.hamcrest.Matchers.equalTo;
|
|||
import static org.hamcrest.Matchers.hasSize;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.notNullValue;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Matchers.eq;
|
||||
|
|
@ -262,7 +261,7 @@ public class TriggeredWatchStoreTests extends ESTestCase {
|
|||
}).when(client).execute(eq(ClearScrollAction.INSTANCE), any(), any());
|
||||
|
||||
assertThat(TriggeredWatchStore.validate(cs), is(true));
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
ScheduleTriggerEvent triggerEvent = new ScheduleTriggerEvent(now, now);
|
||||
|
||||
Watch watch1 = mock(Watch.class);
|
||||
|
|
@ -393,8 +392,9 @@ public class TriggeredWatchStoreTests extends ESTestCase {
|
|||
WatcherSearchTemplateService searchTemplateService = mock(WatcherSearchTemplateService.class);
|
||||
|
||||
Watch watch = WatcherTestUtils.createTestWatch("fired_test", client, httpClient, emailService, searchTemplateService, logger);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent(watch.id(), DateTime.now(DateTimeZone.UTC), DateTime.now(DateTimeZone.UTC));
|
||||
Wid wid = new Wid("_record", DateTime.now(DateTimeZone.UTC));
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent(watch.id(), ZonedDateTime.now(ZoneOffset.UTC),
|
||||
ZonedDateTime.now(ZoneOffset.UTC));
|
||||
Wid wid = new Wid("_record", ZonedDateTime.now(ZoneOffset.UTC));
|
||||
TriggeredWatch triggeredWatch = new TriggeredWatch(wid, event);
|
||||
XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
|
||||
triggeredWatch.toXContent(jsonBuilder, ToXContent.EMPTY_PARAMS);
|
||||
|
|
@ -413,7 +413,7 @@ public class TriggeredWatchStoreTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testPutTriggeredWatches() throws Exception {
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
int numberOfTriggeredWatches = randomIntBetween(1, 100);
|
||||
|
||||
List<TriggeredWatch> triggeredWatches = new ArrayList<>(numberOfTriggeredWatches);
|
||||
|
|
@ -445,7 +445,7 @@ public class TriggeredWatchStoreTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testDeleteTriggeredWatches() throws Exception {
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
|
||||
doAnswer(invocation -> {
|
||||
BulkRequest bulkRequest = (BulkRequest) invocation.getArguments()[0];
|
||||
|
|
|
|||
|
|
@ -37,10 +37,13 @@ import org.elasticsearch.xpack.watcher.common.http.HttpResponse;
|
|||
import org.elasticsearch.xpack.watcher.notification.jira.JiraAccount;
|
||||
import org.elasticsearch.xpack.watcher.notification.jira.JiraIssue;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.Before;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
|
||||
import static java.util.Collections.emptyMap;
|
||||
import static java.util.Collections.singletonMap;
|
||||
import static org.elasticsearch.xpack.core.watcher.history.HistoryStoreField.getHistoryIndexNameForTime;
|
||||
|
|
@ -50,7 +53,6 @@ import static org.hamcrest.Matchers.hasSize;
|
|||
import static org.hamcrest.Matchers.instanceOf;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.core.IsEqual.equalTo;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Mockito.doAnswer;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
|
@ -76,7 +78,7 @@ public class HistoryStoreTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testPut() throws Exception {
|
||||
DateTime now = new DateTime(0, UTC);
|
||||
ZonedDateTime now = Instant.ofEpochMilli(0).atZone(ZoneOffset.UTC);
|
||||
Wid wid = new Wid("_name", now);
|
||||
String index = getHistoryIndexNameForTime(now);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent(wid.watchId(), now, now);
|
||||
|
|
@ -104,13 +106,13 @@ public class HistoryStoreTests extends ESTestCase {
|
|||
|
||||
public void testIndexNameGeneration() {
|
||||
String indexTemplateVersion = INDEX_TEMPLATE_VERSION;
|
||||
assertThat(getHistoryIndexNameForTime(new DateTime(0, UTC)),
|
||||
assertThat(getHistoryIndexNameForTime(Instant.ofEpochMilli((long) 0).atZone(ZoneOffset.UTC)),
|
||||
equalTo(".watcher-history-"+ indexTemplateVersion +"-1970.01.01"));
|
||||
assertThat(getHistoryIndexNameForTime(new DateTime(100000000000L, UTC)),
|
||||
assertThat(getHistoryIndexNameForTime(Instant.ofEpochMilli(100000000000L).atZone(ZoneOffset.UTC)),
|
||||
equalTo(".watcher-history-" + indexTemplateVersion + "-1973.03.03"));
|
||||
assertThat(getHistoryIndexNameForTime(new DateTime(1416582852000L, UTC)),
|
||||
assertThat(getHistoryIndexNameForTime(Instant.ofEpochMilli(1416582852000L).atZone(ZoneOffset.UTC)),
|
||||
equalTo(".watcher-history-" + indexTemplateVersion + "-2014.11.21"));
|
||||
assertThat(getHistoryIndexNameForTime(new DateTime(2833165811000L, UTC)),
|
||||
assertThat(getHistoryIndexNameForTime(Instant.ofEpochMilli(2833165811000L).atZone(ZoneOffset.UTC)),
|
||||
equalTo(".watcher-history-" + indexTemplateVersion + "-2059.10.12"));
|
||||
}
|
||||
|
||||
|
|
@ -132,7 +134,7 @@ public class HistoryStoreTests extends ESTestCase {
|
|||
JiraIssue jiraIssue = account.createIssue(singletonMap("foo", "bar"), null);
|
||||
ActionWrapperResult result = new ActionWrapperResult(JiraAction.TYPE, new JiraAction.Executed(jiraIssue));
|
||||
|
||||
DateTime now = new DateTime(0, UTC);
|
||||
ZonedDateTime now = Instant.ofEpochMilli((long) 0).atZone(ZoneOffset.UTC);
|
||||
Wid wid = new Wid("_name", now);
|
||||
|
||||
Watch watch = mock(Watch.class);
|
||||
|
|
|
|||
|
|
@ -15,10 +15,10 @@ import org.elasticsearch.xpack.core.watcher.input.ExecutableInput;
|
|||
import org.elasticsearch.xpack.core.watcher.input.Input;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.input.simple.SimpleInput;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.elasticsearch.xpack.core.watcher.input.Input.Result.Status;
|
||||
|
|
@ -62,7 +62,7 @@ public class ExecutableChainInputTests extends ESTestCase {
|
|||
}
|
||||
|
||||
private WatchExecutionContext createWatchExecutionContext() {
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
return mockExecutionContextBuilder(wid.watchId())
|
||||
.wid(wid)
|
||||
|
|
|
|||
|
|
@ -24,10 +24,10 @@ import org.elasticsearch.xpack.watcher.condition.InternalAlwaysCondition;
|
|||
import org.elasticsearch.xpack.watcher.notification.email.support.EmailServer;
|
||||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.After;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
|
@ -135,7 +135,7 @@ public class EmailSecretsIntegrationTests extends AbstractWatcherIntegrationTest
|
|||
latch.countDown();
|
||||
});
|
||||
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(new DateTime(DateTimeZone.UTC), new DateTime(DateTimeZone.UTC));
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
ExecuteWatchResponse executeResponse = watcherClient.prepareExecuteWatch("_id")
|
||||
.setRecordExecution(false)
|
||||
.setTriggerEvent(triggerEvent)
|
||||
|
|
|
|||
|
|
@ -10,9 +10,10 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
|
|||
import org.elasticsearch.common.xcontent.XContentFactory;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.elasticsearch.test.ESTestCase;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
|
@ -30,7 +31,7 @@ public class EmailTests extends ESTestCase {
|
|||
Email.AddressList possibleList = new Email.AddressList(addresses);
|
||||
Email.AddressList replyTo = randomFrom(possibleList, null);
|
||||
Email.Priority priority = randomFrom(Email.Priority.values());
|
||||
DateTime sentDate = new DateTime(randomInt(), DateTimeZone.UTC);
|
||||
ZonedDateTime sentDate = Instant.ofEpochMilli(randomInt()).atZone(ZoneOffset.UTC);
|
||||
Email.AddressList to = randomFrom(possibleList, null);
|
||||
Email.AddressList cc = randomFrom(possibleList, null);
|
||||
Email.AddressList bcc = randomFrom(possibleList, null);
|
||||
|
|
|
|||
|
|
@ -20,11 +20,11 @@ import org.elasticsearch.xpack.watcher.common.http.HttpRequest;
|
|||
import org.elasticsearch.xpack.watcher.common.http.HttpRequestTemplate;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpResponse;
|
||||
import org.elasticsearch.xpack.watcher.test.MockTextTemplateEngine;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
|
@ -137,7 +137,7 @@ public class HttpEmailAttachementParserTests extends ESTestCase {
|
|||
}
|
||||
|
||||
private WatchExecutionContext createWatchExecutionContext() {
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid(randomAlphaOfLength(5), now);
|
||||
Map<String, Object> metadata = MapBuilder.<String, Object>newMapBuilder().put("_key", "_val").map();
|
||||
return mockExecutionContextBuilder("watch1")
|
||||
|
|
|
|||
|
|
@ -18,23 +18,23 @@ import org.elasticsearch.xpack.core.watcher.execution.WatchExecutionContext;
|
|||
import org.elasticsearch.xpack.core.watcher.execution.Wid;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.WatcherParams;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
||||
import org.elasticsearch.xpack.watcher.common.http.BasicAuth;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpClient;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpMethod;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpProxy;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpRequest;
|
||||
import org.elasticsearch.xpack.watcher.common.http.HttpResponse;
|
||||
import org.elasticsearch.xpack.watcher.common.http.BasicAuth;
|
||||
import org.elasticsearch.xpack.watcher.common.text.TextTemplate;
|
||||
import org.elasticsearch.xpack.watcher.common.text.TextTemplateEngine;
|
||||
import org.elasticsearch.xpack.watcher.notification.email.Attachment;
|
||||
import org.elasticsearch.xpack.watcher.test.MockTextTemplateEngine;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
|
@ -406,7 +406,7 @@ public class ReportingAttachmentParserTests extends ESTestCase {
|
|||
}
|
||||
|
||||
private WatchExecutionContext createWatchExecutionContext() {
|
||||
DateTime now = DateTime.now(DateTimeZone.UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
return mockExecutionContextBuilder("watch1")
|
||||
.wid(new Wid(randomAlphaOfLength(5), now))
|
||||
.payload(new Payload.Simple())
|
||||
|
|
|
|||
|
|
@ -15,23 +15,21 @@ import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
|||
import org.elasticsearch.xpack.watcher.test.WatcherTestUtils;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.hamcrest.Matchers;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Map;
|
||||
|
||||
import static java.util.Collections.singletonMap;
|
||||
import static org.hamcrest.Matchers.instanceOf;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.notNullValue;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class VariablesTests extends ESTestCase {
|
||||
public void testCreateCtxModel() throws Exception {
|
||||
DateTime scheduledTime = DateTime.now(UTC);
|
||||
DateTime triggeredTime = scheduledTime.plusMillis(50);
|
||||
DateTime executionTime = triggeredTime.plusMillis(50);
|
||||
ZonedDateTime scheduledTime = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
ZonedDateTime triggeredTime = scheduledTime.toInstant().plusMillis(50).atZone(ZoneOffset.UTC);
|
||||
ZonedDateTime executionTime = triggeredTime.toInstant().plusMillis(50).atZone(ZoneOffset.UTC);
|
||||
Payload payload = new Payload.Simple(singletonMap("payload_key", "payload_value"));
|
||||
Map<String, Object> metatdata = singletonMap("metadata_key", "metadata_value");
|
||||
TriggerEvent event = new ScheduleTriggerEvent("_watch_id", triggeredTime, scheduledTime);
|
||||
|
|
@ -49,7 +47,7 @@ public class VariablesTests extends ESTestCase {
|
|||
assertThat(model.size(), is(1));
|
||||
|
||||
JodaCompatibleZonedDateTime jodaJavaExecutionTime =
|
||||
new JodaCompatibleZonedDateTime(Instant.ofEpochMilli(executionTime.getMillis()), ZoneOffset.UTC);
|
||||
new JodaCompatibleZonedDateTime(executionTime.toInstant(), ZoneOffset.UTC);
|
||||
assertThat(ObjectPath.eval("ctx", model), instanceOf(Map.class));
|
||||
assertThat(ObjectPath.eval("ctx.id", model), is(wid.value()));
|
||||
// NOTE: we use toString() here because two ZonedDateTime are *not* equal, we need to check with isEqual
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@ import org.elasticsearch.search.builder.SearchSourceBuilder;
|
|||
import org.elasticsearch.test.ESTestCase;
|
||||
import org.elasticsearch.xpack.core.watcher.support.WatcherUtils;
|
||||
import org.elasticsearch.xpack.watcher.support.search.WatcherSearchTemplateRequest;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.Locale;
|
||||
|
|
@ -46,7 +46,7 @@ import static org.hamcrest.Matchers.nullValue;
|
|||
|
||||
public class WatcherUtilsTests extends ESTestCase {
|
||||
public void testFlattenModel() throws Exception {
|
||||
DateTime now = new DateTime(Clock.systemUTC().millis());
|
||||
ZonedDateTime now = ZonedDateTime.now(Clock.systemUTC());
|
||||
Map<String, Object> map = new HashMap<>();
|
||||
map.put("a", singletonMap("a1", new int[] { 0, 1, 2 }));
|
||||
map.put("b", new String[] { "b0", "b1", "b2" });
|
||||
|
|
|
|||
|
|
@ -58,12 +58,12 @@ import org.elasticsearch.xpack.watcher.notification.email.Profile;
|
|||
import org.elasticsearch.xpack.watcher.trigger.ScheduleTriggerEngineMock;
|
||||
import org.elasticsearch.xpack.watcher.watch.WatchParser;
|
||||
import org.hamcrest.Matcher;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
|
|
@ -252,7 +252,7 @@ public abstract class AbstractWatcherIntegrationTestCase extends ESIntegTestCase
|
|||
assertAcked(client().admin().indices().prepareCreate(triggeredWatchIndexName));
|
||||
}
|
||||
|
||||
String historyIndex = HistoryStoreField.getHistoryIndexNameForTime(DateTime.now(DateTimeZone.UTC));
|
||||
String historyIndex = HistoryStoreField.getHistoryIndexNameForTime(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
assertAcked(client().admin().indices().prepareCreate(historyIndex));
|
||||
logger.info("creating watch history index [{}]", historyIndex);
|
||||
ensureGreen(historyIndex, watchIndexName, triggeredWatchIndexName);
|
||||
|
|
|
|||
|
|
@ -13,12 +13,12 @@ import org.elasticsearch.xpack.core.watcher.watch.Payload;
|
|||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ public class WatchExecutionContextMockBuilder {
|
|||
when(ctx.watch()).thenReturn(watch);
|
||||
payload(Collections.<String, Object>emptyMap());
|
||||
metadata(Collections.<String, Object>emptyMap());
|
||||
time(watchId, DateTime.now(UTC));
|
||||
time(watchId, ZonedDateTime.now(ZoneOffset.UTC));
|
||||
}
|
||||
|
||||
public WatchExecutionContextMockBuilder wid(Wid wid) {
|
||||
|
|
@ -58,11 +58,11 @@ public class WatchExecutionContextMockBuilder {
|
|||
return this;
|
||||
}
|
||||
|
||||
public WatchExecutionContextMockBuilder time(String watchId, DateTime time) {
|
||||
public WatchExecutionContextMockBuilder time(String watchId, ZonedDateTime time) {
|
||||
return executionTime(time).triggerEvent(new ScheduleTriggerEvent(watchId, time, time));
|
||||
}
|
||||
|
||||
public WatchExecutionContextMockBuilder executionTime(DateTime time) {
|
||||
public WatchExecutionContextMockBuilder executionTime(ZonedDateTime time) {
|
||||
when(ctx.executionTime()).thenReturn(time);
|
||||
return this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,10 +52,12 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.CronSchedule;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.IntervalSchedule;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTrigger;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import javax.mail.internet.AddressException;
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
|
@ -67,7 +69,6 @@ import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
|||
import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
|
||||
import static org.elasticsearch.search.builder.SearchSourceBuilder.searchSource;
|
||||
import static org.elasticsearch.test.ESTestCase.randomFrom;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public final class WatcherTestUtils {
|
||||
|
||||
|
|
@ -97,27 +98,28 @@ public final class WatcherTestUtils {
|
|||
|
||||
public static WatchExecutionContextMockBuilder mockExecutionContextBuilder(String watchId) {
|
||||
return new WatchExecutionContextMockBuilder(watchId)
|
||||
.wid(new Wid(watchId, DateTime.now(UTC)));
|
||||
.wid(new Wid(watchId, ZonedDateTime.now(ZoneOffset.UTC)));
|
||||
}
|
||||
|
||||
public static WatchExecutionContext mockExecutionContext(String watchId, Payload payload) {
|
||||
return mockExecutionContextBuilder(watchId)
|
||||
.wid(new Wid(watchId, DateTime.now(UTC)))
|
||||
.wid(new Wid(watchId, ZonedDateTime.now(ZoneOffset.UTC)))
|
||||
.payload(payload)
|
||||
.buildMock();
|
||||
}
|
||||
|
||||
public static WatchExecutionContext mockExecutionContext(String watchId, DateTime time, Payload payload) {
|
||||
public static WatchExecutionContext mockExecutionContext(String watchId, ZonedDateTime time, Payload payload) {
|
||||
return mockExecutionContextBuilder(watchId)
|
||||
.wid(new Wid(watchId, DateTime.now(UTC)))
|
||||
.wid(new Wid(watchId, ZonedDateTime.now(ZoneOffset.UTC)))
|
||||
.payload(payload)
|
||||
.time(watchId, time)
|
||||
.buildMock();
|
||||
}
|
||||
|
||||
public static WatchExecutionContext mockExecutionContext(String watchId, DateTime executionTime, TriggerEvent event, Payload payload) {
|
||||
public static WatchExecutionContext mockExecutionContext(String watchId, ZonedDateTime executionTime, TriggerEvent event,
|
||||
Payload payload) {
|
||||
return mockExecutionContextBuilder(watchId)
|
||||
.wid(new Wid(watchId, DateTime.now(UTC)))
|
||||
.wid(new Wid(watchId, ZonedDateTime.now(ZoneOffset.UTC)))
|
||||
.payload(payload)
|
||||
.executionTime(executionTime)
|
||||
.triggerEvent(event)
|
||||
|
|
@ -125,6 +127,7 @@ public final class WatcherTestUtils {
|
|||
}
|
||||
|
||||
public static WatchExecutionContext createWatchExecutionContext() throws Exception {
|
||||
ZonedDateTime EPOCH_UTC = Instant.EPOCH.atZone(ZoneOffset.UTC);
|
||||
Watch watch = new Watch("test-watch",
|
||||
new ScheduleTrigger(new IntervalSchedule(new IntervalSchedule.Interval(1, IntervalSchedule.Interval.Unit.MINUTES))),
|
||||
new ExecutableSimpleInput(new SimpleInput(new Payload.Simple())),
|
||||
|
|
@ -133,11 +136,10 @@ public final class WatcherTestUtils {
|
|||
null,
|
||||
new ArrayList<>(),
|
||||
null,
|
||||
new WatchStatus(new DateTime(0, UTC), emptyMap()), 1L, 1L);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(),
|
||||
new DateTime(0, UTC),
|
||||
new ScheduleTriggerEvent(watch.id(), new DateTime(0, UTC), new DateTime(0, UTC)),
|
||||
TimeValue.timeValueSeconds(5));
|
||||
|
||||
new WatchStatus(EPOCH_UTC, emptyMap()), 1L, 1L);
|
||||
TriggeredExecutionContext context = new TriggeredExecutionContext(watch.id(), EPOCH_UTC,
|
||||
new ScheduleTriggerEvent(watch.id(), EPOCH_UTC, EPOCH_UTC), TimeValue.timeValueSeconds(5));
|
||||
context.ensureWatchExists(() -> watch);
|
||||
return context;
|
||||
}
|
||||
|
|
@ -163,7 +165,7 @@ public final class WatcherTestUtils {
|
|||
new HtmlSanitizer(Settings.EMPTY), Collections.emptyMap());
|
||||
actions.add(new ActionWrapper("_email", null, null, null, executale));
|
||||
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Map<String, ActionStatus> statuses = new HashMap<>();
|
||||
statuses.put("_webhook", new ActionStatus(now));
|
||||
statuses.put("_email", new ActionStatus(now));
|
||||
|
|
|
|||
|
|
@ -77,8 +77,8 @@ public class ScheduleEngineTriggerBenchmark {
|
|||
if (running.get()) {
|
||||
for (TriggerEvent event : events) {
|
||||
ScheduleTriggerEvent scheduleTriggerEvent = (ScheduleTriggerEvent) event;
|
||||
measure(total, triggerMetric, tooEarlyMetric, event.triggeredTime().getMillis(),
|
||||
scheduleTriggerEvent.scheduledTime().getMillis());
|
||||
measure(total, triggerMetric, tooEarlyMetric, event.triggeredTime().toInstant().toEpochMilli(),
|
||||
scheduleTriggerEvent.scheduledTime().toInstant().toEpochMilli());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ import org.elasticsearch.action.search.SearchType;
|
|||
import org.elasticsearch.common.bytes.BytesReference;
|
||||
import org.elasticsearch.common.xcontent.XContentBuilder;
|
||||
import org.elasticsearch.common.xcontent.XContentType;
|
||||
import org.elasticsearch.protocol.xpack.watcher.DeleteWatchResponse;
|
||||
import org.elasticsearch.protocol.xpack.watcher.PutWatchResponse;
|
||||
import org.elasticsearch.script.Script;
|
||||
import org.elasticsearch.script.ScriptType;
|
||||
|
|
@ -19,7 +20,6 @@ import org.elasticsearch.test.junit.annotations.TestLogging;
|
|||
import org.elasticsearch.xpack.core.watcher.client.WatchSourceBuilder;
|
||||
import org.elasticsearch.xpack.core.watcher.client.WatcherClient;
|
||||
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;
|
||||
import org.elasticsearch.protocol.xpack.watcher.DeleteWatchResponse;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.get.GetWatchResponse;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.Watch;
|
||||
import org.elasticsearch.xpack.watcher.condition.CompareCondition;
|
||||
|
|
@ -30,9 +30,9 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.IntervalSchedule;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.Schedules;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.MonthTimes;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.WeekTimes;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
|
||||
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
|
||||
|
|
@ -340,7 +340,7 @@ public class BasicWatcherTests extends AbstractWatcherIntegrationTestCase {
|
|||
|
||||
private void testConditionSearch(WatcherSearchTemplateRequest request) throws Exception {
|
||||
// reset, so we don't miss event docs when we filter over the _timestamp field.
|
||||
timeWarp().clock().setTime(new DateTime(Clock.systemUTC().millis()));
|
||||
timeWarp().clock().setTime(ZonedDateTime.now(Clock.systemUTC()));
|
||||
|
||||
String watchName = "_name";
|
||||
assertAcked(prepareCreate("events").addMapping("event", "level", "type=text"));
|
||||
|
|
@ -352,7 +352,7 @@ public class BasicWatcherTests extends AbstractWatcherIntegrationTestCase {
|
|||
.condition(new CompareCondition("ctx.payload.hits.total", CompareCondition.Op.GTE, 3L)))
|
||||
.get();
|
||||
|
||||
logger.info("created watch [{}] at [{}]", watchName, new DateTime(Clock.systemUTC().millis()));
|
||||
logger.info("created watch [{}] at [{}]", watchName, ZonedDateTime.now(Clock.systemUTC()));
|
||||
|
||||
client().prepareIndex("events", "event")
|
||||
.setSource("level", "a")
|
||||
|
|
|
|||
|
|
@ -29,9 +29,10 @@ import org.elasticsearch.xpack.watcher.support.search.WatcherSearchTemplateReque
|
|||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.hamcrest.Matchers;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
|
@ -52,7 +53,6 @@ import static org.elasticsearch.xpack.watcher.trigger.schedule.Schedules.cron;
|
|||
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.core.IsEqual.equalTo;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class BootStrapTests extends AbstractWatcherIntegrationTestCase {
|
||||
|
||||
|
|
@ -75,7 +75,7 @@ public class BootStrapTests extends AbstractWatcherIntegrationTestCase {
|
|||
.get();
|
||||
|
||||
// valid watch record:
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
Wid wid = new Wid("_id", now);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent("_id", now, now);
|
||||
ExecutableCondition condition = InternalAlwaysCondition.INSTANCE;
|
||||
|
|
@ -198,7 +198,7 @@ public class BootStrapTests extends AbstractWatcherIntegrationTestCase {
|
|||
|
||||
stopWatcher();
|
||||
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
final int numRecords = scaledRandomIntBetween(numWatches, 128);
|
||||
BulkRequestBuilder bulkRequestBuilder = client().prepareBulk();
|
||||
for (int i = 0; i < numRecords; i++) {
|
||||
|
|
@ -244,7 +244,7 @@ public class BootStrapTests extends AbstractWatcherIntegrationTestCase {
|
|||
|
||||
stopWatcher();
|
||||
|
||||
DateTime now = DateTime.now(UTC);
|
||||
ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
|
||||
final int numRecords = scaledRandomIntBetween(2, 12);
|
||||
BulkRequestBuilder bulkRequestBuilder = client().prepareBulk();
|
||||
for (int i = 0; i < numRecords; i++) {
|
||||
|
|
@ -310,7 +310,8 @@ public class BootStrapTests extends AbstractWatcherIntegrationTestCase {
|
|||
// we rarely create an .watches alias in the base class
|
||||
assertAcked(client().admin().indices().prepareCreate(Watch.INDEX));
|
||||
}
|
||||
DateTime triggeredTime = new DateTime(2015, 11, 5, 0, 0, 0, 0, DateTimeZone.UTC);
|
||||
LocalDateTime localDateTime = LocalDateTime.of(2015, 11, 5, 0, 0, 0, 0);
|
||||
ZonedDateTime triggeredTime = ZonedDateTime.of(localDateTime,ZoneOffset.UTC);
|
||||
final String watchRecordIndex = HistoryStoreField.getHistoryIndexNameForTime(triggeredTime);
|
||||
|
||||
logger.info("Stopping watcher");
|
||||
|
|
|
|||
|
|
@ -27,11 +27,12 @@ import org.elasticsearch.xpack.watcher.common.http.HttpRequestTemplate;
|
|||
import org.elasticsearch.xpack.watcher.condition.InternalAlwaysCondition;
|
||||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Base64;
|
||||
import java.util.Map;
|
||||
|
||||
|
|
@ -49,7 +50,6 @@ import static org.hamcrest.Matchers.is;
|
|||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.Matchers.notNullValue;
|
||||
import static org.hamcrest.Matchers.startsWith;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class HttpSecretsIntegrationTests extends AbstractWatcherIntegrationTestCase {
|
||||
|
||||
|
|
@ -141,7 +141,7 @@ public class HttpSecretsIntegrationTests extends AbstractWatcherIntegrationTestC
|
|||
webServer.enqueue(new MockResponse().setResponseCode(200).setBody(
|
||||
BytesReference.bytes(jsonBuilder().startObject().field("key", "value").endObject()).utf8ToString()));
|
||||
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(new DateTime(UTC), new DateTime(UTC));
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
ExecuteWatchResponse executeResponse = watcherClient.prepareExecuteWatch("_id")
|
||||
.setRecordExecution(false)
|
||||
.setTriggerEvent(triggerEvent)
|
||||
|
|
@ -221,7 +221,7 @@ public class HttpSecretsIntegrationTests extends AbstractWatcherIntegrationTestC
|
|||
webServer.enqueue(new MockResponse().setResponseCode(200).setBody(
|
||||
BytesReference.bytes(jsonBuilder().startObject().field("key", "value").endObject()).utf8ToString()));
|
||||
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(new DateTime(UTC), new DateTime(UTC));
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
ExecuteWatchResponse executeResponse = watcherClient.prepareExecuteWatch("_id")
|
||||
.setRecordExecution(false)
|
||||
.setActionMode("_all", ActionExecutionMode.FORCE_EXECUTE)
|
||||
|
|
|
|||
|
|
@ -7,9 +7,9 @@ package org.elasticsearch.xpack.watcher.test.integration;
|
|||
|
||||
import org.elasticsearch.action.search.SearchResponse;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.xpack.core.watcher.execution.ActionExecutionMode;
|
||||
import org.elasticsearch.xpack.core.watcher.history.HistoryStoreField;
|
||||
import org.elasticsearch.common.xcontent.ObjectPath;
|
||||
import org.elasticsearch.xpack.core.watcher.transport.actions.execute.ExecuteWatchResponse;
|
||||
import org.elasticsearch.xpack.core.watcher.trigger.TriggerEvent;
|
||||
import org.elasticsearch.xpack.watcher.actions.logging.LoggingAction;
|
||||
|
|
@ -19,8 +19,9 @@ import org.elasticsearch.xpack.watcher.condition.CompareCondition;
|
|||
import org.elasticsearch.xpack.watcher.condition.InternalAlwaysCondition;
|
||||
import org.elasticsearch.xpack.watcher.test.AbstractWatcherIntegrationTestCase;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
|
@ -34,7 +35,6 @@ import static org.elasticsearch.xpack.watcher.trigger.TriggerBuilders.schedule;
|
|||
import static org.elasticsearch.xpack.watcher.trigger.schedule.Schedules.cron;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.greaterThan;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class WatchMetadataTests extends AbstractWatcherIntegrationTestCase {
|
||||
|
||||
|
|
@ -84,7 +84,7 @@ public class WatchMetadataTests extends AbstractWatcherIntegrationTestCase {
|
|||
.metadata(metadata))
|
||||
.get();
|
||||
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(new DateTime(UTC), new DateTime(UTC));
|
||||
TriggerEvent triggerEvent = new ScheduleTriggerEvent(ZonedDateTime.now(ZoneOffset.UTC), ZonedDateTime.now(ZoneOffset.UTC));
|
||||
ExecuteWatchResponse executeWatchResponse = watcherClient().prepareExecuteWatch("_name")
|
||||
.setTriggerEvent(triggerEvent).setActionMode("_all", ActionExecutionMode.SIMULATE).get();
|
||||
Map<String, Object> result = executeWatchResponse.getRecordSource().getAsMap();
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@
|
|||
*/
|
||||
package org.elasticsearch.xpack.watcher.trigger;
|
||||
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.elasticsearch.common.unit.TimeValue;
|
||||
import org.elasticsearch.common.xcontent.XContentParser;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.ClockMock;
|
||||
|
|
@ -15,10 +15,10 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleRegistry;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTrigger;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEngine;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTriggerEvent;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
|
@ -84,7 +84,7 @@ public class ScheduleTriggerEngineMock extends ScheduleTriggerEngine {
|
|||
}
|
||||
|
||||
for (int i = 0; i < times; i++) {
|
||||
DateTime now = new DateTime(clock.millis());
|
||||
ZonedDateTime now = ZonedDateTime.now(clock);
|
||||
logger.debug("firing watch [{}] at [{}]", jobName, now);
|
||||
ScheduleTriggerEvent event = new ScheduleTriggerEvent(jobName, now, now);
|
||||
consumers.forEach(consumer -> consumer.accept(Collections.singletonList(event)));
|
||||
|
|
|
|||
|
|
@ -12,6 +12,8 @@ import org.elasticsearch.common.xcontent.XContentParser;
|
|||
import org.elasticsearch.test.ESTestCase;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
|
||||
import static org.hamcrest.Matchers.is;
|
||||
|
||||
|
|
@ -29,7 +31,7 @@ public class ScheduleTriggerEventTests extends ESTestCase {
|
|||
parser.nextToken();
|
||||
|
||||
ScheduleTriggerEvent scheduleTriggerEvent = ScheduleTriggerEvent.parse(parser, "_id", "_context", Clock.systemUTC());
|
||||
assertThat(scheduleTriggerEvent.scheduledTime().isAfter(0), is(true));
|
||||
assertThat(scheduleTriggerEvent.triggeredTime().isAfter(0), is(true));
|
||||
assertThat(scheduleTriggerEvent.scheduledTime().isAfter(Instant.ofEpochMilli(0).atZone(ZoneOffset.UTC)), is(true));
|
||||
assertThat(scheduleTriggerEvent.triggeredTime().isAfter(Instant.ofEpochMilli(0).atZone(ZoneOffset.UTC)), is(true));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,10 +18,12 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleRegistry;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.ScheduleTrigger;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.DayOfWeek;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.WeekTimes;
|
||||
import org.joda.time.DateTime;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.temporal.ChronoField;
|
||||
import java.util.ArrayList;
|
||||
import java.util.BitSet;
|
||||
import java.util.Collections;
|
||||
|
|
@ -36,7 +38,6 @@ import static org.elasticsearch.xpack.watcher.trigger.schedule.Schedules.interva
|
|||
import static org.elasticsearch.xpack.watcher.trigger.schedule.Schedules.weekly;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
public class TickerScheduleEngineTests extends ESTestCase {
|
||||
|
|
@ -58,7 +59,7 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
return new TickerScheduleTriggerEngine(settings, mock(ScheduleRegistry.class), clock);
|
||||
}
|
||||
|
||||
private void advanceClockIfNeeded(DateTime newCurrentDateTime) {
|
||||
private void advanceClockIfNeeded(ZonedDateTime newCurrentDateTime) {
|
||||
clock.setTime(newCurrentDateTime);
|
||||
}
|
||||
|
||||
|
|
@ -95,12 +96,12 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
});
|
||||
|
||||
engine.start(watches);
|
||||
advanceClockIfNeeded(new DateTime(clock.millis(), UTC).plusMillis(1100));
|
||||
advanceClockIfNeeded(clock.instant().plusMillis(1100).atZone(ZoneOffset.UTC));
|
||||
if (!firstLatch.await(3 * count, TimeUnit.SECONDS)) {
|
||||
fail("waiting too long for all watches to be triggered");
|
||||
}
|
||||
|
||||
advanceClockIfNeeded(new DateTime(clock.millis(), UTC).plusMillis(1100));
|
||||
advanceClockIfNeeded(clock.instant().plusMillis(1100).atZone(ZoneOffset.UTC));
|
||||
if (!secondLatch.await(3 * count, TimeUnit.SECONDS)) {
|
||||
fail("waiting too long for all watches to be triggered");
|
||||
}
|
||||
|
|
@ -124,15 +125,17 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
});
|
||||
|
||||
int randomMinute = randomIntBetween(0, 59);
|
||||
DateTime testNowTime = new DateTime(clock.millis(), UTC).withMinuteOfHour(randomMinute)
|
||||
.withSecondOfMinute(59);
|
||||
DateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
ZonedDateTime testNowTime = clock.instant().atZone(ZoneOffset.UTC)
|
||||
.with(ChronoField.MINUTE_OF_HOUR, randomMinute)
|
||||
.with(ChronoField.SECOND_OF_MINUTE, 59);
|
||||
|
||||
ZonedDateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
logger.info("Setting current time to [{}], job execution time [{}]", testNowTime,
|
||||
scheduledTime);
|
||||
|
||||
clock.setTime(testNowTime);
|
||||
engine.add(createWatch(name, daily().at(scheduledTime.getHourOfDay(),
|
||||
scheduledTime.getMinuteOfHour()).build()));
|
||||
engine.add(createWatch(name, daily().at(scheduledTime.getHour(),
|
||||
scheduledTime.getMinute()).build()));
|
||||
advanceClockIfNeeded(scheduledTime);
|
||||
|
||||
if (!latch.await(5, TimeUnit.SECONDS)) {
|
||||
|
|
@ -150,7 +153,7 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
public void accept(Iterable<TriggerEvent> events) {
|
||||
for (TriggerEvent event : events) {
|
||||
assertThat(event.jobName(), is(name));
|
||||
logger.info("triggered job on [{}]", new DateTime(clock.millis(), UTC));
|
||||
logger.info("triggered job on [{}]", clock.instant().atZone(ZoneOffset.UTC));
|
||||
latch.countDown();
|
||||
}
|
||||
}
|
||||
|
|
@ -159,15 +162,17 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
int randomHour = randomIntBetween(0, 23);
|
||||
int randomMinute = randomIntBetween(0, 59);
|
||||
|
||||
DateTime testNowTime = new DateTime(clock.millis(), UTC).withHourOfDay(randomHour)
|
||||
.withMinuteOfHour(randomMinute).withSecondOfMinute(59);
|
||||
DateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
ZonedDateTime testNowTime = clock.instant().atZone(ZoneOffset.UTC)
|
||||
.with(ChronoField.HOUR_OF_DAY, randomHour).with(ChronoField.MINUTE_OF_HOUR, randomMinute)
|
||||
.with(ChronoField.SECOND_OF_MINUTE, 59);
|
||||
|
||||
ZonedDateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
logger.info("Setting current time to [{}], job execution time [{}]", testNowTime,
|
||||
scheduledTime);
|
||||
|
||||
clock.setTime(testNowTime);
|
||||
engine.add(createWatch(name, daily().at(scheduledTime.getHourOfDay(),
|
||||
scheduledTime.getMinuteOfHour()).build()));
|
||||
engine.add(createWatch(name, daily().at(scheduledTime.getHour(),
|
||||
scheduledTime.getMinute()).build()));
|
||||
advanceClockIfNeeded(scheduledTime);
|
||||
|
||||
if (!latch.await(5, TimeUnit.SECONDS)) {
|
||||
|
|
@ -194,9 +199,13 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
int randomMinute = randomIntBetween(0, 59);
|
||||
int randomDay = randomIntBetween(1, 7);
|
||||
|
||||
DateTime testNowTime = new DateTime(clock.millis(), UTC).withDayOfWeek(randomDay)
|
||||
.withHourOfDay(randomHour).withMinuteOfHour(randomMinute).withSecondOfMinute(59);
|
||||
DateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
ZonedDateTime testNowTime = clock.instant().atZone(ZoneOffset.UTC)
|
||||
.with(ChronoField.DAY_OF_WEEK, randomDay)
|
||||
.with(ChronoField.HOUR_OF_DAY, randomHour)
|
||||
.with(ChronoField.MINUTE_OF_HOUR, randomMinute)
|
||||
.with(ChronoField.SECOND_OF_MINUTE, 59);
|
||||
|
||||
ZonedDateTime scheduledTime = testNowTime.plusSeconds(2);
|
||||
|
||||
logger.info("Setting current time to [{}], job execution time [{}]", testNowTime,
|
||||
scheduledTime);
|
||||
|
|
@ -204,10 +213,10 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
|
||||
// fun part here (aka WTF): DayOfWeek with Joda is MON-SUN, starting at 1
|
||||
// DayOfWeek with Watcher is SUN-SAT, starting at 1
|
||||
int watcherDay = (scheduledTime.getDayOfWeek() % 7) + 1;
|
||||
int watcherDay = (scheduledTime.getDayOfWeek().getValue() % 7) + 1;
|
||||
engine.add(createWatch(name, weekly().time(WeekTimes.builder()
|
||||
.on(DayOfWeek.resolve(watcherDay))
|
||||
.at(scheduledTime.getHourOfDay(), scheduledTime.getMinuteOfHour()).build())
|
||||
.at(scheduledTime.getHour(), scheduledTime.getMinute()).build())
|
||||
.build()));
|
||||
advanceClockIfNeeded(scheduledTime);
|
||||
|
||||
|
|
@ -240,12 +249,12 @@ public class TickerScheduleEngineTests extends ESTestCase {
|
|||
engine.add(createWatch("_id", interval("1s")));
|
||||
}
|
||||
|
||||
advanceClockIfNeeded(new DateTime(clock.millis(), UTC).plusMillis(1100));
|
||||
advanceClockIfNeeded(clock.instant().plusMillis(1100).atZone(ZoneOffset.UTC));
|
||||
if (!firstLatch.await(3, TimeUnit.SECONDS)) {
|
||||
fail("waiting too long for all watches to be triggered");
|
||||
}
|
||||
|
||||
advanceClockIfNeeded(new DateTime(clock.millis(), UTC).plusMillis(1100));
|
||||
advanceClockIfNeeded(clock.instant().plusMillis(1100).atZone(ZoneOffset.UTC));
|
||||
if (!secondLatch.await(3, TimeUnit.SECONDS)) {
|
||||
fail("waiting too long for all watches to be triggered");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,8 +7,9 @@ package org.elasticsearch.xpack.watcher.trigger.schedule.tool;
|
|||
|
||||
import org.elasticsearch.cli.Command;
|
||||
import org.elasticsearch.cli.CommandTestCase;
|
||||
import org.joda.time.DateTimeZone;
|
||||
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.Arrays;
|
||||
import java.util.Calendar;
|
||||
import java.util.Locale;
|
||||
|
|
@ -58,7 +59,7 @@ public class CronEvalToolTests extends CommandTestCase {
|
|||
@AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/35687")
|
||||
public void testEnsureDateIsShownInRootLocale() throws Exception {
|
||||
String output = execute("-c","1", "0 0 11 ? * MON-SAT 2040");
|
||||
if (TimeZone.getDefault().equals(DateTimeZone.UTC.toTimeZone())) {
|
||||
if (ZoneId.systemDefault().equals(ZoneOffset.UTC)) {
|
||||
assertThat(output, not(containsString("local time is")));
|
||||
long linesStartingWithOne = Arrays.stream(output.split("\n")).filter(s -> s.startsWith("\t")).count();
|
||||
assertThat(linesStartingWithOne, is(0L));
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@ import org.elasticsearch.xpack.core.watcher.watch.WatchStatus;
|
|||
import org.elasticsearch.xpack.watcher.actions.logging.LoggingAction;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
|
@ -28,27 +30,26 @@ import static org.hamcrest.Matchers.hasKey;
|
|||
import static org.hamcrest.Matchers.instanceOf;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.joda.time.DateTime.now;
|
||||
|
||||
public class WatchStatusTests extends ESTestCase {
|
||||
|
||||
public void testAckStatusIsResetOnUnmetCondition() {
|
||||
HashMap<String, ActionStatus> myMap = new HashMap<>();
|
||||
ActionStatus actionStatus = new ActionStatus(now());
|
||||
ActionStatus actionStatus = new ActionStatus(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
myMap.put("foo", actionStatus);
|
||||
|
||||
actionStatus.update(now(), new LoggingAction.Result.Success("foo"));
|
||||
actionStatus.onAck(now());
|
||||
actionStatus.update(ZonedDateTime.now(ZoneOffset.UTC), new LoggingAction.Result.Success("foo"));
|
||||
actionStatus.onAck(ZonedDateTime.now(ZoneOffset.UTC));
|
||||
assertThat(actionStatus.ackStatus().state(), is(State.ACKED));
|
||||
|
||||
WatchStatus status = new WatchStatus(now(), myMap);
|
||||
status.onCheck(false, now());
|
||||
WatchStatus status = new WatchStatus(ZonedDateTime.now(ZoneOffset.UTC), myMap);
|
||||
status.onCheck(false, ZonedDateTime.now(ZoneOffset.UTC));
|
||||
|
||||
assertThat(status.actionStatus("foo").ackStatus().state(), is(State.AWAITS_SUCCESSFUL_EXECUTION));
|
||||
}
|
||||
|
||||
public void testHeadersToXContent() throws Exception {
|
||||
WatchStatus status = new WatchStatus(now(), Collections.emptyMap());
|
||||
WatchStatus status = new WatchStatus(ZonedDateTime.now(ZoneOffset.UTC), Collections.emptyMap());
|
||||
String key = randomAlphaOfLength(10);
|
||||
String value = randomAlphaOfLength(10);
|
||||
Map<String, String> headers = Collections.singletonMap(key, value);
|
||||
|
|
@ -78,7 +79,7 @@ public class WatchStatusTests extends ESTestCase {
|
|||
}
|
||||
|
||||
public void testHeadersSerialization() throws IOException {
|
||||
WatchStatus status = new WatchStatus(now(), Collections.emptyMap());
|
||||
WatchStatus status = new WatchStatus(ZonedDateTime.now(ZoneOffset.UTC), Collections.emptyMap());
|
||||
String key = randomAlphaOfLength(10);
|
||||
String value = randomAlphaOfLength(10);
|
||||
Map<String, String> headers = Collections.singletonMap(key, value);
|
||||
|
|
|
|||
|
|
@ -114,14 +114,13 @@ import org.elasticsearch.xpack.watcher.trigger.schedule.support.Month;
|
|||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.MonthTimes;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.WeekTimes;
|
||||
import org.elasticsearch.xpack.watcher.trigger.schedule.support.YearTimes;
|
||||
import org.joda.time.DateTime;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.Before;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
|
|
@ -147,7 +146,6 @@ import static org.hamcrest.Matchers.instanceOf;
|
|||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.notNullValue;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
public class WatchTests extends ESTestCase {
|
||||
|
|
@ -178,7 +176,7 @@ public class WatchTests extends ESTestCase {
|
|||
|
||||
public void testParserSelfGenerated() throws Exception {
|
||||
Clock clock = Clock.fixed(Instant.now(), ZoneOffset.UTC);
|
||||
DateTime now = new DateTime(clock.millis(), UTC);
|
||||
ZonedDateTime now = clock.instant().atZone(ZoneOffset.UTC);
|
||||
TransformRegistry transformRegistry = transformRegistry();
|
||||
boolean includeStatus = randomBoolean();
|
||||
Schedule schedule = randomSchedule();
|
||||
|
|
@ -248,8 +246,10 @@ public class WatchTests extends ESTestCase {
|
|||
}
|
||||
};
|
||||
|
||||
DateTime now = new DateTime(UTC);
|
||||
Clock fixedClock = Clock.fixed(Instant.now(), ZoneOffset.UTC);
|
||||
|
||||
ClockMock clock = ClockMock.frozen();
|
||||
ZonedDateTime now = Instant.ofEpochMilli(fixedClock.millis()).atZone(ZoneOffset.UTC);
|
||||
clock.setTime(now);
|
||||
|
||||
List<ActionWrapper> actions = randomActions();
|
||||
|
|
@ -257,12 +257,12 @@ public class WatchTests extends ESTestCase {
|
|||
for (ActionWrapper action : actions) {
|
||||
actionsStatuses.put(action.id(), new ActionStatus(now));
|
||||
}
|
||||
WatchStatus watchStatus = new WatchStatus(new DateTime(clock.millis()), unmodifiableMap(actionsStatuses));
|
||||
WatchStatus watchStatus = new WatchStatus(clock.instant().atZone(ZoneOffset.UTC), unmodifiableMap(actionsStatuses));
|
||||
|
||||
WatchParser watchParser = new WatchParser(triggerService, actionRegistry, inputRegistry, null, clock);
|
||||
XContentBuilder builder = jsonBuilder().startObject().startObject("trigger").endObject().field("status", watchStatus).endObject();
|
||||
Watch watch = watchParser.parse("foo", true, BytesReference.bytes(builder), XContentType.JSON, 1L, 1L);
|
||||
assertThat(watch.status().state().getTimestamp().getMillis(), is(clock.millis()));
|
||||
assertThat(watch.status().state().getTimestamp().toInstant().toEpochMilli(), is(clock.millis()));
|
||||
for (ActionWrapper action : actions) {
|
||||
assertThat(watch.status().actionStatus(action.id()), is(actionsStatuses.get(action.id())));
|
||||
}
|
||||
|
|
@ -548,7 +548,7 @@ public class WatchTests extends ESTestCase {
|
|||
private ExecutableTransform randomTransform() {
|
||||
String type = randomFrom(ScriptTransform.TYPE, SearchTransform.TYPE, ChainTransform.TYPE);
|
||||
TimeValue timeout = randomBoolean() ? timeValueSeconds(between(1, 10000)) : null;
|
||||
DateTimeZone timeZone = randomBoolean() ? DateTimeZone.UTC : null;
|
||||
ZoneOffset timeZone = randomBoolean() ? ZoneOffset.UTC : null;
|
||||
switch (type) {
|
||||
case ScriptTransform.TYPE:
|
||||
return new ExecutableScriptTransform(new ScriptTransform(mockScript("_script")), logger, scriptService);
|
||||
|
|
@ -588,7 +588,7 @@ public class WatchTests extends ESTestCase {
|
|||
new ExecutableEmailAction(action, logger, emailService, templateEngine, htmlSanitizer, Collections.emptyMap())));
|
||||
}
|
||||
if (randomBoolean()) {
|
||||
DateTimeZone timeZone = randomBoolean() ? DateTimeZone.UTC : null;
|
||||
ZoneOffset timeZone = randomBoolean() ? ZoneOffset.UTC : null;
|
||||
TimeValue timeout = randomBoolean() ? timeValueSeconds(between(1, 10000)) : null;
|
||||
WriteRequest.RefreshPolicy refreshPolicy = randomBoolean() ? null : randomFrom(WriteRequest.RefreshPolicy.values());
|
||||
IndexAction action = new IndexAction("_index", null, randomBoolean() ? "123" : null, null, timeout, timeZone,
|
||||
|
|
|
|||
|
|
@ -7,20 +7,11 @@ package org.elasticsearch.xpack.watcher.watch.clock;
|
|||
|
||||
import org.elasticsearch.test.ESTestCase;
|
||||
import org.elasticsearch.xpack.core.watcher.watch.ClockMock;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import java.time.Clock;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.greaterThan;
|
||||
import static org.joda.time.DateTimeZone.UTC;
|
||||
|
||||
public class ClockTests extends ESTestCase {
|
||||
public void testNowUTC() {
|
||||
Clock clockMock = ClockMock.frozen();
|
||||
assertThat(new DateTime(clockMock.millis(), UTC).getZone(), equalTo(UTC));
|
||||
assertThat(new DateTime(Clock.systemUTC().millis(), UTC).getZone(), equalTo(UTC));
|
||||
}
|
||||
|
||||
public void testFreezeUnfreeze() throws Exception {
|
||||
ClockMock clockMock = ClockMock.frozen();
|
||||
|
|
|
|||
Loading…
Reference in New Issue