if (startedAt == null) {
return;
}
- activityDto.setFinishedAt(system2.now());
- long executionTime = activityDto.getFinishedAt() - startedAt;
+ activityDto.setExecutedAt(system2.now());
+ long executionTime = activityDto.getExecutedAt() - startedAt;
activityDto.setExecutionTimeMs(executionTime);
if (status == CeActivityDto.Status.SUCCESS) {
queueStatus.addSuccess(executionTime);
status = CeActivityDto.Status.SUCCESS;
queue.remove(task, status);
} catch (Throwable e) {
- LOG.error(format("Failed to process task %s", task.getUuid()), e);
+ LOG.error(format("Failed to execute task %s", task.getUuid()), e);
queue.remove(task, status);
} finally {
// logging twice: once in sonar.log and once in CE appender
}
private static Profiler startProfiler(CeTask task) {
- return Profiler.create(LOG).startInfo("Process task | project={} | id={}", task.getComponentKey(), task.getUuid());
+ return Profiler.create(LOG).startInfo("Execute task | project={} | id={}", task.getComponentKey(), task.getUuid());
}
private static void stopProfiler(Profiler profiler, CeTask task, CeActivityDto.Status status) {
if (status == CeActivityDto.Status.FAILED) {
- profiler.stopError("Processed task | project={} | id={}", task.getComponentKey(), task.getUuid());
+ profiler.stopError("Executed task | project={} | id={}", task.getComponentKey(), task.getUuid());
} else {
- profiler.stopInfo("Processed task | project={} | id={}", task.getComponentKey(), task.getUuid());
+ profiler.stopInfo("Executed task | project={} | id={}", task.getComponentKey(), task.getUuid());
}
}
}
private static final String PARAM_STATUS = "status";
private static final String PARAM_ONLY_CURRENTS = "onlyCurrents";
private static final String PARAM_MIN_SUBMITTED_AT = "minSubmittedAt";
- private static final String PARAM_MAX_FINISHED_AT = "maxFinishedAt";
+ private static final String PARAM_MAX_EXECUTED_AT = "maxExecutedAt";
private final UserSession userSession;
private final DbClient dbClient;
action.createParam(PARAM_MIN_SUBMITTED_AT)
.setDescription("Optional filter on minimum date of task submission")
.setExampleValue(DateUtils.formatDateTime(new Date()));
- action.createParam(PARAM_MAX_FINISHED_AT)
+ action.createParam(PARAM_MAX_EXECUTED_AT)
.setDescription("Optional filter on the maximum date of end of task processing")
.setExampleValue(DateUtils.formatDateTime(new Date()));
action.addPagingParams(10);
query.setType(wsRequest.param(PARAM_TYPE));
query.setOnlyCurrents(wsRequest.mandatoryParamAsBoolean(PARAM_ONLY_CURRENTS));
query.setMinSubmittedAt(toTime(wsRequest.paramAsDateTime(PARAM_MIN_SUBMITTED_AT)));
- query.setMaxFinishedAt(toTime(wsRequest.paramAsDateTime(PARAM_MAX_FINISHED_AT)));
+ query.setMaxExecutedAt(toTime(wsRequest.paramAsDateTime(PARAM_MAX_EXECUTED_AT)));
String status = wsRequest.param(PARAM_STATUS);
if (status != null) {
if (dto.getStartedAt() != null) {
builder.setStartedAt(DateUtils.formatDateTime(new Date(dto.getStartedAt())));
}
- if (dto.getFinishedAt() != null) {
- builder.setFinishedAt(DateUtils.formatDateTime(new Date(dto.getFinishedAt())));
+ if (dto.getExecutedAt() != null) {
+ builder.setExecutedAt(DateUtils.formatDateTime(new Date(dto.getExecutedAt())));
}
if (dto.getExecutionTimeMs() != null) {
builder.setExecutionTimeMs(dto.getExecutionTimeMs());
"submittedAt": "2015-08-13T23:34:59+0200",
"submitterLogin": "john",
"startedAt": "2015-08-13T23:35:00+0200",
- "finishedAt": "2015-08-13T23:35:10+0200",
+ "executedAt": "2015-08-13T23:35:10+0200",
"executionTimeMs": 10000,
"logs": true
},
"status": "FAILED",
"submittedAt": "2015-09-17T23:34:59+0200",
"startedAt": "2015-09-17T23:35:00+0200",
- "finishedAt": "2015-08-13T23:37:00+0200",
+ "executedAt": "2015-08-13T23:37:00+0200",
"executionTimeMs": 120000,
"logs": false
}
assertThat(wsTask.hasComponentId()).isFalse();
assertThat(wsTask.hasComponentKey()).isFalse();
assertThat(wsTask.hasComponentName()).isFalse();
- assertThat(wsTask.hasFinishedAt()).isFalse();
+ assertThat(wsTask.hasExecutedAt()).isFalse();
}
@Test
assertThat(wsTask.getSubmitterLogin()).isEqualTo("rob");
assertThat(wsTask.hasExecutionTimeMs()).isFalse();
- assertThat(wsTask.hasFinishedAt()).isFalse();
+ assertThat(wsTask.hasExecutedAt()).isFalse();
}
@Test
filter.minSubmittedAt = moment(this.state.minDate).format(DATE_FORMAT);
}
if (this.state.maxDate) {
- filter.maxFinishedAt = moment(this.state.maxDate).format(DATE_FORMAT);
+ filter.maxExecutedAt = moment(this.state.maxDate).format(DATE_FORMAT);
}
break;
default:
{this.renderTaskDay(task, previousTask)}
{this.renderTaskDate(task, 'submittedAt', 'LTS')}
{this.renderTaskDate(task, 'startedAt', 'LTS')}
- {this.renderTaskDate(task, 'finishedAt', 'LTS')}
+ {this.renderTaskDate(task, 'executedAt', 'LTS')}
{this.renderTaskExecutionTime(task)}
<td className="thin nowrap text-right">
{this.renderLogsLink(task)}
var duration = null;
if (this.has('startedAt')) {
var startedAtMoment = moment(this.get('startedAt')),
- finishedAtMoment = moment(this.get('finishedAt') || new Date()),
+ finishedAtMoment = moment(this.get('executedAt') || new Date()),
diff = finishedAtMoment.diff(startedAtMoment);
duration = {
seconds: Math.floor(diff / 1000) % 60,
{{#if startedAt}}
<li>Started: {{dt startedAt}}</li>
{{/if}}
- {{#if finishedAt}}
- <li>Finished: {{dt finishedAt}}</li>
+ {{#if executedAt}}
+ <li>Executed: {{dt executedAt}}</li>
{{/if}}
</ul>
</div>
t.column 'submitter_login', :string, :limit => 255, :null => true
t.column 'submitted_at', :big_integer, :null => false
t.column 'started_at', :big_integer, :null => true
- t.column 'finished_at', :big_integer, :null => true
+ t.column 'executed_at', :big_integer, :null => true
t.column 'created_at', :big_integer, :null => false
t.column 'updated_at', :big_integer, :null => false
t.column 'execution_time_ms', :big_integer, :null => true
"status": "SUCCESS",
"submittedAt": "2015-09-18T11:20:43+0200",
"startedAt": "2015-09-18T11:20:37+0200",
- "finishedAt": "2015-09-18T11:20:43+0200",
+ "executedAt": "2015-09-18T11:20:43+0200",
"executionTimeMs": 6030
},
{
"status": "SUCCESS",
"submittedAt": "2015-09-18T11:16:56+0200",
"startedAt": "2015-09-18T11:16:47+0200",
- "finishedAt": "2015-09-18T11:16:56+0200",
+ "executedAt": "2015-09-18T11:16:56+0200",
"executionTimeMs": 8671
}
]
"status": "SUCCESS",
"submittedAt": "2015-09-18T11:16:56+0200",
"startedAt": "2015-09-18T11:16:47+0200",
- "finishedAt": "2015-09-18T11:16:56+0200",
+ "executedAt": "2015-09-18T11:16:56+0200",
"executionTimeMs": 8671
}
]
"status": "SUCCESS",
"submittedAt": "2015-09-18T11:20:43+0200",
"startedAt": "2015-09-18T11:20:37+0200",
- "finishedAt": "2015-09-18T11:20:43+0200",
+ "executedAt": "2015-09-18T11:20:43+0200",
"executionTimeMs": 6030
},
{
"status": "SUCCESS",
"submittedAt": "2015-09-18T11:16:56+0200",
"startedAt": "2015-09-18T11:16:47+0200",
- "finishedAt": "2015-09-18T11:16:56+0200",
+ "executedAt": "2015-09-18T11:16:56+0200",
"executionTimeMs": 8671
}
]
private String submitterLogin;
private long submittedAt;
private Long startedAt;
- private Long finishedAt;
+ private Long executedAt;
private long createdAt;
private long updatedAt;
private Long executionTimeMs;
}
@CheckForNull
- public Long getFinishedAt() {
- return finishedAt;
+ public Long getExecutedAt() {
+ return executedAt;
}
- public void setFinishedAt(@Nullable Long l) {
- this.finishedAt = l;
+ public void setExecutedAt(@Nullable Long l) {
+ this.executedAt = l;
}
public long getCreatedAt() {
.add("submitterLogin", submitterLogin)
.add("submittedAt", submittedAt)
.add("startedAt", startedAt)
- .add("finishedAt", finishedAt)
+ .add("executedAt", executedAt)
.add("createdAt", createdAt)
.add("updatedAt", updatedAt)
.add("executionTimeMs", executionTimeMs)
private CeActivityDto.Status status;
private String type;
private Long minSubmittedAt;
- private Long maxFinishedAt;
+ private Long maxExecutedAt;
@CheckForNull
public String getComponentUuid() {
}
@CheckForNull
- public Long getMaxFinishedAt() {
- return maxFinishedAt;
+ public Long getMaxExecutedAt() {
+ return maxExecutedAt;
}
- public CeActivityQuery setMaxFinishedAt(@Nullable Long l) {
- this.maxFinishedAt = l;
+ public CeActivityQuery setMaxExecutedAt(@Nullable Long l) {
+ this.maxExecutedAt = l;
return this;
}
ca.submitter_login as submitterLogin,
ca.submitted_at as submittedAt,
ca.started_at as startedAt,
- ca.finished_at as finishedAt,
+ ca.executed_at as executedAt,
ca.created_at as createdAt,
ca.updated_at as updatedAt,
ca.is_last as isLast,
<if test="query.minSubmittedAt != null">
and ca.submitted_at >= #{query.minSubmittedAt}
</if>
- <if test="query.maxFinishedAt != null">
- and ca.finished_at <= #{query.maxFinishedAt}
+ <if test="query.maxExecutedAt != null">
+ and ca.executed_at <= #{query.maxExecutedAt}
</if>
</where>
order by ca.id desc
<if test="query.minSubmittedAt != null">
and ca.submitted_at >= #{query.minSubmittedAt}
</if>
- <if test="query.maxFinishedAt != null">
- and ca.finished_at <= #{query.maxFinishedAt}
+ <if test="query.maxExecutedAt != null">
+ and ca.executed_at <= #{query.maxExecutedAt}
</if>
</where>
</select>
<insert id="insert" parameterType="org.sonar.db.ce.CeActivityDto" useGeneratedKeys="false">
insert into ce_activity
(uuid, component_uuid, status, task_type, is_last, is_last_key, submitter_login, submitted_at, started_at,
- finished_at, created_at, updated_at, execution_time_ms)
+ executed_at, created_at, updated_at, execution_time_ms)
values (
#{uuid,jdbcType=VARCHAR},
#{componentUuid,jdbcType=VARCHAR},
#{submitterLogin,jdbcType=VARCHAR},
#{submittedAt,jdbcType=BIGINT},
#{startedAt,jdbcType=BIGINT},
- #{finishedAt,jdbcType=BIGINT},
+ #{executedAt,jdbcType=BIGINT},
#{createdAt,jdbcType=BIGINT},
#{updatedAt,jdbcType=BIGINT},
#{executionTimeMs,jdbcType=BIGINT}
"DATA_FIELD" CLOB(2147483647)
);
-CREATE TABLE "ANALYSIS_REPORTS" (
- "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
- "PROJECT_KEY" VARCHAR(400) NOT NULL,
- "PROJECT_NAME" VARCHAR(256) NULL,
- "REPORT_STATUS" VARCHAR(20) NOT NULL,
- "UUID" VARCHAR(50) NOT NULL,
- "CREATED_AT" BIGINT NOT NULL,
- "UPDATED_AT" BIGINT NOT NULL,
- "STARTED_AT" BIGINT,
- "FINISHED_AT" BIGINT
-);
-
CREATE TABLE "FILE_SOURCES" (
"ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
"PROJECT_UUID" VARCHAR(50) NOT NULL,
"SUBMITTER_LOGIN" VARCHAR(255) NULL,
"SUBMITTED_AT" BIGINT NOT NULL,
"STARTED_AT" BIGINT NULL,
- "FINISHED_AT" BIGINT NULL,
+ "EXECUTED_AT" BIGINT NULL,
"CREATED_AT" BIGINT NOT NULL,
"UPDATED_AT" BIGINT NOT NULL,
"EXECUTION_TIME_MS" BIGINT NULL
assertThat(saved.get().getSubmittedAt()).isEqualTo(1_300_000_000_000L);
assertThat(saved.get().getCreatedAt()).isEqualTo(1_450_000_000_000L);
assertThat(saved.get().getStartedAt()).isEqualTo(1_500_000_000_000L);
- assertThat(saved.get().getFinishedAt()).isEqualTo(1_500_000_000_500L);
+ assertThat(saved.get().getExecutedAt()).isEqualTo(1_500_000_000_500L);
assertThat(saved.get().getExecutionTimeMs()).isEqualTo(500L);
}
assertThat(underTest.selectByQuery(db.getSession(), query, new RowBounds(0, 10))).extracting("uuid").containsOnly("UUID2");
assertThat(underTest.countByQuery(db.getSession(), query)).isEqualTo(1);
- // search by max finished date
- query = new CeActivityQuery().setMaxFinishedAt(1_475_000_000_000L);
+ // search by max executed date
+ query = new CeActivityQuery().setMaxExecutedAt(1_475_000_000_000L);
assertThat(underTest.selectByQuery(db.getSession(), query, new RowBounds(0, 10))).extracting("uuid").containsOnly("UUID1");
assertThat(underTest.countByQuery(db.getSession(), query)).isEqualTo(1);
// search by both dates
query = new CeActivityQuery()
.setMinSubmittedAt(1_400_000_000_000L)
- .setMaxFinishedAt(1_475_000_000_000L);
+ .setMaxExecutedAt(1_475_000_000_000L);
assertThat(underTest.selectByQuery(db.getSession(), query, new RowBounds(0, 10))).extracting("uuid").containsOnly("UUID1");
assertThat(underTest.countByQuery(db.getSession(), query)).isEqualTo(1);
}
- private void insertWithDates(String uuid, long submittedAt, long finishedAt) {
+ private void insertWithDates(String uuid, long submittedAt, long executedAt) {
CeQueueDto queueDto = new CeQueueDto();
queueDto.setUuid(uuid);
queueDto.setTaskType("fake");
CeActivityDto dto = new CeActivityDto(queueDto);
dto.setStatus(CeActivityDto.Status.SUCCESS);
dto.setSubmittedAt(submittedAt);
- dto.setFinishedAt(finishedAt);
+ dto.setExecutedAt(executedAt);
underTest.insert(db.getSession(), dto);
}
CeActivityDto dto = new CeActivityDto(queueDto);
dto.setStatus(status);
dto.setStartedAt(1_500_000_000_000L);
- dto.setFinishedAt(1_500_000_000_500L);
+ dto.setExecutedAt(1_500_000_000_500L);
dto.setExecutionTimeMs(500L);
underTest.insert(db.getSession(), dto);
}
getStartedAtBytes();
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- boolean hasFinishedAt();
+ boolean hasExecutedAt();
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- java.lang.String getFinishedAt();
+ java.lang.String getExecutedAt();
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
com.google.protobuf.ByteString
- getFinishedAtBytes();
+ getExecutedAtBytes();
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- boolean hasIsLastFinished();
+ boolean hasIsLastExecuted();
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- boolean getIsLastFinished();
+ boolean getIsLastExecuted();
/**
* <code>optional int64 executionTimeMs = 12;</code>
* <code>optional bool logs = 13;</code>
*/
boolean hasLogs();
-
/**
* <code>optional bool logs = 13;</code>
*/
submittedAt_ = "";
submitterLogin_ = "";
startedAt_ = "";
- finishedAt_ = "";
- isLastFinished_ = false;
+ executedAt_ = "";
+ isLastExecuted_ = false;
executionTimeMs_ = 0L;
logs_ = false;
}
case 82: {
com.google.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000200;
- finishedAt_ = bs;
+ executedAt_ = bs;
break;
}
case 88: {
bitField0_ |= 0x00000400;
- isLastFinished_ = input.readBool();
+ isLastExecuted_ = input.readBool();
break;
}
case 96: {
}
}
- public static final int FINISHEDAT_FIELD_NUMBER = 10;
- private volatile java.lang.Object finishedAt_;
+ public static final int EXECUTEDAT_FIELD_NUMBER = 10;
+ private volatile java.lang.Object executedAt_;
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public boolean hasFinishedAt() {
+ public boolean hasExecutedAt() {
return ((bitField0_ & 0x00000200) == 0x00000200);
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public java.lang.String getFinishedAt() {
- java.lang.Object ref = finishedAt_;
+ public java.lang.String getExecutedAt() {
+ java.lang.Object ref = executedAt_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (bs.isValidUtf8()) {
- finishedAt_ = s;
+ executedAt_ = s;
}
return s;
}
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
public com.google.protobuf.ByteString
- getFinishedAtBytes() {
- java.lang.Object ref = finishedAt_;
+ getExecutedAtBytes() {
+ java.lang.Object ref = executedAt_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
- finishedAt_ = b;
+ executedAt_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
- public static final int ISLASTFINISHED_FIELD_NUMBER = 11;
- private boolean isLastFinished_;
+ public static final int ISLASTEXECUTED_FIELD_NUMBER = 11;
+ private boolean isLastExecuted_;
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public boolean hasIsLastFinished() {
+ public boolean hasIsLastExecuted() {
return ((bitField0_ & 0x00000400) == 0x00000400);
}
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public boolean getIsLastFinished() {
- return isLastFinished_;
+ public boolean getIsLastExecuted() {
+ return isLastExecuted_;
}
public static final int EXECUTIONTIMEMS_FIELD_NUMBER = 12;
public static final int LOGS_FIELD_NUMBER = 13;
private boolean logs_;
-
/**
* <code>optional bool logs = 13;</code>
*/
public boolean hasLogs() {
return ((bitField0_ & 0x00001000) == 0x00001000);
}
-
/**
* <code>optional bool logs = 13;</code>
*/
output.writeBytes(9, getStartedAtBytes());
}
if (((bitField0_ & 0x00000200) == 0x00000200)) {
- output.writeBytes(10, getFinishedAtBytes());
+ output.writeBytes(10, getExecutedAtBytes());
}
if (((bitField0_ & 0x00000400) == 0x00000400)) {
- output.writeBool(11, isLastFinished_);
+ output.writeBool(11, isLastExecuted_);
}
if (((bitField0_ & 0x00000800) == 0x00000800)) {
output.writeInt64(12, executionTimeMs_);
}
if (((bitField0_ & 0x00000200) == 0x00000200)) {
size += com.google.protobuf.CodedOutputStream
- .computeBytesSize(10, getFinishedAtBytes());
+ .computeBytesSize(10, getExecutedAtBytes());
}
if (((bitField0_ & 0x00000400) == 0x00000400)) {
size += com.google.protobuf.CodedOutputStream
- .computeBoolSize(11, isLastFinished_);
+ .computeBoolSize(11, isLastExecuted_);
}
if (((bitField0_ & 0x00000800) == 0x00000800)) {
size += com.google.protobuf.CodedOutputStream
bitField0_ = (bitField0_ & ~0x00000080);
startedAt_ = "";
bitField0_ = (bitField0_ & ~0x00000100);
- finishedAt_ = "";
+ executedAt_ = "";
bitField0_ = (bitField0_ & ~0x00000200);
- isLastFinished_ = false;
+ isLastExecuted_ = false;
bitField0_ = (bitField0_ & ~0x00000400);
executionTimeMs_ = 0L;
bitField0_ = (bitField0_ & ~0x00000800);
if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
to_bitField0_ |= 0x00000200;
}
- result.finishedAt_ = finishedAt_;
+ result.executedAt_ = executedAt_;
if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
to_bitField0_ |= 0x00000400;
}
- result.isLastFinished_ = isLastFinished_;
+ result.isLastExecuted_ = isLastExecuted_;
if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
to_bitField0_ |= 0x00000800;
}
startedAt_ = other.startedAt_;
onChanged();
}
- if (other.hasFinishedAt()) {
+ if (other.hasExecutedAt()) {
bitField0_ |= 0x00000200;
- finishedAt_ = other.finishedAt_;
+ executedAt_ = other.executedAt_;
onChanged();
}
- if (other.hasIsLastFinished()) {
- setIsLastFinished(other.getIsLastFinished());
+ if (other.hasIsLastExecuted()) {
+ setIsLastExecuted(other.getIsLastExecuted());
}
if (other.hasExecutionTimeMs()) {
setExecutionTimeMs(other.getExecutionTimeMs());
return this;
}
- private java.lang.Object finishedAt_ = "";
+ private java.lang.Object executedAt_ = "";
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public boolean hasFinishedAt() {
+ public boolean hasExecutedAt() {
return ((bitField0_ & 0x00000200) == 0x00000200);
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public java.lang.String getFinishedAt() {
- java.lang.Object ref = finishedAt_;
+ public java.lang.String getExecutedAt() {
+ java.lang.Object ref = executedAt_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (bs.isValidUtf8()) {
- finishedAt_ = s;
+ executedAt_ = s;
}
return s;
} else {
return (java.lang.String) ref;
}
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
public com.google.protobuf.ByteString
- getFinishedAtBytes() {
- java.lang.Object ref = finishedAt_;
+ getExecutedAtBytes() {
+ java.lang.Object ref = executedAt_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
- finishedAt_ = b;
+ executedAt_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public Builder setFinishedAt(
+ public Builder setExecutedAt(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
bitField0_ |= 0x00000200;
- finishedAt_ = value;
+ executedAt_ = value;
onChanged();
return this;
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public Builder clearFinishedAt() {
+ public Builder clearExecutedAt() {
bitField0_ = (bitField0_ & ~0x00000200);
- finishedAt_ = getDefaultInstance().getFinishedAt();
+ executedAt_ = getDefaultInstance().getExecutedAt();
onChanged();
return this;
}
+
/**
- * <code>optional string finishedAt = 10;</code>
+ * <code>optional string executedAt = 10;</code>
*/
- public Builder setFinishedAtBytes(
+ public Builder setExecutedAtBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
bitField0_ |= 0x00000200;
- finishedAt_ = value;
+ executedAt_ = value;
onChanged();
return this;
}
- private boolean isLastFinished_ ;
+ private boolean isLastExecuted_;
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public boolean hasIsLastFinished() {
+ public boolean hasIsLastExecuted() {
return ((bitField0_ & 0x00000400) == 0x00000400);
}
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public boolean getIsLastFinished() {
- return isLastFinished_;
+ public boolean getIsLastExecuted() {
+ return isLastExecuted_;
}
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public Builder setIsLastFinished(boolean value) {
+ public Builder setIsLastExecuted(boolean value) {
bitField0_ |= 0x00000400;
- isLastFinished_ = value;
+ isLastExecuted_ = value;
onChanged();
return this;
}
+
/**
- * <code>optional bool isLastFinished = 11;</code>
+ * <code>optional bool isLastExecuted = 11;</code>
*/
- public Builder clearIsLastFinished() {
+ public Builder clearIsLastExecuted() {
bitField0_ = (bitField0_ & ~0x00000400);
- isLastFinished_ = false;
+ isLastExecuted_ = false;
onChanged();
return this;
}
}
private boolean logs_;
-
/**
* <code>optional bool logs = 13;</code>
*/
public boolean hasLogs() {
return ((bitField0_ & 0x00001000) == 0x00001000);
}
-
/**
* <code>optional bool logs = 13;</code>
*/
public boolean getLogs() {
return logs_;
}
-
/**
* <code>optional bool logs = 13;</code>
*/
onChanged();
return this;
}
-
/**
* <code>optional bool logs = 13;</code>
*/
"ey\030\004 \001(\t\022\025\n\rcomponentName\030\005 \001(\t\022+\n\006statu" +
"s\030\006 \001(\0162\033.sonarqube.ws.ce.TaskStatus\022\023\n\013" +
"submittedAt\030\007 \001(\t\022\026\n\016submitterLogin\030\010 \001(" +
- "\t\022\021\n\tstartedAt\030\t \001(\t\022\022\n\nfinishedAt\030\n \001(\t" +
- "\022\026\n\016isLastFinished\030\013 \001(\010\022\027\n\017executionTim" +
+ "\t\022\021\n\tstartedAt\030\t \001(\t\022\022\n\nexecutedAt\030\n \001(\t" +
+ "\022\026\n\016isLastExecuted\030\013 \001(\010\022\027\n\017executionTim" +
"eMs\030\014 \001(\003\022\014\n\004logs\030\r \001(\010*Q\n\nTaskStatus\022\013\n" +
"\007PENDING\020\000\022\017\n\013IN_PROGRESS\020\001\022\013\n\007SUCCESS\020\002" +
"\022\n\n\006FAILED\020\003\022\014\n\010CANCELED\020\004B\032\n\020org.sonarq",
internal_static_sonarqube_ws_ce_Task_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_sonarqube_ws_ce_Task_descriptor,
- new java.lang.String[] {"Id", "Type", "ComponentId", "ComponentKey", "ComponentName", "Status", "SubmittedAt", "SubmitterLogin", "StartedAt", "FinishedAt", "IsLastFinished",
+ new java.lang.String[] {"Id", "Type", "ComponentId", "ComponentKey", "ComponentName", "Status", "SubmittedAt", "SubmitterLogin", "StartedAt", "ExecutedAt", "IsLastExecuted",
"ExecutionTimeMs", "Logs",});
org.sonarqube.ws.Common.getDescriptor();
}
optional string submittedAt = 7;
optional string submitterLogin = 8;
optional string startedAt = 9;
- optional string finishedAt = 10;
- optional bool isLastFinished = 11;
+ optional string executedAt = 10;
+ optional bool isLastExecuted = 11;
optional int64 executionTimeMs = 12;
optional bool logs = 13;
}
projects / sonarqube.git / commitdiff