diff options
54 files changed, 1167 insertions, 1574 deletions
diff --git a/sonar-core/src/main/java/org/sonar/core/activity/Activity.java b/server/sonar-server/src/main/java/org/sonar/server/activity/Activity.java index c5ede01df71..f0a50a40c5e 100644 --- a/sonar-core/src/main/java/org/sonar/core/activity/Activity.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/Activity.java @@ -17,30 +17,54 @@ * along with this program; if not, write to the Free Software Foundation, * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -package org.sonar.core.activity; +package org.sonar.server.activity; -import java.util.Date; +import javax.annotation.Nullable; + +import java.util.LinkedHashMap; import java.util.Map; -/** - * @since 4.4 - */ -public interface Activity { +public class Activity { - Type type(); + public static enum Type { + QPROFILE, SERVER, ANALYSIS_REPORT + } + + private Type type; + private String action; + private String message; + private final Map<String,Object> data = new LinkedHashMap<>(); + + public Type getType() { + return type; + } - String action(); + public void setType(Type type) { + this.type = type; + } - Date time(); + public String getAction() { + return action; + } - String login(); + public void setAction(String action) { + this.action = action; + } - Map<String, String> details(); + public String getMessage() { + return message; + } - String message(); + public void setMessage(@Nullable String message) { + this.message = message; + } - public static enum Type { - NONE, QPROFILE, SERVER, ANALYSIS_REPORT + public Map<String, Object> getData() { + return data; } + public Activity setData(String key, Object val) { + this.data.put(key, val); + return this; + } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/ActivityService.java b/server/sonar-server/src/main/java/org/sonar/server/activity/ActivityService.java index bb91bf20967..a108c0db063 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/ActivityService.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/ActivityService.java @@ -19,60 +19,33 @@ */ package org.sonar.server.activity; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.ActivityLog; +import org.sonar.api.ServerComponent; +import org.sonar.api.utils.KeyValueFormat; +import org.sonar.api.utils.internal.Uuids; import org.sonar.core.activity.db.ActivityDto; -import org.sonar.core.persistence.DbSession; -import org.sonar.server.activity.index.ActivityIndex; -import org.sonar.server.activity.index.ActivityQuery; +import org.sonar.server.activity.index.ActivityIndexer; import org.sonar.server.db.DbClient; -import org.sonar.server.search.IndexClient; -import org.sonar.server.search.QueryContext; -import org.sonar.server.search.Result; import org.sonar.server.user.UserSession; -import javax.annotation.Nullable; - -/** - * Log service is used to log Activity classes which represents an event to DB and Index. - * - * @see org.sonar.core.activity.ActivityLog - */ -public class ActivityService { +public class ActivityService implements ServerComponent { private final DbClient dbClient; - private final IndexClient indexClient; + private final ActivityIndexer indexer; - public ActivityService(DbClient dbClient, IndexClient indexClient) { + public ActivityService(DbClient dbClient, ActivityIndexer indexer) { this.dbClient = dbClient; - this.indexClient = indexClient; - } - - @Nullable - private String getAuthor() { - return (UserSession.get().login() != null) ? UserSession.get().login() : null; - } - - private void save(DbSession session, ActivityDto log) { - dbClient.activityDao().insert(session, - log.setAuthor(getAuthor())); - } - - public void write(DbSession session, Activity.Type type, String message) { - save(session, ActivityDto.createFor(message).setType(type)); - } - - public <L extends ActivityLog> void write(DbSession session, Activity.Type type, L log) { - this.save(session, ActivityDto.createFor(log) - .setType(type)); - } - - public ActivityQuery newActivityQuery() { - return new ActivityQuery(); + this.indexer = indexer; } - public Result<Activity> search(ActivityQuery query, QueryContext options) { - ActivityIndex index = indexClient.get(ActivityIndex.class); - return new Result<Activity>(index, index.search(query, options)); + public void save(Activity activity) { + ActivityDto dto = new ActivityDto() + .setKey(Uuids.create()) + .setAuthor(UserSession.get().login()) + .setAction(activity.getAction()) + .setMessage(activity.getMessage()) + .setData(KeyValueFormat.format(activity.getData())) + .setType(activity.getType().name()); + dbClient.activityDao().insert(dto); + indexer.index(); } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/RubyQProfileActivityService.java b/server/sonar-server/src/main/java/org/sonar/server/activity/RubyQProfileActivityService.java index 744a3c05fd6..d0e3c7a0794 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/RubyQProfileActivityService.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/RubyQProfileActivityService.java @@ -23,10 +23,10 @@ package org.sonar.server.activity; import org.picocontainer.Startable; import org.sonar.api.ServerComponent; import org.sonar.api.utils.Paging; +import org.sonar.server.es.SearchOptions; import org.sonar.server.qualityprofile.QProfileActivity; import org.sonar.server.qualityprofile.QProfileActivityQuery; import org.sonar.server.qualityprofile.QProfileService; -import org.sonar.server.search.QueryContext; import org.sonar.server.search.Result; import org.sonar.server.util.RubyUtils; @@ -51,11 +51,8 @@ public class RubyQProfileActivityService implements ServerComponent, Startable { */ public QProfileActivityResult search(Map<String, Object> params) { QProfileActivityQuery query = new QProfileActivityQuery(); - QueryContext queryContext = new QueryContext().setMaxLimit(); - List<String> profileKeys = RubyUtils.toStrings(params.get("profileKeys")); - if (profileKeys != null) { - query.setQprofileKeys(profileKeys); - } + + query.setQprofileKey((String)params.get("profileKey")); Date since = RubyUtils.toDate(params.get("since")); if (since != null) { query.setSince(since); @@ -64,12 +61,14 @@ public class RubyQProfileActivityService implements ServerComponent, Startable { if (to != null) { query.setTo(to); } + + SearchOptions options = new SearchOptions(); Integer page = RubyUtils.toInteger(params.get("p")); int pageIndex = page != null ? page : 1; - queryContext.setPage(pageIndex, 50); + options.setPage(pageIndex, 50); - Result<QProfileActivity> result = service.searchActivities(query, queryContext); - return new QProfileActivityResult(result.getHits(), Paging.create(queryContext.getLimit(), pageIndex, (int) result.getTotal())); + Result<QProfileActivity> result = service.searchActivities(query, options); + return new QProfileActivityResult(result.getHits(), Paging.create(options.getLimit(), pageIndex, (int) result.getTotal())); } @Override diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/db/ActivityDao.java b/server/sonar-server/src/main/java/org/sonar/server/activity/db/ActivityDao.java index 7d4a636947f..c6a9a271632 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/db/ActivityDao.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/db/ActivityDao.java @@ -19,46 +19,39 @@ */ package org.sonar.server.activity.db; +import org.sonar.api.ServerComponent; import org.sonar.api.utils.System2; import org.sonar.core.activity.db.ActivityDto; import org.sonar.core.activity.db.ActivityMapper; +import org.sonar.core.persistence.DaoComponent; import org.sonar.core.persistence.DbSession; -import org.sonar.server.db.BaseDao; -import org.sonar.server.search.IndexDefinition; +import org.sonar.core.persistence.MyBatis; -import java.util.List; +import java.util.Date; -/** - * @since 4.4 - */ -public class ActivityDao extends BaseDao<ActivityMapper, ActivityDto, String> { +public class ActivityDao implements DaoComponent, ServerComponent { - public ActivityDao(System2 system) { - super(IndexDefinition.LOG, ActivityMapper.class, system); - } + private final MyBatis mybatis; + private final System2 system; - @Override - protected ActivityDto doGetNullableByKey(DbSession session, String key) { - throw new IllegalStateException("Cannot execute getByKey on Activities in DB"); + public ActivityDao(MyBatis mybatis, System2 system) { + this.mybatis = mybatis; + this.system = system; } - @Override - protected ActivityDto doInsert(DbSession session, ActivityDto item) { - mapper(session).insert(item); - return item; + public void insert(ActivityDto dto) { + DbSession session = mybatis.openSession(false); + try { + insert(session, dto); + session.commit(); + } finally { + MyBatis.closeQuietly(session); + } } - @Override - protected ActivityDto doUpdate(DbSession session, ActivityDto item) { - throw new IllegalStateException("Cannot update Log!"); + public void insert(DbSession session, ActivityDto dto) { + dto.setCreatedAt(new Date(system.now())); + session.getMapper(ActivityMapper.class).insert(dto); } - @Override - protected void doDeleteByKey(DbSession session, String key) { - throw new IllegalStateException("Cannot delete Log!"); - } - - public List<ActivityDto> findAll(DbSession session) { - return mapper(session).selectAll(); - } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityDoc.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityDoc.java index a438fa3a61d..46e122bae51 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityDoc.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityDoc.java @@ -19,54 +19,88 @@ */ package org.sonar.server.activity.index; +import com.google.common.annotations.VisibleForTesting; import org.apache.commons.lang.builder.ReflectionToStringBuilder; -import org.sonar.core.activity.Activity; import org.sonar.server.search.BaseDoc; -import org.sonar.server.search.IndexUtils; + +import javax.annotation.CheckForNull; +import javax.annotation.Nullable; import java.util.Date; +import java.util.HashMap; import java.util.Map; -/** - * @since 4.4 - */ -public class ActivityDoc extends BaseDoc implements Activity { +public class ActivityDoc extends BaseDoc { - protected ActivityDoc(Map<String, Object> fields) { + public ActivityDoc(Map<String, Object> fields) { super(fields); } - @Override - public Date time() { - return IndexUtils.parseDateTime((String) getField(ActivityNormalizer.LogFields.CREATED_AT.field())); + @VisibleForTesting + ActivityDoc() { + super(new HashMap<String, Object>()); + } + + public void setCreatedAt(Date date) { + setField(ActivityIndexDefinition.FIELD_CREATED_AT, date); + } + + public Date getCreatedAt() { + return getFieldAsDate(ActivityIndexDefinition.FIELD_CREATED_AT); + } + + public String getKey() { + return this.getField(ActivityIndexDefinition.FIELD_KEY); + } + + public void setKey(String s) { + setField(ActivityIndexDefinition.FIELD_KEY, s); + } + + @CheckForNull + public String getLogin() { + return this.getNullableField(ActivityIndexDefinition.FIELD_LOGIN); + } + + public void setLogin(@Nullable String s) { + setField(ActivityIndexDefinition.FIELD_LOGIN, s); + } + + public String getType() { + return ((String) getField(ActivityIndexDefinition.FIELD_TYPE)); + } + + public void setType(String s) { + setField(ActivityIndexDefinition.FIELD_TYPE, s); + } + + @CheckForNull + public String getAction() { + return this.getNullableField(ActivityIndexDefinition.FIELD_ACTION); } - @Override - public String login() { - return this.getNullableField(ActivityNormalizer.LogFields.LOGIN.field()); + public void setAction(@Nullable String s) { + setField(ActivityIndexDefinition.FIELD_ACTION, s); } - @Override - public Type type() { - return Type.valueOf((String) getField(ActivityNormalizer.LogFields.TYPE.field())); + @CheckForNull + public Map<String, String> getDetails() { + return this.getNullableField(ActivityIndexDefinition.FIELD_DETAILS); } - @Override - public String action() { - return this.getNullableField(ActivityNormalizer.LogFields.ACTION.field()); + public void setDetails(Map<String, String> details) { + setField(ActivityIndexDefinition.FIELD_DETAILS, details); } - @Override - public Map<String, String> details() { - return this.getNullableField(ActivityNormalizer.LogFields.DETAILS.field()); + @CheckForNull + public String getMessage() { + return this.getNullableField(ActivityIndexDefinition.FIELD_MESSAGE); } - @Override - public String message() { - return this.getNullableField(ActivityNormalizer.LogFields.MESSAGE.field()); + public void setMessage(@Nullable String s) { + setField(ActivityIndexDefinition.FIELD_MESSAGE, s); } - @Override public String toString() { return ReflectionToStringBuilder.toString(this); } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndex.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndex.java index 0e1ced87c50..ee082d63d43 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndex.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndex.java @@ -19,119 +19,86 @@ */ package org.sonar.server.activity.index; +import com.google.common.base.Function; import org.elasticsearch.action.search.SearchRequestBuilder; import org.elasticsearch.action.search.SearchResponse; -import org.elasticsearch.action.search.SearchType; -import org.elasticsearch.common.settings.ImmutableSettings; -import org.elasticsearch.common.unit.TimeValue; -import org.elasticsearch.index.query.*; +import org.elasticsearch.index.query.AndFilterBuilder; +import org.elasticsearch.index.query.FilterBuilders; +import org.elasticsearch.index.query.OrFilterBuilder; +import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.search.sort.SortOrder; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.db.ActivityDto; -import org.sonar.server.search.*; +import org.sonar.core.util.NonNullInputFunction; +import org.sonar.server.es.BaseIndex; +import org.sonar.server.es.EsClient; +import org.sonar.server.es.SearchOptions; +import org.sonar.server.es.SearchResult; -import javax.annotation.Nullable; - -import java.util.HashMap; +import java.util.Date; import java.util.Map; -/** - * @since 4.4 - */ -public class ActivityIndex extends BaseIndex<Activity, ActivityDto, String> { - - public ActivityIndex(ActivityNormalizer normalizer, SearchClient node) { - super(IndexDefinition.LOG, normalizer, node); - } - - @Override - protected String getKeyValue(String key) { - return key; - } - - @Override - protected Map mapKey() { - Map<String, Object> mapping = new HashMap<String, Object>(); - mapping.put("path", ActivityNormalizer.LogFields.KEY.field()); - return mapping; - } - - @Override - protected ImmutableSettings.Builder addCustomIndexSettings(ImmutableSettings.Builder settings) { - return settings - .put("analysis.analyzer.default.type", "keyword"); - } +public class ActivityIndex extends BaseIndex { - @Override - protected Map mapProperties() { - Map<String, Object> mapping = new HashMap<String, Object>(); - for (IndexField field : ActivityNormalizer.LogFields.ALL_FIELDS) { - mapping.put(field.field(), mapField(field)); + /** + * Convert an Elasticsearch result (a map) to an {@link org.sonar.server.activity.index.ActivityDoc}. It's + * used for {@link org.sonar.server.es.SearchResult}. + */ + private static final Function<Map<String, Object>, ActivityDoc> DOC_CONVERTER = new NonNullInputFunction<Map<String, Object>, ActivityDoc>() { + @Override + protected ActivityDoc doApply(Map<String, Object> input) { + return new ActivityDoc(input); } - return mapping; - } - - @Override - protected Activity toDoc(final Map<String, Object> fields) { - return new ActivityDoc(fields); - } + }; - public Result<Activity> findAll() { - SearchRequestBuilder request = getClient().prepareSearch(this.getIndexName()) - .setQuery(QueryBuilders.matchAllQuery()) - .setTypes(this.getIndexType()) - .setSize(Integer.MAX_VALUE); - SearchResponse response = request.get(); - return new Result<Activity>(this, response); + public ActivityIndex(EsClient esClient) { + super(esClient); } - public SearchResponse search(ActivityQuery query, QueryContext options) { - return search(query, options, null); + public SearchResult<ActivityDoc> search(ActivityQuery query, SearchOptions options) { + SearchResponse response = doSearch(query, options); + return new SearchResult<>(response, DOC_CONVERTER); } - public SearchResponse search(ActivityQuery query, QueryContext options, - @Nullable FilterBuilder domainFilter) { - - // Prepare query - SearchRequestBuilder esSearch = getClient() - .prepareSearch(this.getIndexName()) - .setTypes(this.getIndexType()) - .setIndices(this.getIndexName()); - - // Integrate Pagination - esSearch.setFrom(options.getOffset()); - esSearch.setSize(options.getLimit()); + public SearchResponse doSearch(ActivityQuery query, SearchOptions options) { + SearchRequestBuilder requestBuilder = getClient() + .prepareSearch(ActivityIndexDefinition.INDEX) + .setTypes(ActivityIndexDefinition.TYPE); - // Sort Date Desc - esSearch.addSort(ActivityNormalizer.LogFields.CREATED_AT.field(), SortOrder.DESC); + requestBuilder.setFrom(options.getOffset()); + requestBuilder.setSize(options.getLimit()); + requestBuilder.addSort(ActivityIndexDefinition.FIELD_CREATED_AT, SortOrder.DESC); AndFilterBuilder filter = FilterBuilders.andFilter(); - - // implement Type Filtering - OrFilterBuilder typeFilter = FilterBuilders.orFilter(); - for (Activity.Type type : query.getTypes()) { - typeFilter.add(FilterBuilders.termFilter(ActivityNormalizer.LogFields.TYPE.field(), type)); + if (!query.getTypes().isEmpty()) { + OrFilterBuilder typeFilter = FilterBuilders.orFilter(); + for (String type : query.getTypes()) { + typeFilter.add(FilterBuilders.termFilter(ActivityIndexDefinition.FIELD_TYPE, type)); + } + filter.add(typeFilter); } - filter.add(typeFilter); - - // Implement date Filter - filter.add(FilterBuilders.rangeFilter(ActivityNormalizer.LogFields.CREATED_AT.field()) - .from(query.getSince()) - .to(query.getTo())); - // Add any additional domain filter - if (domainFilter != null) { - filter.add(domainFilter); + if (!query.getDataOrFilters().isEmpty()) { + for (Map.Entry<String, Object> entry : query.getDataOrFilters().entrySet()) { + OrFilterBuilder orFilter = FilterBuilders.orFilter(); + orFilter.add(FilterBuilders.nestedFilter(ActivityIndexDefinition.FIELD_DETAILS, + FilterBuilders.termFilter(ActivityIndexDefinition.FIELD_DETAILS + "." + entry.getKey(), entry.getValue()))); + filter.add(orFilter); + } } - esSearch.setQuery(QueryBuilders.filteredQuery( - QueryBuilders.matchAllQuery(), filter)); - - if (options.isScroll()) { - esSearch.setSearchType(SearchType.SCAN); - esSearch.setScroll(TimeValue.timeValueMinutes(3)); + Date since = query.getSince(); + if (since != null) { + filter.add(FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT) + .gt(since) + .cache(false)); + } + Date to = query.getTo(); + if (to != null) { + filter.add(FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT) + .lt(to) + .cache(false)); } - return esSearch.get(); + requestBuilder.setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), filter)); + return requestBuilder.get(); } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexDefinition.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexDefinition.java new file mode 100644 index 00000000000..9fd5756c51b --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexDefinition.java @@ -0,0 +1,76 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import com.google.common.collect.ImmutableMap; +import org.elasticsearch.cluster.metadata.IndexMetaData; +import org.sonar.api.config.Settings; +import org.sonar.process.ProcessConstants; +import org.sonar.server.es.IndexDefinition; +import org.sonar.server.es.NewIndex; + +/** + * Definition of ES index "activities", including settings and fields. + */ +public class ActivityIndexDefinition implements IndexDefinition { + + public static final String INDEX = "activities"; + public static final String TYPE = "activity"; + public static final String FIELD_KEY = "key"; + public static final String FIELD_TYPE = "type"; + public static final String FIELD_ACTION = "action"; + public static final String FIELD_CREATED_AT = "createdAt"; + public static final String FIELD_LOGIN = "login"; + public static final String FIELD_DETAILS = "details"; + public static final String FIELD_MESSAGE = "message"; + + private final Settings settings; + + public ActivityIndexDefinition(Settings settings) { + this.settings = settings; + } + + @Override + public void define(IndexDefinitionContext context) { + NewIndex index = context.create(INDEX); + // refresh is always handled by ActivityIndexer + index.getSettings().put("index.refresh_interval", "-1"); + index.getSettings().put("analysis.analyzer.default.type", "keyword"); + + // shards + boolean clusterMode = settings.getBoolean(ProcessConstants.CLUSTER_ACTIVATE); + if (clusterMode) { + index.getSettings().put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 4); + index.getSettings().put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1); + // else keep defaults (one shard) + } + + // type "activity" + NewIndex.NewIndexType mapping = index.createType(TYPE); + mapping.setAttribute("_id", ImmutableMap.of("path", FIELD_KEY)); + mapping.stringFieldBuilder(FIELD_KEY).build(); + mapping.stringFieldBuilder(FIELD_TYPE).build(); + mapping.stringFieldBuilder(FIELD_ACTION).build(); + mapping.stringFieldBuilder(FIELD_LOGIN).build(); + mapping.createDynamicNestedField(FIELD_DETAILS); + mapping.stringFieldBuilder(FIELD_MESSAGE).build(); + mapping.createDateTimeField(FIELD_CREATED_AT); + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexer.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexer.java new file mode 100644 index 00000000000..1a668bd5a8f --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityIndexer.java @@ -0,0 +1,89 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import org.elasticsearch.action.update.UpdateRequest; +import org.sonar.core.persistence.DbSession; +import org.sonar.server.db.DbClient; +import org.sonar.server.es.BaseIndexer; +import org.sonar.server.es.BulkIndexer; +import org.sonar.server.es.EsClient; + +import java.sql.Connection; +import java.util.Iterator; + +/** + * Add to Elasticsearch index {@link org.sonar.server.activity.index.ActivityIndexDefinition} the rows of + * db table ACTIVITIES that are not indexed yet + * <p/> + * TODO idea of improvement - index asynchronously with UpdateRequest#replicationType(ReplicationType.ASYNC) + */ +public class ActivityIndexer extends BaseIndexer { + + private final DbClient dbClient; + + public ActivityIndexer(DbClient dbClient, EsClient esClient) { + super(esClient, 0L, ActivityIndexDefinition.INDEX, ActivityIndexDefinition.TYPE); + this.dbClient = dbClient; + } + + @Override + protected long doIndex(long lastUpdatedAt) { + final BulkIndexer bulk = new BulkIndexer(esClient, ActivityIndexDefinition.INDEX); + bulk.setLarge(lastUpdatedAt == 0L); + + DbSession dbSession = dbClient.openSession(false); + Connection dbConnection = dbSession.getConnection(); + try { + ActivityResultSetIterator rowIt = ActivityResultSetIterator.create(dbClient, dbConnection, lastUpdatedAt); + long maxUpdatedAt = doIndex(bulk, rowIt); + rowIt.close(); + return maxUpdatedAt; + + } finally { + dbSession.close(); + } + } + + public long index(Iterator<ActivityDoc> activities) { + final BulkIndexer bulk = new BulkIndexer(esClient, ActivityIndexDefinition.INDEX); + return doIndex(bulk, activities); + } + + private long doIndex(BulkIndexer bulk, Iterator<ActivityDoc> activities) { + long maxUpdatedAt = 0L; + bulk.start(); + while (activities.hasNext()) { + ActivityDoc activity = activities.next(); + bulk.add(newUpsertRequest(activity)); + + // it's more efficient to sort programmatically than in SQL on some databases (MySQL for instance) + maxUpdatedAt = Math.max(maxUpdatedAt, activity.getCreatedAt().getTime()); + } + bulk.stop(); + return maxUpdatedAt; + } + + private UpdateRequest newUpsertRequest(ActivityDoc doc) { + return new UpdateRequest(ActivityIndexDefinition.INDEX, ActivityIndexDefinition.TYPE, doc.getKey()) + .doc(doc.getFields()) + .upsert(doc.getFields()); + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityNormalizer.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityNormalizer.java deleted file mode 100644 index 2e64ed487a7..00000000000 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityNormalizer.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.server.activity.index; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableSet; -import org.elasticsearch.action.support.replication.ReplicationType; -import org.elasticsearch.action.update.UpdateRequest; -import org.sonar.api.utils.KeyValueFormat; -import org.sonar.core.activity.db.ActivityDto; -import org.sonar.server.db.DbClient; -import org.sonar.server.search.BaseNormalizer; -import org.sonar.server.search.IndexField; -import org.sonar.server.search.Indexable; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * @since 4.4 - */ -public class ActivityNormalizer extends BaseNormalizer<ActivityDto, String> { - - public static final class LogFields extends Indexable { - - public static final IndexField KEY = add(IndexField.Type.STRING, "key"); - public static final IndexField TYPE = addSortable(IndexField.Type.STRING, "type"); - public static final IndexField ACTION = addSortable(IndexField.Type.STRING, "action"); - public static final IndexField CREATED_AT = addSortable(IndexField.Type.DATE, "createdAt"); - public static final IndexField UPDATED_AT = addSortable(IndexField.Type.DATE, BaseNormalizer.UPDATED_AT_FIELD); - public static final IndexField LOGIN = addSearchable(IndexField.Type.STRING, "login"); - public static final IndexField DETAILS = addSearchable(IndexField.Type.OBJECT, "details"); - public static final IndexField MESSAGE = addSearchable(IndexField.Type.STRING, "message"); - public static final Set<IndexField> ALL_FIELDS = ImmutableSet.of(KEY, TYPE, ACTION, CREATED_AT, UPDATED_AT, LOGIN, DETAILS, MESSAGE); - } - - public ActivityNormalizer(DbClient db) { - super(db); - } - - @Override - public List<UpdateRequest> normalize(ActivityDto dto) { - - Map<String, Object> logDoc = new HashMap<String, Object>(); - logDoc.put(LogFields.KEY.field(), dto.getKey()); - logDoc.put(LogFields.TYPE.field(), dto.getType()); - logDoc.put(LogFields.ACTION.field(), dto.getAction()); - logDoc.put(LogFields.LOGIN.field(), dto.getAuthor()); - logDoc.put(LogFields.MESSAGE.field(), dto.getMessage()); - logDoc.put(LogFields.CREATED_AT.field(), dto.getCreatedAt()); - logDoc.put(LogFields.UPDATED_AT.field(), dto.getUpdatedAt()); - - logDoc.put(LogFields.DETAILS.field(), KeyValueFormat.parse(dto.getData())); - - /* Creating updateRequest */ - return ImmutableList.of(new UpdateRequest() - .id(dto.getKey()) - .replicationType(ReplicationType.ASYNC) - .doc(logDoc) - .upsert(logDoc)); - } -} diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityQuery.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityQuery.java index 53c8749ae21..b8e25d91c15 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityQuery.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityQuery.java @@ -19,49 +19,60 @@ */ package org.sonar.server.activity.index; -import com.google.common.collect.Lists; -import org.sonar.core.activity.Activity; +import javax.annotation.CheckForNull; +import javax.annotation.Nullable; +import java.util.ArrayList; import java.util.Collection; import java.util.Date; +import java.util.LinkedHashMap; +import java.util.Map; -/** - * @since 4.4 - */ public class ActivityQuery { private Date since; private Date to; - private Collection<Activity.Type> types; - - public ActivityQuery() { - types = Lists.newArrayList(); - } + private final Collection<String> types = new ArrayList<>(); + private final Map<String, Object> dataOrFilters = new LinkedHashMap<>(); + @CheckForNull public Date getSince() { return since; } - public ActivityQuery setSince(Date since) { + public ActivityQuery setSince(@Nullable Date since) { this.since = since; return this; } + @CheckForNull public Date getTo() { return to; } - public ActivityQuery setTo(Date to) { + public ActivityQuery setTo(@Nullable Date to) { this.to = to; return this; } - public Collection<Activity.Type> getTypes() { + public Collection<String> getTypes() { return types; } - public ActivityQuery setTypes(Collection<Activity.Type> types) { - this.types = types; + public ActivityQuery setTypes(@Nullable Collection<String> types) { + this.types.clear(); + if (types != null) { + this.types.addAll(types); + } + return this; + } + + public Map<String, Object> getDataOrFilters() { + return dataOrFilters; + } + + public ActivityQuery addDataOrFilter(String dataKey, Object dataValue) { + dataOrFilters.put(dataKey, dataValue); return this; } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityResultSetIterator.java b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityResultSetIterator.java new file mode 100644 index 00000000000..701d649ff8f --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/index/ActivityResultSetIterator.java @@ -0,0 +1,86 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import org.apache.commons.lang.StringUtils; +import org.sonar.api.utils.KeyValueFormat; +import org.sonar.server.db.DbClient; +import org.sonar.server.db.ResultSetIterator; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.HashMap; + +/** + * Scrolls over table ACTIVITIES and reads documents to populate + * the index "activities/activity" + */ +class ActivityResultSetIterator extends ResultSetIterator<ActivityDoc> { + + private static final String[] FIELDS = { + // column 1 + "log_key", + "log_action", + "log_message", + "data_field", + "user_login", + "log_type", + "created_at" + }; + + private static final String SQL_ALL = "select " + StringUtils.join(FIELDS, ",") + " from activities "; + + private static final String SQL_AFTER_DATE = SQL_ALL + " where created_at>=?"; + + private ActivityResultSetIterator(PreparedStatement stmt) throws SQLException { + super(stmt); + } + + static ActivityResultSetIterator create(DbClient dbClient, Connection connection, long afterDate) { + try { + String sql = afterDate > 0L ? SQL_AFTER_DATE : SQL_ALL; + PreparedStatement stmt = dbClient.newScrollingSelectStatement(connection, sql); + if (afterDate > 0L) { + stmt.setTimestamp(1, new Timestamp(afterDate)); + } + return new ActivityResultSetIterator(stmt); + } catch (SQLException e) { + throw new IllegalStateException("Fail to prepare SQL request to select activities", e); + } + } + + @Override + protected ActivityDoc read(ResultSet rs) throws SQLException { + ActivityDoc doc = new ActivityDoc(new HashMap<String, Object>(10)); + + // all the fields must be present, even if value is null + doc.setKey(rs.getString(1)); + doc.setAction(rs.getString(2)); + doc.setMessage(rs.getString(3)); + doc.setDetails(KeyValueFormat.parse(rs.getString(4))); + doc.setLogin(rs.getString(5)); + doc.setType(rs.getString(6)); + doc.setCreatedAt(rs.getTimestamp(7)); + return doc; + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/ws/ActivityMapping.java b/server/sonar-server/src/main/java/org/sonar/server/activity/ws/ActivityMapping.java index aee5b31cdc6..07a756335cf 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/ws/ActivityMapping.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/ws/ActivityMapping.java @@ -20,9 +20,8 @@ package org.sonar.server.activity.ws; import org.sonar.api.utils.text.JsonWriter; -import org.sonar.core.activity.Activity; import org.sonar.server.activity.index.ActivityDoc; -import org.sonar.server.activity.index.ActivityNormalizer; +import org.sonar.server.activity.index.ActivityIndexDefinition; import org.sonar.server.search.QueryContext; import org.sonar.server.search.ws.BaseMapping; @@ -34,16 +33,16 @@ import java.util.Map; public class ActivityMapping extends BaseMapping<ActivityDoc, Object> { public ActivityMapping() { - map("type", ActivityNormalizer.LogFields.TYPE.field()); - map("action", ActivityNormalizer.LogFields.ACTION.field()); - mapDateTime("createdAt", ActivityNormalizer.LogFields.CREATED_AT.field()); - map("login", ActivityNormalizer.LogFields.LOGIN.field()); - map("message", ActivityNormalizer.LogFields.MESSAGE.field()); - map("details", new IndexMapper<ActivityDoc, Object>(ActivityNormalizer.LogFields.DETAILS.field()) { + map("type", ActivityIndexDefinition.FIELD_TYPE); + map("action", ActivityIndexDefinition.FIELD_ACTION); + mapDateTime("createdAt", ActivityIndexDefinition.FIELD_CREATED_AT); + map("login", ActivityIndexDefinition.FIELD_LOGIN); + map("message", ActivityIndexDefinition.FIELD_MESSAGE); + map("details", new IndexMapper<ActivityDoc, Object>(ActivityIndexDefinition.FIELD_DETAILS) { @Override public void write(JsonWriter json, ActivityDoc activity, Object context) { json.name("details").beginObject(); - for (Map.Entry<String, String> detail : activity.details().entrySet()) { + for (Map.Entry<String, String> detail : activity.getDetails().entrySet()) { json.prop(detail.getKey(), detail.getValue()); } json.endObject(); @@ -51,8 +50,8 @@ public class ActivityMapping extends BaseMapping<ActivityDoc, Object> { }); } - public void write(Activity activity, JsonWriter writer, QueryContext context) { - doWrite((ActivityDoc) activity, null, writer, context); + public void write(ActivityDoc activity, JsonWriter writer, QueryContext context) { + doWrite(activity, null, writer, context); } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/activity/ws/SearchAction.java b/server/sonar-server/src/main/java/org/sonar/server/activity/ws/SearchAction.java index 256028e0209..0bb0647f753 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/activity/ws/SearchAction.java +++ b/server/sonar-server/src/main/java/org/sonar/server/activity/ws/SearchAction.java @@ -19,34 +19,30 @@ */ package org.sonar.server.activity.ws; -import org.apache.commons.lang.StringUtils; import org.sonar.api.server.ws.Request; import org.sonar.api.server.ws.RequestHandler; import org.sonar.api.server.ws.Response; import org.sonar.api.server.ws.WebService; import org.sonar.api.utils.text.JsonWriter; -import org.sonar.core.activity.Activity; -import org.sonar.server.activity.ActivityService; +import org.sonar.server.activity.Activity; +import org.sonar.server.activity.index.ActivityDoc; +import org.sonar.server.activity.index.ActivityIndex; import org.sonar.server.activity.index.ActivityQuery; +import org.sonar.server.es.SearchOptions; +import org.sonar.server.es.SearchResult; import org.sonar.server.search.QueryContext; -import org.sonar.server.search.Result; -import org.sonar.server.search.ws.SearchOptions; -/** - * @since 4.4 - */ public class SearchAction implements RequestHandler { public static final String PARAM_TYPE = "type"; - public static final String SEARCH_ACTION = "search"; - private final ActivityService logService; - private final ActivityMapping mapping; + private final ActivityIndex activityIndex; + private final ActivityMapping docToJsonMapping; - public SearchAction(ActivityService logService, ActivityMapping mapping) { - this.logService = logService; - this.mapping = mapping; + public SearchAction(ActivityIndex activityIndex, ActivityMapping docToJsonMapping) { + this.activityIndex = activityIndex; + this.docToJsonMapping = docToJsonMapping; } void define(WebService.NewController controller) { @@ -57,36 +53,34 @@ public class SearchAction implements RequestHandler { .setInternal(true) .setHandler(this); - // Other parameters action.createParam(PARAM_TYPE) - .setDescription("Types of activities to search") - .setPossibleValues(Activity.Type.values()) - .setDefaultValue(StringUtils.join(Activity.Type.values(), ",")); + .setDescription("Activity type") + .setPossibleValues(Activity.Type.values()); - // Generic search parameters - SearchOptions.defineFieldsParam(action, mapping.supportedFields()); - - SearchOptions.definePageParams(action); + action.addPagingParams(10); + action.addFieldsParam(docToJsonMapping.supportedFields()); } @Override public void handle(Request request, Response response) { - ActivityQuery query = logService.newActivityQuery(); - SearchOptions searchOptions = SearchOptions.create(request); - QueryContext queryContext = mapping.newQueryOptions(searchOptions); + ActivityQuery query = new ActivityQuery(); + query.setTypes(request.paramAsStrings(PARAM_TYPE)); + + SearchOptions options = new SearchOptions(); + options.setPage(request.mandatoryParamAsInt(WebService.Param.PAGE), request.mandatoryParamAsInt(WebService.Param.PAGE_SIZE)); - Result<Activity> results = logService.search(query, queryContext); + SearchResult<ActivityDoc> results = activityIndex.search(query, options); JsonWriter json = response.newJsonWriter().beginObject(); - searchOptions.writeStatistics(json, results); - writeLogs(results, json, queryContext); + options.writeJson(json, results.getTotal()); + writeActivities(results, json, new QueryContext().setFieldsToReturn(request.paramAsStrings(WebService.Param.FIELDS))); json.endObject().close(); } - private void writeLogs(Result<Activity> result, JsonWriter json, QueryContext context) { + private void writeActivities(SearchResult<ActivityDoc> docs, JsonWriter json, QueryContext context) { json.name("logs").beginArray(); - for (Activity log : result.getHits()) { - mapping.write(log, json, context); + for (ActivityDoc doc : docs.getDocs()) { + docToJsonMapping.write(doc, json, context); } json.endArray(); } diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java index 8787e16ec94..cdaca50a7d1 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java @@ -31,11 +31,11 @@ import org.sonar.api.utils.log.Logger; import org.sonar.api.utils.log.Loggers; import org.sonar.api.utils.log.Profiler; import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.core.activity.Activity; import org.sonar.core.component.ComponentDto; import org.sonar.core.computation.db.AnalysisReportDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; import org.sonar.server.computation.step.ComputationStep; import org.sonar.server.computation.step.ComputationSteps; @@ -44,6 +44,9 @@ import org.sonar.server.db.DbClient; import java.io.File; import java.io.IOException; +import static org.sonar.api.utils.DateUtils.formatDateTimeNullSafe; +import static org.sonar.api.utils.DateUtils.longToDate; + public class ComputationService implements ServerComponent { private static final Logger LOG = Loggers.get(ComputationService.class); @@ -87,7 +90,7 @@ public class ComputationService implements ServerComponent { } finally { item.dto.setFinishedAt(system.now()); - logActivity(item.dto, project); + saveActivity(item.dto, project); profiler.stopInfo(); } } @@ -117,14 +120,19 @@ public class ComputationService implements ServerComponent { } } - private void logActivity(AnalysisReportDto report, ComponentDto project) { - DbSession session = dbClient.openSession(false); - try { - report.setFinishedAt(System2.INSTANCE.now()); - activityService.write(session, Activity.Type.ANALYSIS_REPORT, new ReportActivity(report, project)); - session.commit(); - } finally { - MyBatis.closeQuietly(session); - } + private void saveActivity(AnalysisReportDto report, ComponentDto project) { + Activity activity = new Activity(); + activity.setType(Activity.Type.ANALYSIS_REPORT); + activity.setAction("LOG_ANALYSIS_REPORT"); + activity + .setData("key", String.valueOf(report.getId())) + .setData("projectKey", project.key()) + .setData("projectName", project.name()) + .setData("projectUuid", project.uuid()) + .setData("status", String.valueOf(report.getStatus())) + .setData("submittedAt", formatDateTimeNullSafe(longToDate(report.getCreatedAt()))) + .setData("startedAt", formatDateTimeNullSafe(longToDate(report.getStartedAt()))) + .setData("finishedAt", formatDateTimeNullSafe(longToDate(report.getFinishedAt()))); + activityService.save(activity); } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/ReportActivity.java b/server/sonar-server/src/main/java/org/sonar/server/computation/ReportActivity.java deleted file mode 100644 index b4d7165a82f..00000000000 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/ReportActivity.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -package org.sonar.server.computation; - -import com.google.common.collect.ImmutableMap; -import org.sonar.core.activity.ActivityLog; -import org.sonar.core.component.ComponentDto; -import org.sonar.core.computation.db.AnalysisReportDto; - -import java.util.Map; - -import static org.sonar.api.utils.DateUtils.formatDateTimeNullSafe; -import static org.sonar.api.utils.DateUtils.longToDate; - -public class ReportActivity implements ActivityLog { - - private static final String ACTION = "LOG_ANALYSIS_REPORT"; - - private final AnalysisReportDto report; - private final ComponentDto project; - - public ReportActivity(AnalysisReportDto report, ComponentDto project) { - this.report = report; - this.project = project; - } - - @Override - public Map<String, String> getDetails() { - return ImmutableMap.<String, String>builder() - .put("key", String.valueOf(report.getId())) - .put("projectKey", project.key()) - .put("projectName", project.name()) - .put("projectUuid", project.uuid()) - .put("status", String.valueOf(report.getStatus())) - .put("submittedAt", formatDateTimeNullSafe(longToDate(report.getCreatedAt()))) - .put("startedAt", formatDateTimeNullSafe(longToDate(report.getStartedAt()))) - .put("finishedAt", formatDateTimeNullSafe(longToDate(report.getFinishedAt()))) - .build(); - } - - @Override - public String getAction() { - return ACTION; - } -} diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/ws/HistoryWsAction.java b/server/sonar-server/src/main/java/org/sonar/server/computation/ws/HistoryWsAction.java index eec1336a157..82135a2c15f 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/ws/HistoryWsAction.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/ws/HistoryWsAction.java @@ -25,29 +25,28 @@ import org.sonar.api.server.ws.RequestHandler; import org.sonar.api.server.ws.Response; import org.sonar.api.server.ws.WebService; import org.sonar.api.utils.text.JsonWriter; -import org.sonar.core.activity.Activity; import org.sonar.core.permission.GlobalPermissions; -import org.sonar.server.activity.ActivityService; +import org.sonar.server.activity.Activity; +import org.sonar.server.activity.index.ActivityDoc; +import org.sonar.server.activity.index.ActivityIndex; import org.sonar.server.activity.index.ActivityQuery; -import org.sonar.server.activity.ws.ActivityMapping; -import org.sonar.server.search.QueryContext; -import org.sonar.server.search.Result; -import org.sonar.server.search.ws.SearchOptions; +import org.sonar.server.es.SearchOptions; +import org.sonar.server.es.SearchResult; +import org.sonar.server.issue.ws.IssuesWs; import org.sonar.server.user.UserSession; import java.util.Arrays; import java.util.Map; +// FIXME replace by api/activities/search public class HistoryWsAction implements ComputationWsAction, RequestHandler { public static final String PARAM_TYPE = "type"; - private final ActivityService activityService; - private final ActivityMapping mapping; + private final ActivityIndex activityIndex; - public HistoryWsAction(ActivityService activityService, ActivityMapping mapping) { - this.activityService = activityService; - this.mapping = mapping; + public HistoryWsAction(ActivityIndex activityIndex) { + this.activityIndex = activityIndex; } @Override @@ -59,38 +58,31 @@ public class HistoryWsAction implements ComputationWsAction, RequestHandler { .setInternal(true) .setHandler(this); - // Generic search parameters - SearchOptions.defineFieldsParam(action, mapping.supportedFields()); - SearchOptions.definePageParams(action); + action.addPagingParams(10); } @Override public void handle(Request request, Response response) { - checkUserRights(); - - ActivityQuery query = activityService.newActivityQuery(); - query.setTypes(Arrays.asList(Activity.Type.ANALYSIS_REPORT)); + UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN); - SearchOptions searchOptions = SearchOptions.create(request); - QueryContext queryContext = mapping.newQueryOptions(searchOptions); + ActivityQuery query = new ActivityQuery(); + query.setTypes(Arrays.asList(Activity.Type.ANALYSIS_REPORT.name())); - Result<Activity> results = activityService.search(query, queryContext); + SearchOptions options = new SearchOptions(); + options.setPage(request.mandatoryParamAsInt(IssuesWs.Param.PAGE), request.mandatoryParamAsInt(IssuesWs.Param.PAGE_SIZE)); + SearchResult<ActivityDoc> results = activityIndex.search(query, options); JsonWriter json = response.newJsonWriter().beginObject(); - searchOptions.writeStatistics(json, results); + options.writeJson(json, results.getTotal()); writeReports(results, json); json.endObject().close(); } - private void checkUserRights() { - UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN); - } - - private void writeReports(Result<Activity> result, JsonWriter json) { + private void writeReports(SearchResult<ActivityDoc> result, JsonWriter json) { json.name("reports").beginArray(); - for (Activity reportActivity : result.getHits()) { + for (ActivityDoc doc : result.getDocs()) { json.beginObject(); - for (Map.Entry<String, String> detail : reportActivity.details().entrySet()) { + for (Map.Entry<String, String> detail : doc.getDetails().entrySet()) { json.prop(detail.getKey(), detail.getValue()); } json.endObject(); diff --git a/server/sonar-server/src/main/java/org/sonar/server/db/migrations/v44/ChangeLogMigration.java b/server/sonar-server/src/main/java/org/sonar/server/db/migrations/v44/ChangeLogMigration.java index 41b28a488dd..ca1ca126cd8 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/db/migrations/v44/ChangeLogMigration.java +++ b/server/sonar-server/src/main/java/org/sonar/server/db/migrations/v44/ChangeLogMigration.java @@ -21,13 +21,15 @@ package org.sonar.server.db.migrations.v44; import org.apache.commons.lang.StringUtils; import org.sonar.api.rule.RuleKey; -import org.sonar.core.activity.Activity; +import org.sonar.api.utils.KeyValueFormat; +import org.sonar.api.utils.internal.Uuids; import org.sonar.core.activity.db.ActivityDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.migration.v44.ChangeLog; import org.sonar.core.persistence.migration.v44.Migration44Mapper; import org.sonar.core.qualityprofile.db.ActiveRuleKey; import org.sonar.core.rule.SeverityUtil; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.db.ActivityDao; import org.sonar.server.db.DbClient; import org.sonar.server.db.migrations.DatabaseMigration; @@ -99,11 +101,16 @@ public class ChangeLogMigration implements DatabaseMigration { } private void saveActiveRuleChange(DbSession session, ActiveRuleChange ruleChange, String author, Date currentTimeStamp) { - ActivityDto activity = ActivityDto.createFor(ruleChange); - activity.setType(Activity.Type.QPROFILE); - activity.setAuthor(author); - activity.setCreatedAt(currentTimeStamp); - dao.insert(session, activity); + Activity activity = ruleChange.toActivity(); + ActivityDto dto = new ActivityDto(); + dto.setKey(Uuids.create()); + dto.setType(Activity.Type.QPROFILE.name()); + dto.setAction(activity.getAction()); + dto.setMessage(activity.getMessage()); + dto.setAuthor(author); + dto.setData(KeyValueFormat.format(activity.getData())); + dto.setCreatedAt(currentTimeStamp); + dao.insert(session, dto); } private void processRuleChange(ActiveRuleChange ruleChange, ChangeLog change) { diff --git a/server/sonar-server/src/main/java/org/sonar/server/es/NewIndex.java b/server/sonar-server/src/main/java/org/sonar/server/es/NewIndex.java index 4459fd5b3db..22493030b9e 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/es/NewIndex.java +++ b/server/sonar-server/src/main/java/org/sonar/server/es/NewIndex.java @@ -96,6 +96,10 @@ public class NewIndex { return setProperty(fieldName, ImmutableMap.of("type", "long")); } + public NewIndexType createDynamicNestedField(String fieldName) { + return setProperty(fieldName, ImmutableMap.of("type", "nested", "dynamic", "true")); + } + public NewIndexType createShortField(String fieldName) { return setProperty(fieldName, ImmutableMap.of("type", "short")); } diff --git a/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueResultSetIterator.java b/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueResultSetIterator.java index 7f24b0a56cd..76de0d82363 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueResultSetIterator.java +++ b/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueResultSetIterator.java @@ -150,7 +150,7 @@ class IssueResultSetIterator extends ResultSetIterator<IssueDoc> { String key = rs.getString(1); String projectUuid = rs.getString(2); - // all the keys must be present, even if value is null + // all the fields must be present, even if value is null doc.setKey(key); doc.setProjectUuid(projectUuid); doc.setTechnicalUpdateDate(new Date(rs.getLong(3))); diff --git a/server/sonar-server/src/main/java/org/sonar/server/issue/ws/SearchAction.java b/server/sonar-server/src/main/java/org/sonar/server/issue/ws/SearchAction.java index c5e4b4770a0..9898640cb76 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/issue/ws/SearchAction.java +++ b/server/sonar-server/src/main/java/org/sonar/server/issue/ws/SearchAction.java @@ -63,7 +63,13 @@ import org.sonar.server.user.UserSession; import javax.annotation.CheckForNull; import javax.annotation.Nullable; -import java.util.*; +import java.util.Collection; +import java.util.Collections; +import java.util.Date; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; import static com.google.common.collect.Lists.newArrayList; import static com.google.common.collect.Maps.newHashMap; @@ -263,7 +269,7 @@ public class SearchAction implements BaseIssuesWsAction { @Override public final void handle(Request request, Response response) throws Exception { SearchOptions options = new SearchOptions(); - options.setPage(request.mandatoryParamAsInt(IssuesWs.Param.PAGE), request.mandatoryParamAsInt(IssuesWs.Param.PAGE_SIZE)); + options.setPage(request.mandatoryParamAsInt(WebService.Param.PAGE), request.mandatoryParamAsInt(WebService.Param.PAGE_SIZE)); options.addFacets(request.paramAsStrings(WebService.Param.FACETS)); IssueQuery query = issueQueryService.createFromRequest(request); diff --git a/server/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java b/server/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java index cf8302be667..dd409d3e8ae 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java +++ b/server/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java @@ -78,7 +78,8 @@ import org.sonar.server.activity.ActivityService; import org.sonar.server.activity.RubyQProfileActivityService; import org.sonar.server.activity.db.ActivityDao; import org.sonar.server.activity.index.ActivityIndex; -import org.sonar.server.activity.index.ActivityNormalizer; +import org.sonar.server.activity.index.ActivityIndexDefinition; +import org.sonar.server.activity.index.ActivityIndexer; import org.sonar.server.activity.ws.ActivitiesWebService; import org.sonar.server.activity.ws.ActivityMapping; import org.sonar.server.authentication.ws.AuthenticationWs; @@ -423,10 +424,6 @@ class ServerComponents { IssueIndex.class, IssueDao.class, - // Activity - ActivityService.class, - ActivityNormalizer.class, - ActivityIndex.class, ActivityDao.class )); components.addAll(CorePropertyDefinitions.all()); @@ -491,6 +488,12 @@ class ServerComponents { pico.addSingleton(IndexRegistry.class); pico.addSingleton(IndexCreator.class); + // Activity + pico.addSingleton(ActivityService.class); + pico.addSingleton(ActivityIndexDefinition.class); + pico.addSingleton(ActivityIndexer.class); + pico.addSingleton(ActivityIndex.class); + // batch pico.addSingleton(BatchIndex.class); pico.addSingleton(GlobalRepositoryAction.class); diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java index 44391663eec..ae29ee90da5 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java @@ -22,16 +22,15 @@ package org.sonar.server.qualityprofile; import com.google.common.base.Objects; import com.google.common.collect.Maps; import org.apache.commons.lang.StringUtils; -import org.sonar.core.activity.ActivityLog; import org.sonar.core.qualityprofile.db.ActiveRuleKey; +import org.sonar.server.activity.Activity; import javax.annotation.CheckForNull; import javax.annotation.Nullable; -import java.util.HashMap; import java.util.Map; -public class ActiveRuleChange implements ActivityLog { +public class ActiveRuleChange { public static enum Type { ACTIVATED, DEACTIVATED, UPDATED @@ -91,26 +90,26 @@ public class ActiveRuleChange implements ActivityLog { return this; } - @Override - public Map<String, String> getDetails() { - HashMap<String, String> details = new HashMap<String, String>(); - - details.put("key", getKey().toString()); - details.put("ruleKey", getKey().ruleKey().toString()); - details.put("profileKey", getKey().qProfile().toString()); + public Activity toActivity() { + Activity activity = new Activity(); + activity.setType(Activity.Type.QPROFILE); + activity.setAction(type.name()); + activity.setData("key", getKey().toString()); + activity.setData("ruleKey", getKey().ruleKey().toString()); + activity.setData("profileKey", getKey().qProfile().toString()); for (Map.Entry<String, String> param : parameters.entrySet()) { if (!param.getKey().isEmpty()) { - details.put("param_" + param.getKey(), param.getValue()); + activity.setData("param_" + param.getKey(), param.getValue()); } } if (StringUtils.isNotEmpty(severity)) { - details.put("severity", severity); + activity.setData("severity", severity); } if (inheritance != null) { - details.put("inheritance", inheritance.name()); + activity.setData("inheritance", inheritance.name()); } - return details; + return activity; } public static ActiveRuleChange createFor(Type type, ActiveRuleKey key) { @@ -127,9 +126,4 @@ public class ActiveRuleChange implements ActivityLog { .add("parameters", parameters) .toString(); } - - @Override - public String getAction() { - return type.name(); - } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivity.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivity.java index 8b294dfa62f..fa49d3695e4 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivity.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivity.java @@ -21,19 +21,17 @@ package org.sonar.server.qualityprofile; import com.google.common.collect.Maps; import org.sonar.api.rule.RuleKey; -import org.sonar.core.activity.Activity; import org.sonar.server.activity.index.ActivityDoc; -import org.sonar.server.activity.index.ActivityNormalizer; +import org.sonar.server.activity.index.ActivityIndexDefinition; import javax.annotation.CheckForNull; import javax.annotation.Nullable; - import java.util.Map; /** * @since 4.4 */ -public class QProfileActivity extends ActivityDoc implements Activity { +public class QProfileActivity extends ActivityDoc { private String ruleName = null; private String authorName = null; @@ -77,8 +75,8 @@ public class QProfileActivity extends ActivityDoc implements Activity { @Override @CheckForNull - public String login() { - return getNullableField(ActivityNormalizer.LogFields.LOGIN.field()); + public String getLogin() { + return getNullableField(ActivityIndexDefinition.FIELD_LOGIN); } @CheckForNull diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivityQuery.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivityQuery.java index cc303dab5a1..5cce6da31fe 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivityQuery.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileActivityQuery.java @@ -19,32 +19,30 @@ */ package org.sonar.server.qualityprofile; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Lists; -import org.sonar.core.activity.Activity; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.index.ActivityQuery; -import java.util.Collection; +import javax.annotation.CheckForNull; +import javax.annotation.Nullable; +import java.util.Arrays; /** * @since 4.4 */ public class QProfileActivityQuery extends ActivityQuery { - Collection<String> qprofileKeys; - public QProfileActivityQuery() { super(); - this.setTypes(ImmutableSet.of(Activity.Type.QPROFILE)); - qprofileKeys = Lists.newArrayList(); + setTypes(Arrays.asList(Activity.Type.QPROFILE.name())); } - public Collection<String> getQprofileKeys() { - return qprofileKeys; + @CheckForNull + public String getQprofileKey() { + return (String)getDataOrFilters().get("profileKey"); } - public QProfileActivityQuery setQprofileKeys(Collection<String> qprofileKeys) { - this.qprofileKeys = qprofileKeys; + public QProfileActivityQuery setQprofileKey(@Nullable String qprofileKey) { + addDataOrFilter("profileKey", qprofileKey); return this; } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileService.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileService.java index 0e0a7acb4ac..42a4ad0f0a3 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileService.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/QProfileService.java @@ -20,9 +20,6 @@ package org.sonar.server.qualityprofile; import org.elasticsearch.action.search.SearchResponse; -import org.elasticsearch.index.query.FilterBuilders; -import org.elasticsearch.index.query.OrFilterBuilder; -import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.search.SearchHit; import org.sonar.api.ServerComponent; import org.sonar.core.permission.GlobalPermissions; @@ -33,15 +30,13 @@ import org.sonar.core.rule.RuleDto; import org.sonar.core.user.UserDto; import org.sonar.server.activity.index.ActivityIndex; import org.sonar.server.db.DbClient; +import org.sonar.server.es.SearchOptions; import org.sonar.server.rule.index.RuleQuery; -import org.sonar.server.search.IndexClient; -import org.sonar.server.search.QueryContext; import org.sonar.server.search.Result; import org.sonar.server.user.UserSession; import javax.annotation.CheckForNull; import javax.annotation.Nullable; - import java.io.Reader; import java.io.StringReader; import java.io.StringWriter; @@ -53,7 +48,7 @@ import java.util.Map; public class QProfileService implements ServerComponent { private final DbClient db; - private final IndexClient index; + private final ActivityIndex activityIndex; private final RuleActivator ruleActivator; private final QProfileFactory factory; private final QProfileBackuper backuper; @@ -61,10 +56,10 @@ public class QProfileService implements ServerComponent { private final QProfileReset reset; private final QProfileExporters exporters; - public QProfileService(DbClient db, IndexClient index, RuleActivator ruleActivator, QProfileFactory factory, + public QProfileService(DbClient db, ActivityIndex activityIndex, RuleActivator ruleActivator, QProfileFactory factory, QProfileBackuper backuper, QProfileCopier copier, QProfileReset reset, QProfileExporters exporters) { this.db = db; - this.index = index; + this.activityIndex = activityIndex; this.ruleActivator = ruleActivator; this.factory = factory; this.backuper = backuper; @@ -214,23 +209,17 @@ public class QProfileService implements ServerComponent { UserSession.get().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN); } - public Result<QProfileActivity> searchActivities(QProfileActivityQuery query, QueryContext options) { + public Result<QProfileActivity> searchActivities(QProfileActivityQuery query, SearchOptions options) { DbSession session = db.openSession(false); try { - OrFilterBuilder activityFilter = FilterBuilders.orFilter(); - for (String profileKey : query.getQprofileKeys()) { - activityFilter.add(FilterBuilders.nestedFilter("details", - QueryBuilders.matchQuery("details.profileKey", profileKey))); - } - - SearchResponse response = index.get(ActivityIndex.class).search(query, options, activityFilter); + SearchResponse response = activityIndex.doSearch(query, options); Result<QProfileActivity> result = new Result<QProfileActivity>(response); for (SearchHit hit : response.getHits().getHits()) { QProfileActivity profileActivity = new QProfileActivity(hit.getSource()); RuleDto ruleDto = db.ruleDao().getNullableByKey(session, profileActivity.ruleKey()); profileActivity.ruleName(ruleDto != null ? ruleDto.getName() : null); - String login = profileActivity.login(); + String login = profileActivity.getLogin(); if (login != null) { UserDto user = db.userDao().selectActiveUserByLogin(login, session); profileActivity.authorName(user != null ? user.getName() : null); diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java index 96bc7511f2f..757334f7100 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java @@ -23,7 +23,6 @@ import com.google.common.base.Splitter; import com.google.common.collect.Lists; import org.sonar.api.ServerComponent; import org.sonar.api.server.rule.RuleParamType; -import org.sonar.core.activity.Activity; import org.sonar.core.persistence.DbSession; import org.sonar.core.qualityprofile.db.ActiveRuleDto; import org.sonar.core.qualityprofile.db.ActiveRuleKey; @@ -63,16 +62,16 @@ public class RuleActivator implements ServerComponent { private final TypeValidations typeValidations; private final RuleActivatorContextFactory contextFactory; private final IndexClient index; - private final ActivityService log; + private final ActivityService activityService; public RuleActivator(DbClient db, IndexClient index, RuleActivatorContextFactory contextFactory, TypeValidations typeValidations, - ActivityService log) { + ActivityService activityService) { this.db = db; this.index = index; this.contextFactory = contextFactory; this.typeValidations = typeValidations; - this.log = log; + this.activityService = activityService; } public List<ActiveRuleChange> activate(DbSession dbSession, RuleActivation activation, String profileKey) { @@ -240,7 +239,7 @@ public class RuleActivator implements ServerComponent { } else if (change.getType() == ActiveRuleChange.Type.UPDATED) { activeRule = doUpdate(change, context, dbSession); } - log.write(dbSession, Activity.Type.QPROFILE, change); + activityService.save(change.toActivity()); return activeRule; } diff --git a/server/sonar-server/src/main/java/org/sonar/server/search/BaseIndex.java b/server/sonar-server/src/main/java/org/sonar/server/search/BaseIndex.java index 1a03ce18662..65d82a82998 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/search/BaseIndex.java +++ b/server/sonar-server/src/main/java/org/sonar/server/search/BaseIndex.java @@ -55,6 +55,10 @@ import javax.annotation.Nullable; import java.io.Serializable; import java.util.*; +/** + * @deprecated replaced by {@link org.sonar.server.es.BaseIndex} + */ +@Deprecated public abstract class BaseIndex<DOMAIN, DTO extends Dto<KEY>, KEY extends Serializable> implements Index<DOMAIN, DTO, KEY> { @@ -215,7 +219,7 @@ public abstract class BaseIndex<DOMAIN, DTO extends Dto<KEY>, KEY extends Serial protected abstract String getKeyValue(KEY key); public final Settings getIndexSettings() { - ImmutableSettings.Builder settings = this.addCustomIndexSettings(this.getBaseIndexSettings()); + ImmutableSettings.Builder settings = this.getBaseIndexSettings(); // In case there is a replication factor set by the index, // it is removed since we're using global cluster state @@ -225,10 +229,6 @@ public abstract class BaseIndex<DOMAIN, DTO extends Dto<KEY>, KEY extends Serial return settings.build(); } - protected ImmutableSettings.Builder addCustomIndexSettings(ImmutableSettings.Builder baseIndexSettings) { - return baseIndexSettings; - } - protected abstract Map mapProperties(); protected abstract Map mapKey(); diff --git a/server/sonar-server/src/main/java/org/sonar/server/search/IndexDefinition.java b/server/sonar-server/src/main/java/org/sonar/server/search/IndexDefinition.java index fc9b36ebe17..ffafa74a18a 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/search/IndexDefinition.java +++ b/server/sonar-server/src/main/java/org/sonar/server/search/IndexDefinition.java @@ -40,7 +40,6 @@ public class IndexDefinition { public static final IndexDefinition RULE = new IndexDefinition("rules", "rule"); public static final IndexDefinition ACTIVE_RULE = new IndexDefinition("rules", "activeRule"); public static final IndexDefinition ISSUES = new IndexDefinition("issues", "issue"); - public static final IndexDefinition LOG = new IndexDefinition("logs", "sonarLog"); // Only used for test static final IndexDefinition TEST = new IndexDefinition("test", "test"); diff --git a/server/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java b/server/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java index 2aaa1e874b7..b4499a4d20c 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java +++ b/server/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java @@ -23,7 +23,7 @@ package org.sonar.server.search; import org.sonar.api.utils.log.Logger; import org.sonar.api.utils.log.Loggers; import org.sonar.core.persistence.DbSession; -import org.sonar.server.activity.index.ActivityIndex; +import org.sonar.server.activity.index.ActivityIndexer; import org.sonar.server.db.Dao; import org.sonar.server.db.DbClient; import org.sonar.server.issue.index.IssueAuthorizationIndexer; @@ -47,9 +47,11 @@ public class IndexSynchronizer { private final IssueIndexer issueIndexer; private final UserIndexer userIndexer; private final ViewIndexer viewIndexer; + private final ActivityIndexer activityIndexer; public IndexSynchronizer(DbClient db, IndexClient index, SourceLineIndexer sourceLineIndexer, - IssueAuthorizationIndexer issueAuthorizationIndexer, IssueIndexer issueIndexer, UserIndexer userIndexer, ViewIndexer viewIndexer) { + IssueAuthorizationIndexer issueAuthorizationIndexer, IssueIndexer issueIndexer, + UserIndexer userIndexer, ViewIndexer viewIndexer, ActivityIndexer activityIndexer) { this.db = db; this.index = index; this.sourceLineIndexer = sourceLineIndexer; @@ -57,6 +59,7 @@ public class IndexSynchronizer { this.issueIndexer = issueIndexer; this.userIndexer = userIndexer; this.viewIndexer = viewIndexer; + this.activityIndexer = activityIndexer; } public void execute() { @@ -64,12 +67,14 @@ public class IndexSynchronizer { try { synchronize(session, db.ruleDao(), index.get(RuleIndex.class)); synchronize(session, db.activeRuleDao(), index.get(ActiveRuleIndex.class)); - synchronize(session, db.activityDao(), index.get(ActivityIndex.class)); session.commit(); } finally { session.close(); } + LOG.info("Index activities"); + activityIndexer.index(); + LOG.info("Index issues"); issueAuthorizationIndexer.index(); issueIndexer.index(); diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityBackendMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityBackendMediumTest.java deleted file mode 100644 index d89298a63db..00000000000 --- a/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityBackendMediumTest.java +++ /dev/null @@ -1,215 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.server.activity; - -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Iterables; -import org.elasticsearch.action.search.SearchResponse; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.ActivityLog; -import org.sonar.core.persistence.DbSession; -import org.sonar.server.activity.db.ActivityDao; -import org.sonar.server.activity.index.ActivityIndex; -import org.sonar.server.activity.index.ActivityQuery; -import org.sonar.server.db.DbClient; -import org.sonar.server.platform.Platform; -import org.sonar.server.search.QueryContext; -import org.sonar.server.search.Result; -import org.sonar.server.tester.ServerTester; - -import java.util.Iterator; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - -public class ActivityBackendMediumTest { - - @ClassRule - public static ServerTester tester = new ServerTester(); - - ActivityService service = tester.get(ActivityService.class); - ActivityDao dao = tester.get(ActivityDao.class); - ActivityIndex index = tester.get(ActivityIndex.class); - DbSession dbSession; - - @Before - public void before() { - tester.clearDbAndIndexes(); - dbSession = tester.get(DbClient.class).openSession(false); - } - - @After - public void after() { - dbSession.close(); - } - - @Test - public void insert_find_text_log() throws InterruptedException { - final String testValue = "hello world"; - service.write(dbSession, Activity.Type.QPROFILE, testValue); - dbSession.commit(); - assertThat(index.findAll().getTotal()).isEqualTo(1); - - Activity activity = Iterables.getFirst(index.findAll().getHits(), null); - assertThat(activity).isNotNull(); - assertThat(activity.message()).isEqualTo(testValue); - } - - @Test - public void insert_find_loggable_log() { - final String testKey = "message"; - final String testValue = "hello world"; - service.write(dbSession, Activity.Type.QPROFILE, new ActivityLog() { - - @Override - public Map<String, String> getDetails() { - return ImmutableMap.of(testKey, testValue); - } - - @Override - public String getAction() { - return "myAction"; - } - }); - dbSession.commit(); - - assertThat(index.findAll().getTotal()).isEqualTo(1); - - Activity activity = Iterables.getFirst(index.findAll().getHits(), null); - assertThat(activity).isNotNull(); - assertThat(activity.details().get(testKey)).isEqualTo(testValue); - } - - @Test - public void current_time_zone() { - service.write(dbSession, Activity.Type.QPROFILE, "now"); - dbSession.commit(); - - Activity activity = service.search(new ActivityQuery(), new QueryContext()).getHits().get(0); - assertThat(System.currentTimeMillis() - activity.time().getTime()).isLessThan(1000L); - } - - @Test - public void massive_insert() { - - // 0 Assert no logs in DB - assertThat(dao.findAll(dbSession)).hasSize(0); - int max = 35; - final String testValue = "hello world"; - for (int i = 0; i < max; i++) { - - service.write(dbSession, Activity.Type.QPROFILE, testValue + "_" + i); - } - dbSession.commit(); - - // 1. assert both backends have all logs - assertThat(dao.findAll(dbSession)).hasSize(max); - assertThat(index.findAll().getHits()).hasSize(max); - - // 2. assert scrollable - int count = 0; - SearchResponse result = index.search(new ActivityQuery(), new QueryContext().setScroll(true)); - Iterator<Activity> logs = new Result<Activity>(index, result).scroll(); - while (logs.hasNext()) { - logs.next(); - count++; - } - assertThat(count).isEqualTo(max); - - // 3 assert synchronize above IndexQueue threshold - tester.clearIndexes(); - tester.get(Platform.class).executeStartupTasks(); - result = index.search(new ActivityQuery(), new QueryContext().setScroll(true)); - logs = new Result<Activity>(index, result).scroll(); - count = 0; - while (logs.hasNext()) { - logs.next(); - count++; - } - assertThat(count).isEqualTo(max); - - } - - @Test - public void massive_log_insert() { - - // 0 Assert no logs in DB - assertThat(dao.findAll(dbSession)).hasSize(0); - int max = 40; - final String testValue = "hello world"; - for (int i = 0; i < max; i++) { - TestActivityLog log = new TestActivityLog(testValue + "_" + i, Activity.Type.QPROFILE.toString()); - service.write(dbSession, Activity.Type.QPROFILE, log); - } - dbSession.commit(); - - // 1. assert both backends have all logs - assertThat(dao.findAll(dbSession)).hasSize(max); - assertThat(index.findAll().getHits()).hasSize(max); - - // 2. assert scrollable - int count = 0; - SearchResponse result = index.search(new ActivityQuery(), new QueryContext().setScroll(true)); - Iterator<Activity> logs = new Result<Activity>(index, result).scroll(); - while (logs.hasNext()) { - logs.next(); - count++; - } - assertThat(count).isEqualTo(max); - - // 3 assert synchronize above IndexQueue threshold - tester.clearIndexes(); - tester.get(Platform.class).executeStartupTasks(); - result = index.search(new ActivityQuery(), new QueryContext().setScroll(true)); - logs = new Result<Activity>(index, result).scroll(); - count = 0; - while (logs.hasNext()) { - logs.next(); - count++; - } - assertThat(count).isEqualTo(max); - - } - - class TestActivityLog implements ActivityLog { - - private final String name; - private final String action; - - TestActivityLog(String name, String action) { - this.name = name; - this.action = action; - } - - @Override - public Map<String, String> getDetails() { - return ImmutableMap.<String, String>of("name", name); - } - - @Override - public String getAction() { - return action; - } - } -} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceMediumTest.java deleted file mode 100644 index 71fec3c117d..00000000000 --- a/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceMediumTest.java +++ /dev/null @@ -1,217 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.server.activity; - -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Iterables; -import org.elasticsearch.action.search.SearchResponse; -import org.joda.time.DateTime; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.ActivityLog; -import org.sonar.core.activity.db.ActivityDto; -import org.sonar.core.persistence.DbSession; -import org.sonar.server.activity.db.ActivityDao; -import org.sonar.server.activity.index.ActivityIndex; -import org.sonar.server.activity.index.ActivityQuery; -import org.sonar.server.db.DbClient; -import org.sonar.server.search.QueryContext; -import org.sonar.server.search.Result; -import org.sonar.server.tester.ServerTester; - -import java.util.Iterator; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - -public class ActivityServiceMediumTest { - - @ClassRule - public static ServerTester tester = new ServerTester(); - - ActivityService service = tester.get(ActivityService.class); - ActivityDao dao = tester.get(ActivityDao.class); - ActivityIndex index = tester.get(ActivityIndex.class); - DbSession dbSession; - - @Before - public void before() { - tester.clearDbAndIndexes(); - dbSession = tester.get(DbClient.class).openSession(false); - } - - @After - public void after() { - dbSession.close(); - } - - @Test - public void find_all() throws InterruptedException { - service.write(dbSession, Activity.Type.QPROFILE, testValue); - dbSession.commit(); - assertThat(index.findAll().getTotal()).isEqualTo(1); - - Activity activity = Iterables.getFirst(index.findAll().getHits(), null); - assertThat(activity).isNotNull(); - assertThat(activity.message()).isEqualTo(testValue); - } - - @Test - public void search_message_log() throws InterruptedException { - service.write(dbSession, Activity.Type.QPROFILE, testValue); - dbSession.commit(); - assertThat(index.findAll().getTotal()).isEqualTo(1); - - SearchResponse result = index.search(service.newActivityQuery(), new QueryContext()); - assertThat(result.getHits().getTotalHits()).isEqualTo(1L); - Result<Activity> activityResult = new Result<Activity>(index, result); - assertThat(activityResult.getHits().get(0).message()).isEqualTo(testValue); - } - - @Test - public void search_activity_log() throws InterruptedException { - - service.write(dbSession, Activity.Type.QPROFILE, getActivity()); - dbSession.commit(); - assertThat(index.findAll().getTotal()).isEqualTo(1); - - SearchResponse result = index.search(service.newActivityQuery(), new QueryContext()); - assertThat(result.getHits().getTotalHits()).isEqualTo(1L); - Result<Activity> activityResult = new Result<Activity>(index, result); - assertThat(activityResult.getHits().get(0).details().get(test_key)).isEqualTo(test_value); - } - - @Test - public void filter_by_type() { - service.write(dbSession, Activity.Type.NONE, getActivity()); - service.write(dbSession, Activity.Type.SERVER, getActivity()); - service.write(dbSession, Activity.Type.SERVER, testValue); - service.write(dbSession, Activity.Type.QPROFILE, getActivity()); - dbSession.commit(); - - assertThat(service.search(new ActivityQuery(), - new QueryContext()).getHits()).hasSize(4); - - assertThat(service.search(new ActivityQuery() - .setTypes(ImmutableSet.of(Activity.Type.SERVER)), - new QueryContext()).getHits()).hasSize(2); - - assertThat(service.search(new ActivityQuery() - .setTypes(ImmutableSet.of(Activity.Type.QPROFILE)), - new QueryContext()).getHits()).hasSize(1); - } - - @Test - public void filter_by_date() throws InterruptedException { - - DateTime t0 = new DateTime().minusHours(1); - ActivityDto activity = getActivityDto(); - activity.setCreatedAt(t0.toDate()); - dao.insert(dbSession, activity); - activity = getActivityDto(); - activity.setCreatedAt(t0.toDate()); - dao.insert(dbSession, activity); - dbSession.commit(); - DateTime t1 = new DateTime(); - activity = getActivityDto(); - activity.setCreatedAt(t1.toDate()); - dao.insert(dbSession, activity); - dbSession.commit(); - DateTime t2 = new DateTime().plusHours(1); - - assertThat(service.search(new ActivityQuery(), - new QueryContext()).getHits()).hasSize(3); - - assertThat(service.search(new ActivityQuery() - .setSince(t0.minusSeconds(5).toDate()), - new QueryContext()).getHits()).hasSize(3); - - assertThat(service.search(new ActivityQuery() - .setSince(t1.minusSeconds(5).toDate()), - new QueryContext()).getHits()).hasSize(1); - - assertThat(service.search(new ActivityQuery() - .setSince(t2.minusSeconds(5).toDate()), - new QueryContext()).getHits()).hasSize(0); - - assertThat(service.search(new ActivityQuery() - .setTo(t1.minusSeconds(5).toDate()), - new QueryContext()).getHits()).hasSize(2); - - assertThat(service.search(new ActivityQuery() - .setSince(t1.minusSeconds(5).toDate()) - .setTo(t2.plusSeconds(5).toDate()), - new QueryContext()).getHits()).hasSize(1); - } - - private ActivityDto getActivityDto() { - return ActivityDto.createFor(testValue) - .setType(Activity.Type.NONE).setAuthor("testing"); - } - - @Test - public void iterate_all() throws InterruptedException { - int max = QueryContext.DEFAULT_LIMIT + 3; - final String testValue = "hello world"; - for (int i = 0; i < max; i++) { - service.write(dbSession, Activity.Type.QPROFILE, testValue + "_" + i); - } - dbSession.commit(); - - // 0. assert Base case - assertThat(dao.findAll(dbSession)).hasSize(max); - - SearchResponse result = index.search(service.newActivityQuery(), new QueryContext().setScroll(true)); - assertThat(result.getHits().getTotalHits()).isEqualTo(max); - Result<Activity> activityResult = new Result<Activity>(index, result); - - assertThat(activityResult.getTotal()).isEqualTo(max); - assertThat(activityResult.getHits()).hasSize(0); - int count = 0; - Iterator<Activity> logIterator = activityResult.scroll(); - while (logIterator.hasNext()) { - count++; - logIterator.next(); - } - assertThat(count).isEqualTo(max); - } - - final String test_key = "hello"; - final String test_value = "world"; - final String testValue = "hello world"; - - private ActivityLog getActivity() { - return new ActivityLog() { - @Override - public Map<String, String> getDetails() { - return ImmutableMap.of(test_key, test_value); - } - - @Override - public String getAction() { - return "myAction"; - } - }; - } -} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceTest.java new file mode 100644 index 00000000000..58447946cd5 --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/ActivityServiceTest.java @@ -0,0 +1,91 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity; + +import org.apache.commons.io.IOUtils; +import org.assertj.core.data.MapEntry; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.sonar.api.config.Settings; +import org.sonar.api.utils.System2; +import org.sonar.core.persistence.DbTester; +import org.sonar.server.activity.db.ActivityDao; +import org.sonar.server.activity.index.ActivityDoc; +import org.sonar.server.activity.index.ActivityIndexDefinition; +import org.sonar.server.activity.index.ActivityIndexer; +import org.sonar.server.db.DbClient; +import org.sonar.server.es.EsTester; +import org.sonar.server.issue.db.IssueDao; + +import java.sql.Clob; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class ActivityServiceTest { + + @ClassRule + public static DbTester db = new DbTester(); + + @ClassRule + public static EsTester es = new EsTester().addDefinitions(new ActivityIndexDefinition(new Settings())); + + System2 system = mock(System2.class); + ActivityService service; + + @Before + public void before() { + ActivityDao activityDao = new ActivityDao(db.myBatis(), system); + IssueDao issueDao = new IssueDao(db.myBatis()); + DbClient dbClient = new DbClient(db.database(), db.myBatis(), issueDao, activityDao); + service = new ActivityService(dbClient, new ActivityIndexer(dbClient, es.client())); + } + + @Test + public void insert_and_index() throws Exception { + when(system.now()).thenReturn(1_500_000_000_000L); + + Activity activity = new Activity(); + activity.setType(Activity.Type.ANALYSIS_REPORT); + activity.setAction("THE_ACTION"); + activity.setMessage("THE_MSG"); + activity.setData("foo", "bar"); + service.save(activity); + + Map<String, Object> dbMap = db.selectFirst("select log_type as \"type\", log_action as \"action\", log_message as \"msg\", data_field as \"data\" from activities"); + assertThat(dbMap).containsEntry("type", "ANALYSIS_REPORT"); + assertThat(dbMap).containsEntry("action", "THE_ACTION"); + assertThat(dbMap).containsEntry("msg", "THE_MSG"); + Clob data = (Clob) dbMap.get("data"); + assertThat(IOUtils.toString(data.getAsciiStream())).isEqualTo("foo=bar"); + + List<ActivityDoc> docs = es.getDocuments("activities", "activity", ActivityDoc.class); + assertThat(docs).hasSize(1); + assertThat(docs.get(0).getKey()).isNotEmpty(); + assertThat(docs.get(0).getAction()).isEqualTo("THE_ACTION"); + assertThat(docs.get(0).getMessage()).isEqualTo("THE_MSG"); + assertThat(docs.get(0).getDetails()).containsOnly(MapEntry.entry("foo", "bar")); + } + +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/RubyQProfileActivityServiceTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/RubyQProfileActivityServiceTest.java index 10a2e55b65f..ef446052923 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/activity/RubyQProfileActivityServiceTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/RubyQProfileActivityServiceTest.java @@ -30,11 +30,10 @@ import org.mockito.Captor; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; import org.sonar.api.utils.DateUtils; -import org.sonar.core.activity.Activity; +import org.sonar.server.es.SearchOptions; import org.sonar.server.qualityprofile.QProfileActivity; import org.sonar.server.qualityprofile.QProfileActivityQuery; import org.sonar.server.qualityprofile.QProfileService; -import org.sonar.server.search.QueryContext; import org.sonar.server.search.Result; import java.util.Date; @@ -53,7 +52,7 @@ public class RubyQProfileActivityServiceTest { ArgumentCaptor<QProfileActivityQuery> activityArgumentCaptor; @Captor - ArgumentCaptor<QueryContext> queryOptionsArgumentCaptor; + ArgumentCaptor<SearchOptions> queryOptionsArgumentCaptor; RubyQProfileActivityService rubyQProfileActivityService; @@ -70,16 +69,16 @@ public class RubyQProfileActivityServiceTest { Result<QProfileActivity> result = mock(Result.class); when(result.getHits()).thenReturn(Lists.<QProfileActivity>newArrayList()); when(result.getTotal()).thenReturn(10L); - when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryContext.class))).thenReturn(result); + when(service.searchActivities(any(QProfileActivityQuery.class), any(SearchOptions.class))).thenReturn(result); - rubyQProfileActivityService.search(ImmutableMap.<String, Object>of("profileKeys", "PROFILE_KEY", "since", since, "to", to)); + rubyQProfileActivityService.search(ImmutableMap.<String, Object>of("profileKey", "PROFILE_KEY", "since", since, "to", to)); verify(service).searchActivities(activityArgumentCaptor.capture(), queryOptionsArgumentCaptor.capture()); assertThat(queryOptionsArgumentCaptor.getValue().getLimit()).isEqualTo(50); - assertThat(activityArgumentCaptor.getValue().getQprofileKeys()).containsOnly("PROFILE_KEY"); - assertThat(activityArgumentCaptor.getValue().getTypes()).containsOnly(Activity.Type.QPROFILE); + assertThat(activityArgumentCaptor.getValue().getQprofileKey()).isEqualTo("PROFILE_KEY"); + assertThat(activityArgumentCaptor.getValue().getTypes()).containsOnly(Activity.Type.QPROFILE.name()); assertThat(activityArgumentCaptor.getValue().getSince()).isEqualTo(since); assertThat(activityArgumentCaptor.getValue().getTo()).isEqualTo(to); } @@ -89,7 +88,7 @@ public class RubyQProfileActivityServiceTest { Result<QProfileActivity> result = mock(Result.class); when(result.getHits()).thenReturn(Lists.<QProfileActivity>newArrayList()); when(result.getTotal()).thenReturn(10L); - when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryContext.class))).thenReturn(result); + when(service.searchActivities(any(QProfileActivityQuery.class), any(SearchOptions.class))).thenReturn(result); rubyQProfileActivityService.search(ImmutableMap.<String, Object>of()); @@ -97,7 +96,7 @@ public class RubyQProfileActivityServiceTest { assertThat(queryOptionsArgumentCaptor.getValue().getLimit()).isEqualTo(50); - assertThat(activityArgumentCaptor.getValue().getQprofileKeys()).isEmpty(); + assertThat(activityArgumentCaptor.getValue().getQprofileKey()).isNull(); assertThat(activityArgumentCaptor.getValue().getSince()).isNull(); assertThat(activityArgumentCaptor.getValue().getTo()).isNull(); } diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/db/ActivityDaoTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/db/ActivityDaoTest.java index 1a2cd967c17..9ebf997f9ac 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/activity/db/ActivityDaoTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/db/ActivityDaoTest.java @@ -19,116 +19,50 @@ */ package org.sonar.server.activity.db; - -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Iterables; -import org.junit.After; +import org.apache.commons.io.IOUtils; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; -import org.sonar.api.utils.KeyValueFormat; +import org.junit.experimental.categories.Category; import org.sonar.api.utils.System2; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.ActivityLog; import org.sonar.core.activity.db.ActivityDto; -import org.sonar.core.persistence.AbstractDaoTestCase; -import org.sonar.core.persistence.DbSession; +import org.sonar.core.persistence.DbTester; +import org.sonar.test.DbTests; +import java.sql.Clob; +import java.sql.Timestamp; import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@Category(DbTests.class) +public class ActivityDaoTest { -public class ActivityDaoTest extends AbstractDaoTestCase { + @Rule + public DbTester dbTester = new DbTester(); - private ActivityDao dao; - private DbSession session; + System2 system = mock(System2.class); + ActivityDao sut; @Before public void before() throws Exception { - this.session = getMyBatis().openSession(false); - this.dao = new ActivityDao(mock(System2.class)); - } - - @After - public void after() { - session.close(); - } - - @Test - public void fail_insert_missing_type() { - String testValue = "hello world"; - ActivityDto log = ActivityDto.createFor(testValue); - try { - dao.insert(session, log); - } catch (IllegalArgumentException e) { - assertThat(e.getMessage()).isEqualTo("Type must be set"); - } - } - - - @Test - public void fail_get_by_key() { - try { - dao.getByKey(session, "hello world"); - } catch (IllegalStateException e) { - assertThat(e.getMessage()).isEqualTo("Cannot execute getByKey on Activities in DB"); - } - } - - - @Test - public void fail_insert_missing_author() { - String testValue = "hello world"; - ActivityDto log = ActivityDto.createFor(testValue) - .setType(Activity.Type.QPROFILE); - try { - dao.insert(session, log); - } catch (IllegalArgumentException e) { - assertThat(e.getMessage()).isEqualTo("Type must be set"); - } - } - - @Test - public void insert_text_log() { - String testValue = "hello world"; - ActivityDto log = ActivityDto.createFor(testValue) - .setType(Activity.Type.QPROFILE) - .setAuthor("jUnit"); - dao.insert(session, log); - - ActivityDto newDto = Iterables.getFirst(dao.findAll(session), null); - assertThat(newDto).isNotNull(); - assertThat(newDto.getAuthor()).isEqualTo(log.getAuthor()); - assertThat(newDto.getMessage()).isEqualTo(testValue); + sut = new ActivityDao(dbTester.myBatis(), system); } @Test - public void insert_loggable_log() { - final String testKey = "message"; - final String testValue = "hello world"; - ActivityDto log = ActivityDto.createFor(new ActivityLog() { - - @Override - public Map<String, String> getDetails() { - return ImmutableMap.of(testKey, testValue); - } - - @Override - public String getAction() { - return "myAction"; - } - }) - .setAuthor("jUnit") - .setType(Activity.Type.QPROFILE); - - dao.insert(session, log); - - ActivityDto newDto = Iterables.getFirst(dao.findAll(session), null); - assertThat(newDto).isNotNull(); - assertThat(newDto.getAuthor()).isEqualTo(log.getAuthor()); - assertThat(newDto.getData()).isNotNull(); - Map<String, String> details = KeyValueFormat.parse(newDto.getData()); - assertThat(details.get(testKey)).isEqualTo(testValue); + public void insert() throws Exception { + when(system.now()).thenReturn(1_500_000_000_000L); + ActivityDto dto = new ActivityDto() + .setKey("UUID_1").setAction("THE_ACTION").setType("THE_TYPE") + .setAuthor("THE_AUTHOR").setData("THE_DATA"); + sut.insert(dto); + + Map<String, Object> map = dbTester.selectFirst("select created_at as \"createdAt\", log_action as \"action\", data_field as \"data\" from activities where log_key='UUID_1'"); + assertThat(map.get("action")).isEqualTo("THE_ACTION"); + assertThat(((Timestamp)map.get("createdAt")).getTime()).isEqualTo(1_500_000_000_000L); + Clob data = (Clob) map.get("data"); + assertThat(IOUtils.toString(data.getAsciiStream())).isEqualTo("THE_DATA"); } - } diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexDefinitionTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexDefinitionTest.java new file mode 100644 index 00000000000..80ef2f2fba0 --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexDefinitionTest.java @@ -0,0 +1,60 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import org.junit.Test; +import org.sonar.api.config.Settings; +import org.sonar.process.ProcessConstants; +import org.sonar.server.es.IndexDefinition; +import org.sonar.server.es.NewIndex; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ActivityIndexDefinitionTest { + + IndexDefinition.IndexDefinitionContext context = new IndexDefinition.IndexDefinitionContext(); + + @Test + public void define() throws Exception { + ActivityIndexDefinition def = new ActivityIndexDefinition(new Settings()); + def.define(context); + + assertThat(context.getIndices()).hasSize(1); + NewIndex index = context.getIndices().get("activities"); + assertThat(index).isNotNull(); + assertThat(index.getTypes().keySet()).containsOnly("activity"); + + // no cluster by default + assertThat(index.getSettings().get("index.number_of_shards")).isEqualTo("1"); + assertThat(index.getSettings().get("index.number_of_replicas")).isEqualTo("0"); + } + + @Test + public void enable_cluster() throws Exception { + Settings settings = new Settings(); + settings.setProperty(ProcessConstants.CLUSTER_ACTIVATE, true); + ActivityIndexDefinition def = new ActivityIndexDefinition(settings); + def.define(context); + + NewIndex index = context.getIndices().get("activities"); + assertThat(index.getSettings().get("index.number_of_shards")).isEqualTo("4"); + assertThat(index.getSettings().get("index.number_of_replicas")).isEqualTo("1"); + } +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexTest.java new file mode 100644 index 00000000000..8ace24aa377 --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityIndexTest.java @@ -0,0 +1,111 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import com.google.common.collect.ImmutableMap; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.sonar.api.config.Settings; +import org.sonar.server.activity.Activity; +import org.sonar.server.es.EsTester; +import org.sonar.server.es.SearchOptions; +import org.sonar.server.es.SearchResult; + +import java.util.Arrays; +import java.util.Date; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ActivityIndexTest { + + @ClassRule + public static EsTester es = new EsTester().addDefinitions(new ActivityIndexDefinition(new Settings())); + + ActivityIndex sut; + + @Before + public void before() { + sut = new ActivityIndex(es.client()); + } + + @Test + public void search_all() throws Exception { + es.putDocuments("activities", "activity", newDoc(1, 1_500_000_000_000L), newDoc(2, 1_600_000_000_000L)); + + SearchResult<ActivityDoc> results = sut.search(new ActivityQuery(), new SearchOptions()); + assertThat(results.getTotal()).isEqualTo(2L); + assertThat(results.getDocs()).hasSize(2); + assertThat(results.getDocs()).extracting("message").containsOnly("THE_MSG 1", "THE_MSG 2"); + } + + @Test + public void search_by_type() throws Exception { + es.putDocuments("activities", "activity", newDoc(1, 1_500_000_000_000L), newDoc(2, 1_600_000_000_000L)); + + ActivityQuery query = new ActivityQuery(); + query.setTypes(Arrays.asList("ANALYSIS_REPORT")); + assertThat(sut.search(query, new SearchOptions()).getTotal()).isEqualTo(2L); + + query = new ActivityQuery(); + query.setTypes(Arrays.asList("OTHER", "TYPES")); + assertThat(sut.search(query, new SearchOptions()).getTotal()).isEqualTo(0L); + } + + @Test + public void search_by_data() throws Exception { + es.putDocuments("activities", "activity", newDoc(1, 1_500_000_000_000L), newDoc(2, 1_600_000_000_000L)); + + ActivityQuery query = new ActivityQuery(); + query.addDataOrFilter("foo", "bar2"); + SearchResult<ActivityDoc> results = sut.search(query, new SearchOptions()); + assertThat(results.getDocs()).hasSize(1); + assertThat(results.getDocs().get(0).getKey()).isEqualTo("UUID2"); + } + + @Test + public void search_by_date() throws Exception { + es.putDocuments("activities", "activity", newDoc(1, 1_500_000_000_000L), newDoc(2, 1_600_000_000_000L)); + + ActivityQuery query = new ActivityQuery(); + query.setSince(new Date(1_550_000_000_000L)); + SearchResult<ActivityDoc> results = sut.search(query, new SearchOptions()); + assertThat(results.getDocs()).hasSize(1); + assertThat(results.getDocs().get(0).getKey()).isEqualTo("UUID2"); + + query = new ActivityQuery(); + query.setTo(new Date(1_550_000_000_000L)); + results = sut.search(query, new SearchOptions()); + assertThat(results.getDocs()).hasSize(1); + assertThat(results.getDocs().get(0).getKey()).isEqualTo("UUID1"); + } + + ActivityDoc newDoc(int id, long date) { + ActivityDoc doc = new ActivityDoc(); + doc.setKey("UUID" + id); + doc.setType(Activity.Type.ANALYSIS_REPORT.name()); + doc.setAction("THE_ACTION " + id); + doc.setMessage("THE_MSG " + id); + doc.setDetails(ImmutableMap.of("foo", "bar" + id)); + doc.setLogin("THE_GUY " + id); + doc.setCreatedAt(new Date(date)); + return doc; + } +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityResultSetIteratorTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityResultSetIteratorTest.java new file mode 100644 index 00000000000..6a986068ae5 --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/index/ActivityResultSetIteratorTest.java @@ -0,0 +1,91 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.activity.index; + +import org.apache.commons.dbutils.DbUtils; +import org.assertj.core.data.MapEntry; +import org.junit.After; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.sonar.api.utils.DateUtils; +import org.sonar.core.persistence.DbTester; +import org.sonar.server.db.DbClient; +import org.sonar.test.DbTests; + +import java.sql.Connection; + +import static org.assertj.core.api.Assertions.assertThat; + +@Category(DbTests.class) +public class ActivityResultSetIteratorTest { + + @ClassRule + public static DbTester dbTester = new DbTester(); + + DbClient client; + Connection connection; + + @Before + public void setUp() throws Exception { + dbTester.truncateTables(); + client = new DbClient(dbTester.database(), dbTester.myBatis()); + connection = dbTester.openConnection(); + } + + @After + public void tearDown() throws Exception { + DbUtils.closeQuietly(connection); + } + + @Test + public void traverse() throws Exception { + dbTester.prepareDbUnit(getClass(), "traverse.xml"); + ActivityResultSetIterator it = ActivityResultSetIterator.create(client, connection, 0L); + assertThat(it.hasNext()).isTrue(); + ActivityDoc doc = it.next(); + assertThat(doc).isNotNull(); + assertThat(doc.getKey()).isEqualTo("UUID1"); + assertThat(doc.getAction()).isEqualTo("THE_ACTION"); + assertThat(doc.getMessage()).isEqualTo("THE_MSG"); + assertThat(doc.getDetails()).containsOnly(MapEntry.entry("foo", "bar")); + assertThat(doc.getLogin()).isEqualTo("THE_AUTHOR"); + + assertThat(it.hasNext()).isTrue(); + assertThat(it.next()).isNotNull(); + assertThat(it.hasNext()).isFalse(); + it.close(); + } + + @Test + public void traverse_after_date() throws Exception { + dbTester.prepareDbUnit(getClass(), "traverse.xml"); + ActivityResultSetIterator it = ActivityResultSetIterator.create(client, connection, DateUtils.parseDate("2014-12-01").getTime()); + + assertThat(it.hasNext()).isTrue(); + ActivityDoc doc = it.next(); + assertThat(doc).isNotNull(); + assertThat(doc.getKey()).isEqualTo("UUID2"); + + assertThat(it.hasNext()).isFalse(); + it.close(); + } +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/activity/ws/ActivitiesWebServiceMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/activity/ws/ActivitiesWebServiceMediumTest.java index 36920b23461..f5462dc69fa 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/activity/ws/ActivitiesWebServiceMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/activity/ws/ActivitiesWebServiceMediumTest.java @@ -19,15 +19,12 @@ */ package org.sonar.server.activity.ws; -import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.sonar.api.server.ws.WebService; -import org.sonar.core.activity.Activity; -import org.sonar.core.persistence.DbSession; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; -import org.sonar.server.db.DbClient; import org.sonar.server.tester.ServerTester; import org.sonar.server.user.MockUserSession; import org.sonar.server.ws.WsTester; @@ -39,22 +36,14 @@ public class ActivitiesWebServiceMediumTest { @ClassRule public static ServerTester tester = new ServerTester(); - private ActivitiesWebService ws; - private ActivityService service; - private DbSession session; - + ActivitiesWebService ws; + ActivityService service; @Before public void setUp() throws Exception { tester.clearDbAndIndexes(); ws = tester.get(ActivitiesWebService.class); service = tester.get(ActivityService.class); - session = tester.get(DbClient.class).openSession(false); - } - - @After - public void after() { - session.close(); } @Test @@ -70,14 +59,20 @@ public class ActivitiesWebServiceMediumTest { } @Test - public void search_logs() throws Exception { - service.write(session, Activity.Type.QPROFILE, "Hello World"); - session.commit(); + public void search() throws Exception { + Activity activity = new Activity(); + activity.setType(Activity.Type.ANALYSIS_REPORT); + activity.setAction("THE_ACTION"); + activity.setMessage("THE_MSG"); + activity.setData("foo", "bar"); + service.save(activity); MockUserSession.set(); - // 1. List single Text log - WsTester.TestRequest request = tester.wsTester().newGetRequest(ActivitiesWebService.API_ENDPOINT, SearchAction.SEARCH_ACTION); + WsTester.TestRequest request = tester.wsTester().newGetRequest("api/activities", "search"); WsTester.Result result = request.execute(); + assertThat(result.outputAsString()).contains("\"total\":1"); + assertThat(result.outputAsString()).contains("\"type\":\"ANALYSIS_REPORT\""); + assertThat(result.outputAsString()).contains("\"details\":{\"foo\":\"bar\"}"); } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java index 61d9cc7ab88..26682ddb642 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java @@ -52,10 +52,9 @@ import org.sonar.api.utils.log.LogTester; import org.sonar.api.utils.log.LoggerLevel; import org.sonar.batch.protocol.output.BatchOutputWriter; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.core.activity.Activity; import org.sonar.core.computation.db.AnalysisReportDto; -import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.step.ComputationStep; @@ -122,7 +121,7 @@ public class ComputationServiceTest { verify(projectStep1).execute(any(ComputationContext.class)); verify(projectStep2).execute(any(ComputationContext.class)); verify(viewStep, never()).execute(any(ComputationContext.class)); - verify(activityService).write(any(DbSession.class), eq(Activity.Type.ANALYSIS_REPORT), any(ReportActivity.class)); + verify(activityService).save(any(Activity.class)); } @Test diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/ReportActivityTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/ReportActivityTest.java deleted file mode 100644 index 82ca71f828a..00000000000 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/ReportActivityTest.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -package org.sonar.server.computation; - -import org.junit.Test; -import org.sonar.api.utils.DateUtils; -import org.sonar.core.component.ComponentDto; -import org.sonar.core.computation.db.AnalysisReportDto; -import org.sonar.server.component.ComponentTesting; - -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.sonar.core.computation.db.AnalysisReportDto.Status.FAILED; - -public class ReportActivityTest { - - @Test - public void insert_find_analysis_report_log() { - AnalysisReportDto report = AnalysisReportDto.newForTests(1L) - .setProjectKey("projectKey") - .setStatus(FAILED) - .setCreatedAt(DateUtils.parseDate("2014-10-15").getTime()) - .setUpdatedAt(DateUtils.parseDate("2014-10-16").getTime()) - .setStartedAt(DateUtils.parseDate("2014-10-17").getTime()) - .setFinishedAt(DateUtils.parseDate("2014-10-18").getTime()); - ComponentDto project = ComponentTesting.newProjectDto(); - - ReportActivity activity = new ReportActivity(report, project); - - Map<String, String> details = activity.getDetails(); - assertThat(details.get("key")).isEqualTo(String.valueOf(report.getId())); - assertThat(details.get("projectKey")).isEqualTo(project.key()); - assertThat(details.get("projectName")).isEqualTo(project.name()); - assertThat(details.get("projectUuid")).isEqualTo(project.uuid()); - assertThat(details.get("status")).isEqualTo("FAILED"); - assertThat(details.get("submittedAt")).isEqualTo("2014-10-15T00:00:00+0200"); - assertThat(details.get("startedAt")).isEqualTo("2014-10-17T00:00:00+0200"); - assertThat(details.get("finishedAt")).isEqualTo("2014-10-18T00:00:00+0200"); - } - -} diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/ws/HistoryWsActionMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/ws/HistoryWsActionMediumTest.java index 6852087e43f..26fe86462b3 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/ws/HistoryWsActionMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/ws/HistoryWsActionMediumTest.java @@ -20,126 +20,71 @@ package org.sonar.server.computation.ws; -import org.apache.commons.io.IOUtils; -import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; -import org.sonar.api.security.DefaultGroups; -import org.sonar.api.web.UserRole; -import org.sonar.core.activity.Activity; -import org.sonar.core.component.ComponentDto; import org.sonar.core.computation.db.AnalysisReportDto; import org.sonar.core.permission.GlobalPermissions; -import org.sonar.core.permission.PermissionFacade; -import org.sonar.core.persistence.DbSession; -import org.sonar.core.persistence.MyBatis; -import org.sonar.core.user.UserDto; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; -import org.sonar.server.component.ComponentTesting; -import org.sonar.server.computation.ReportActivity; -import org.sonar.server.computation.ReportQueue; -import org.sonar.server.db.DbClient; import org.sonar.server.exceptions.ForbiddenException; import org.sonar.server.tester.ServerTester; import org.sonar.server.user.MockUserSession; import org.sonar.server.ws.WsTester; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; +import java.util.Date; /** -* TODO replace this medium test by a small test -*/ + * TODO replace this medium test by a small test + */ public class HistoryWsActionMediumTest { - private static final String DEFAULT_PROJECT_KEY = "DefaultProjectKey"; - private static final String DEFAULT_PROJECT_NAME = "DefaultProjectName"; - private static final String DEFAULT_REPORT_DATA = "default-project"; @ClassRule public static ServerTester tester = new ServerTester(); - private DbClient dbClient; - private DbSession session; - private WsTester wsTester; - private ReportQueue queue; - private MockUserSession userSession; - private ActivityService activityService; + HistoryWsAction sut; + ActivityService activityService; @Before - public void before() { + public void setUp() throws Exception { tester.clearDbAndIndexes(); - dbClient = tester.get(DbClient.class); - wsTester = tester.get(WsTester.class); - session = dbClient.openSession(false); - queue = tester.get(ReportQueue.class); + sut = tester.get(HistoryWsAction.class); activityService = tester.get(ActivityService.class); - - UserDto connectedUser = new UserDto().setLogin("gandalf").setName("Gandalf"); - dbClient.userDao().insert(session, connectedUser); - - userSession = MockUserSession.set() - .setLogin(connectedUser.getLogin()) - .setUserId(connectedUser.getId().intValue()) - .setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION); - } - - @After - public void after() { - MyBatis.closeQuietly(session); } @Test - public void add_and_try_to_retrieve_activities() throws Exception { - insertPermissionsForProject(DEFAULT_PROJECT_KEY); - queue.add(DEFAULT_PROJECT_KEY, IOUtils.toInputStream(DEFAULT_REPORT_DATA)); - queue.add(DEFAULT_PROJECT_KEY, IOUtils.toInputStream(DEFAULT_REPORT_DATA)); - queue.add(DEFAULT_PROJECT_KEY, IOUtils.toInputStream(DEFAULT_REPORT_DATA)); - - List<AnalysisReportDto> reports = queue.all(); - ComponentDto project = ComponentTesting.newProjectDto() - .setName(DEFAULT_PROJECT_NAME) - .setKey(DEFAULT_PROJECT_KEY); - for (AnalysisReportDto report : reports) { - report.succeed(); - activityService.write(session, Activity.Type.ANALYSIS_REPORT, new ReportActivity(report, project)); - } - - session.commit(); - userSession.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN); - - WsTester.TestRequest request = wsTester.newGetRequest(ComputationWebService.API_ENDPOINT, "history"); - WsTester.Result result = request.execute(); - - assertThat(result).isNotNull(); - result.assertJson(getClass(), "list_history_reports.json", false); - } - - private ComponentDto insertPermissionsForProject(String projectKey) { - ComponentDto project = new ComponentDto().setKey(projectKey).setId(1L); - dbClient.componentDao().insert(session, project); - - tester.get(PermissionFacade.class).insertGroupPermission(project.getId(), DefaultGroups.ANYONE, UserRole.USER, session); - userSession.addProjectPermissions(UserRole.ADMIN, project.key()); - userSession.addProjectPermissions(UserRole.USER, project.key()); - - session.commit(); - - return project; + public void search() throws Exception { + Activity activity1 = new Activity(); + activity1.setType(Activity.Type.ANALYSIS_REPORT); + activity1.setAction("LOG_ANALYSIS_REPORT"); + activity1.setData("projectKey", "P1"); + activity1.setData("projectName", "POne"); + activity1.setData("projectUuid", "U1"); + activity1.setData("status", AnalysisReportDto.Status.SUCCESS); + activity1.setData("submittedAt", new Date()); + activityService.save(activity1); + + Activity activity2 = new Activity(); + activity2.setType(Activity.Type.ANALYSIS_REPORT); + activity2.setAction("LOG_ANALYSIS_REPORT"); + activity2.setData("projectKey", "P2"); + activity2.setData("projectName", "PTwo"); + activity2.setData("projectUuid", "U2"); + activity2.setData("status", AnalysisReportDto.Status.FAILED); + activity2.setData("submittedAt", new Date()); + activityService.save(activity2); + + MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN); + + WsTester.TestRequest request = tester.wsTester().newGetRequest("api/computation", "history"); + request.execute().assertJson(getClass(), "list_history_reports.json", false); } @Test(expected = ForbiddenException.class) - public void user_rights_is_not_enough_throw_ForbiddenException() throws Exception { - insertPermissionsForProject(DEFAULT_PROJECT_KEY); - queue.add(DEFAULT_PROJECT_KEY, IOUtils.toInputStream(DEFAULT_REPORT_DATA)); - - AnalysisReportDto report = queue.all().get(0); - report.succeed(); - // queue.remove(report); - userSession.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION); + public void requires_admin_right() throws Exception { + MockUserSession.set(); - WsTester.TestRequest sut = wsTester.newGetRequest(ComputationWebService.API_ENDPOINT, "history"); - sut.execute(); + WsTester.TestRequest request = tester.wsTester().newGetRequest("api/computation", "history"); + request.execute(); } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/db/migrations/v44/ChangeLogMigrationTest.java b/server/sonar-server/src/test/java/org/sonar/server/db/migrations/v44/ChangeLogMigrationTest.java index 699581a22b6..ceb22da3b6a 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/db/migrations/v44/ChangeLogMigrationTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/db/migrations/v44/ChangeLogMigrationTest.java @@ -23,31 +23,23 @@ import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.runners.MockitoJUnitRunner; import org.sonar.api.utils.DateUtils; import org.sonar.api.utils.System2; -import org.sonar.core.activity.db.ActivityDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.activity.db.ActivityDao; import org.sonar.server.db.DbClient; -import java.util.List; - import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.class) public class ChangeLogMigrationTest { @ClassRule public static DbTester db = new DbTester().schema(ChangeLogMigrationTest.class, "schema.sql"); - @Mock - System2 system2; - + System2 system2 = mock(System2.class); DbClient dbClient; ActivityDao dao; ChangeLogMigration migration; @@ -56,7 +48,7 @@ public class ChangeLogMigrationTest { @Before public void setUp() throws Exception { when(system2.now()).thenReturn(DateUtils.parseDate("2014-03-13").getTime()); - dao = new ActivityDao(system2); + dao = new ActivityDao(db.myBatis(), system2); dbClient = new DbClient(db.database(), db.myBatis(), dao); migration = new ChangeLogMigration(dao, dbClient); session = dbClient.openSession(false); @@ -71,10 +63,10 @@ public class ChangeLogMigrationTest { public void migrate() throws Exception { db.prepareDbUnit(getClass(), "active_rules_changes.xml"); migration.execute(); - assertThat(dao.findAll(session)).hasSize(5); + assertThat(db.countRowsOfTable("activities")).isEqualTo(5); - List<ActivityDto> changes = dao.findAll(session); - assertThat(changes.get(1).getData()).contains("param_PARAM1=TODO"); + int count = db.countSql("select count(*) from activities where data_field like '%param_PARAM1=TODO%'"); + assertThat(count).isGreaterThan(0); } @Test @@ -82,6 +74,6 @@ public class ChangeLogMigrationTest { db.prepareDbUnit(getClass(), "migrate_when_no_changelog.xml"); migration.execute(); - assertThat(dao.findAll(session)).isEmpty(); + assertThat(db.countRowsOfTable("activities")).isEqualTo(0); } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleChangeMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleChangeMediumTest.java deleted file mode 100644 index c57d29fb178..00000000000 --- a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleChangeMediumTest.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.server.qualityprofile; - -import com.google.common.collect.Iterables; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.sonar.api.rule.RuleKey; -import org.sonar.core.activity.Activity; -import org.sonar.core.persistence.DbSession; -import org.sonar.core.qualityprofile.db.ActiveRuleKey; -import org.sonar.server.activity.ActivityService; -import org.sonar.server.activity.index.ActivityIndex; -import org.sonar.server.db.DbClient; -import org.sonar.server.tester.ServerTester; - -import static org.assertj.core.api.Assertions.assertThat; - -public class ActiveRuleChangeMediumTest { - - @ClassRule - public static ServerTester tester = new ServerTester(); - - ActivityService service = tester.get(ActivityService.class); - ActivityIndex index = tester.get(ActivityIndex.class); - DbSession dbSession; - - @Before - public void before() { - tester.clearDbAndIndexes(); - dbSession = tester.get(DbClient.class).openSession(false); - } - - @After - public void after() { - dbSession.close(); - } - - @Test - public void insert_find_active_rule_change() { - ActiveRuleKey key = ActiveRuleKey.of("XOO_P1", RuleKey.of("xoo", "X1")); - ActiveRuleChange change = ActiveRuleChange - .createFor(ActiveRuleChange.Type.ACTIVATED, key) - .setInheritance(ActiveRule.Inheritance.INHERITED) - .setSeverity("BLOCKER") - .setParameter("param1", "value1"); - - service.write(dbSession, Activity.Type.QPROFILE, change); - dbSession.commit(); - - // 0. AssertBase case - assertThat(index.findAll().getHits()).hasSize(1); - - Activity activity = Iterables.getFirst(index.findAll().getHits(), null); - assertThat(activity).isNotNull(); - assertThat(activity.details().get("key")).isEqualTo(key.toString()); - } -} diff --git a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileServiceMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileServiceMediumTest.java index 2015af9ab51..034bb052ef9 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileServiceMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileServiceMediumTest.java @@ -20,7 +20,6 @@ package org.sonar.server.qualityprofile; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import org.junit.After; @@ -36,19 +35,19 @@ import org.sonar.api.rule.Severity; import org.sonar.api.rules.Rule; import org.sonar.api.rules.RulePriority; import org.sonar.api.utils.ValidationMessages; -import org.sonar.core.activity.Activity; import org.sonar.core.permission.GlobalPermissions; import org.sonar.core.persistence.DbSession; import org.sonar.core.qualityprofile.db.ActiveRuleKey; import org.sonar.core.qualityprofile.db.QualityProfileDto; import org.sonar.core.rule.RuleDto; import org.sonar.core.user.UserDto; +import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; import org.sonar.server.db.DbClient; +import org.sonar.server.es.SearchOptions; import org.sonar.server.qualityprofile.index.ActiveRuleNormalizer; import org.sonar.server.rule.RuleTesting; import org.sonar.server.search.FacetValue; -import org.sonar.server.search.QueryContext; import org.sonar.server.search.Result; import org.sonar.server.tester.ServerTester; import org.sonar.server.user.MockUserSession; @@ -187,24 +186,23 @@ public class QProfileServiceMediumTest { // We need an actual rule in DB to test RuleName in Activity RuleDto rule = db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)) - .setSeverity(Severity.MAJOR) - .setParameter("max", "10") - ); dbSession.commit(); - Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext()); + tester.get(ActivityService.class).save(ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)) + .setSeverity(Severity.MAJOR) + .setParameter("max", "10").toActivity()); + + Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new SearchOptions()); assertThat(activities.getHits()).hasSize(1); QProfileActivity activity = activities.getHits().get(0); - assertThat(activity.type()).isEqualTo(Activity.Type.QPROFILE); - assertThat(activity.action()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name()); + assertThat(activity.getType()).isEqualTo(Activity.Type.QPROFILE.name()); + assertThat(activity.getAction()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name()); assertThat(activity.ruleKey()).isEqualTo(RuleTesting.XOO_X1); assertThat(activity.profileKey()).isEqualTo(XOO_P1_KEY); assertThat(activity.severity()).isEqualTo(Severity.MAJOR); assertThat(activity.ruleName()).isEqualTo(rule.getName()); - assertThat(activity.login()).isEqualTo("david"); + assertThat(activity.getLogin()).isEqualTo("david"); assertThat(activity.authorName()).isEqualTo("David"); assertThat(activity.parameters()).hasSize(1); @@ -217,13 +215,11 @@ public class QProfileServiceMediumTest { RuleKey ruleKey = RuleKey.of("xoo", "deleted_rule"); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.UPDATED, ActiveRuleKey.of(XOO_P1_KEY, ruleKey)) - .setParameter("max", "10") + tester.get(ActivityService.class).save(ActiveRuleChange.createFor(ActiveRuleChange.Type.UPDATED, ActiveRuleKey.of(XOO_P1_KEY, ruleKey)) + .setParameter("max", "10").toActivity() ); - dbSession.commit(); - Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext()); + Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new SearchOptions()); assertThat(activities.getHits()).hasSize(1); QProfileActivity activity = activities.getHits().get(0); @@ -238,19 +234,20 @@ public class QProfileServiceMediumTest { // We need an actual rule in DB to test RuleName in Activity db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1); + dbSession.commit(); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, + tester.get(ActivityService.class).save( ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)) .setSeverity(Severity.MAJOR) .setParameter("max", "10") + .toActivity() ); - dbSession.commit(); - Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext()); + Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new SearchOptions()); assertThat(activities.getHits()).hasSize(1); QProfileActivity activity = activities.getHits().get(0); - assertThat(activity.login()).isEqualTo("david"); + assertThat(activity.getLogin()).isEqualTo("david"); assertThat(activity.authorName()).isNull(); } @@ -260,14 +257,14 @@ public class QProfileServiceMediumTest { RuleKey ruleKey = RuleKey.of("xoo", "deleted_rule"); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, ruleKey)) - .setSeverity(Severity.MAJOR) - .setParameter("max", "10") + tester.get(ActivityService.class).save(ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, ruleKey)) + .setSeverity(Severity.MAJOR) + .setParameter("max", "10") + .toActivity() ); dbSession.commit(); - Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext()); + Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new SearchOptions()); assertThat(activities.getHits()).hasSize(1); QProfileActivity activity = activities.getHits().get(0); @@ -278,48 +275,36 @@ public class QProfileServiceMediumTest { @Test public void search_activity_by_qprofile() throws InterruptedException { - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1))); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X1))); - dbSession.commit(); + tester.get(ActivityService.class).save( + ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)).toActivity()); + tester.get(ActivityService.class).save( + ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X1)).toActivity()); // 0. Base case verify 2 activities in index - assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryContext()).getHits()) + assertThat(service.searchActivities(new QProfileActivityQuery(), new SearchOptions()).getHits()) .hasSize(2); // 1. filter by QProfile List<QProfileActivity> result = service.searchActivities(new QProfileActivityQuery() - .setQprofileKeys(ImmutableSet.of(XOO_P1_KEY)), new QueryContext()).getHits(); + .setQprofileKey(XOO_P1_KEY), new SearchOptions()).getHits(); assertThat(result).hasSize(1); - - // 1. filter by QProfiles - assertThat(service.searchActivities(new QProfileActivityQuery() - .setQprofileKeys(ImmutableSet.of(XOO_P1_KEY, XOO_P2_KEY)) - , new QueryContext()).getHits()).hasSize(2); } @Test public void search_activity_by_qprofile_having_dashes_in_keys() throws InterruptedException { - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of("java-default", RuleTesting.XOO_X1))); - tester.get(ActivityService.class).write(dbSession, Activity.Type.QPROFILE, - ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of("java-toto", RuleTesting.XOO_X1))); - dbSession.commit(); + tester.get(ActivityService.class).save( + ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of("java-default", RuleTesting.XOO_X1)).toActivity()); + tester.get(ActivityService.class).save( + ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of("java-toto", RuleTesting.XOO_X1)).toActivity()); // 0. Base case verify 2 activities in index - assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryContext()).getHits()) + assertThat(service.searchActivities(new QProfileActivityQuery(), new SearchOptions()).getHits()) .hasSize(2); // 1. filter by QProfile List<QProfileActivity> result = service.searchActivities(new QProfileActivityQuery() - .setQprofileKeys(ImmutableSet.of("java-default")), new QueryContext()).getHits(); + .setQprofileKey("java-default"), new SearchOptions()).getHits(); assertThat(result).hasSize(1); - - // 1. filter by QProfiles - assertThat(service.searchActivities(new QProfileActivityQuery() - .setQprofileKeys(ImmutableSet.of("java-default", "java-toto")) - , new QueryContext()).getHits()).hasSize(2); } @Test diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/db/RuleDaoTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/db/RuleDaoTest.java index 15ce8518841..2b82eb2aaa9 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/db/RuleDaoTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/db/RuleDaoTest.java @@ -34,9 +34,7 @@ import org.sonar.core.persistence.DbSession; import org.sonar.core.rule.RuleDto; import org.sonar.core.rule.RuleDto.Format; import org.sonar.core.rule.RuleParamDto; -import org.sonar.server.rule.RuleTesting; -import java.util.Date; import java.util.List; import static org.assertj.core.api.Assertions.assertThat; @@ -368,31 +366,4 @@ public class RuleDaoTest extends AbstractDaoTestCase { checkTables("update_parameter", "rules_parameters"); } - - @Test - public void findAfterDate() throws Exception { - long t0 = DateUtils.parseDate("2014-01-01").getTime(); - when(system2.now()).thenReturn(t0); - dao.insert(session, RuleTesting.newXooX1()); - session.commit(); - assertThat(dao.getByKey(session, RuleTesting.XOO_X1).getCreatedAt().after(new Date(t0))); - - - long t1 = DateUtils.parseDate("2014-02-01").getTime(); - when(system2.now()).thenReturn(t1); - dao.insert(session, RuleTesting.newXooX2()); - session.commit(); - assertThat(dao.getByKey(session, RuleTesting.XOO_X2).getCreatedAt().after(new Date(t1))); - - long t2 = DateUtils.parseDate("2014-03-01").getTime(); - when(system2.now()).thenReturn(t2); - session.flushStatements(); - - - assertThat(dao.findAll(session)).hasSize(2); - assertThat(dao.findAfterDate(session, new Date(0))).hasSize(2); - assertThat(dao.findAfterDate(session, new Date(t0))).hasSize(2); - assertThat(dao.findAfterDate(session, new Date(t1))).hasSize(1); - assertThat(dao.findAfterDate(session, new Date(t2))).hasSize(0); - } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/search/BaseIndexTest.java b/server/sonar-server/src/test/java/org/sonar/server/search/BaseIndexTest.java index 9eeecef377d..006e153ef06 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/search/BaseIndexTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/search/BaseIndexTest.java @@ -20,7 +20,6 @@ package org.sonar.server.search; import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse; -import org.elasticsearch.common.settings.ImmutableSettings; import org.junit.After; import org.junit.Before; import org.junit.ClassRule; @@ -91,11 +90,6 @@ public class BaseIndexTest { null, searchClient) { @Override - protected ImmutableSettings.Builder addCustomIndexSettings(ImmutableSettings.Builder baseIndexSettings) { - return baseIndexSettings.put("index.number_of_replicas", 22); - } - - @Override protected String getKeyValue(Serializable key) { return null; } diff --git a/server/sonar-server/src/test/resources/org/sonar/server/activity/index/ActivityResultSetIteratorTest/traverse.xml b/server/sonar-server/src/test/resources/org/sonar/server/activity/index/ActivityResultSetIteratorTest/traverse.xml new file mode 100644 index 00000000000..f92f7678379 --- /dev/null +++ b/server/sonar-server/src/test/resources/org/sonar/server/activity/index/ActivityResultSetIteratorTest/traverse.xml @@ -0,0 +1,7 @@ +<dataset> + <activities id="1" log_key="UUID1" log_type="ANALYSIS_REPORT" log_action="THE_ACTION" log_message="THE_MSG" + created_at="2014-01-01" data_field="foo=bar" user_login="THE_AUTHOR"/> + + <activities id="2" log_key="UUID2" log_type="ANALYSIS_REPORT" log_action="THE_ACTION" log_message="THE_MSG" + created_at="2015-01-01" data_field="foo=bar" user_login="THE_AUTHOR"/> +</dataset> diff --git a/server/sonar-server/src/test/resources/org/sonar/server/computation/ws/HistoryWsActionMediumTest/list_history_reports.json b/server/sonar-server/src/test/resources/org/sonar/server/computation/ws/HistoryWsActionMediumTest/list_history_reports.json index b0ed60a0876..caa180819a4 100644 --- a/server/sonar-server/src/test/resources/org/sonar/server/computation/ws/HistoryWsActionMediumTest/list_history_reports.json +++ b/server/sonar-server/src/test/resources/org/sonar/server/computation/ws/HistoryWsActionMediumTest/list_history_reports.json @@ -2,18 +2,15 @@ "reports": [ { "status": "SUCCESS", - "projectName": "DefaultProjectName", - "projectKey": "DefaultProjectKey" + "projectName": "POne", + "projectKey": "P1", + "projectUuid": "U1" }, { - "status": "SUCCESS", - "projectName": "DefaultProjectName", - "projectKey": "DefaultProjectKey" - }, - { - "status": "SUCCESS", - "projectName": "DefaultProjectName", - "projectKey": "DefaultProjectKey" + "status": "FAILED", + "projectName": "PTwo", + "projectKey": "P2", + "projectUuid": "U2" } ] -}
\ No newline at end of file +} diff --git a/server/sonar-web/src/main/webapp/WEB-INF/app/controllers/profiles_controller.rb b/server/sonar-web/src/main/webapp/WEB-INF/app/controllers/profiles_controller.rb index 3ac6eba4b8d..2b107edfefb 100644 --- a/server/sonar-web/src/main/webapp/WEB-INF/app/controllers/profiles_controller.rb +++ b/server/sonar-web/src/main/webapp/WEB-INF/app/controllers/profiles_controller.rb @@ -268,7 +268,7 @@ class ProfilesController < ApplicationController require_parameters 'key' @profile = Internal.qprofile_loader.getByKey(params[:key]) - search = {'profileKeys' => @profile.key().to_s, 'since' => params[:since], 'to' => params[:to], 'p' => params[:p]} + search = {'profileKey' => @profile.key().to_s, 'since' => params[:since], 'to' => params[:to], 'p' => params[:p]} result = Internal.component(Java::OrgSonarServerActivity::RubyQProfileActivityService.java_class).search(search) @changes = result.activities @paging = result.paging diff --git a/sonar-core/src/main/java/org/sonar/core/activity/ActivityLog.java b/sonar-core/src/main/java/org/sonar/core/activity/ActivityLog.java deleted file mode 100644 index 9b0a7f54a24..00000000000 --- a/sonar-core/src/main/java/org/sonar/core/activity/ActivityLog.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.core.activity; - -import java.util.Map; - -/** - * @since 4.4 - */ -public interface ActivityLog { - - Map<String, String> getDetails(); - - public String getAction(); - -} diff --git a/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityDto.java b/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityDto.java index 517f0e998a7..298b88faef9 100644 --- a/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityDto.java +++ b/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityDto.java @@ -21,44 +21,42 @@ package org.sonar.core.activity.db; import org.apache.commons.lang.builder.ReflectionToStringBuilder; import org.apache.commons.lang.builder.ToStringStyle; -import org.sonar.api.utils.KeyValueFormat; -import org.sonar.api.utils.internal.Uuids; -import org.sonar.core.activity.Activity; -import org.sonar.core.activity.ActivityLog; -import org.sonar.core.persistence.Dto; - -/** - * @since 4.4 - */ -public final class ActivityDto extends Dto<String> { + +import java.util.Date; + +public class ActivityDto { private String key; private String message; - private Activity.Type type; + private String type; private String action; private String author; - private String data; + private Date createdAt; - protected ActivityDto() { - this.key = Uuids.create(); + public ActivityDto setKey(String key) { + this.key = key; + return this; } - @Override public String getKey() { return key; } - @Override - public String toString() { - return ReflectionToStringBuilder.toString(this, ToStringStyle.MULTI_LINE_STYLE); + public Date getCreatedAt() { + return createdAt; + } + + public ActivityDto setCreatedAt(Date createdAt) { + this.createdAt = createdAt; + return this; } - public Activity.Type getType() { + public String getType() { return type; } - public ActivityDto setType(Activity.Type type) { + public ActivityDto setType(String type) { this.type = type; return this; } @@ -99,21 +97,8 @@ public final class ActivityDto extends Dto<String> { return this; } - public static ActivityDto createFor(String message) { - return new ActivityDto() - .setMessage(message); - } - - public static ActivityDto createFor(String action, String message) { - return new ActivityDto() - .setAction(action) - .setMessage(message); - } - - public static ActivityDto createFor(ActivityLog activityLog) { - return new ActivityDto() - .setAction(activityLog.getAction()) - .setData(KeyValueFormat.format(activityLog.getDetails())); - + @Override + public String toString() { + return ReflectionToStringBuilder.toString(this, ToStringStyle.MULTI_LINE_STYLE); } } diff --git a/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityMapper.java b/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityMapper.java index d7f5959c422..175bef8bc30 100644 --- a/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityMapper.java +++ b/sonar-core/src/main/java/org/sonar/core/activity/db/ActivityMapper.java @@ -19,21 +19,8 @@ */ package org.sonar.core.activity.db; -import org.apache.ibatis.annotations.Param; - -import javax.annotation.Nullable; - -import java.sql.Timestamp; -import java.util.List; - -/** - * @since 4.4 - */ public interface ActivityMapper { - void insert(ActivityDto rule); - - List<ActivityDto> selectAll(); + void insert(ActivityDto dto); - List<ActivityDto> selectAfterDate(@Nullable @Param("date") Timestamp timestamp); } diff --git a/sonar-core/src/main/java/org/sonar/core/activity/package-info.java b/sonar-core/src/main/java/org/sonar/core/activity/package-info.java deleted file mode 100644 index 8c6baa92aa2..00000000000 --- a/sonar-core/src/main/java/org/sonar/core/activity/package-info.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2014 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * SonarQube is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -@ParametersAreNonnullByDefault -package org.sonar.core.activity; - -import javax.annotation.ParametersAreNonnullByDefault; diff --git a/sonar-core/src/main/resources/org/sonar/core/activity/db/ActivityMapper.xml b/sonar-core/src/main/resources/org/sonar/core/activity/db/ActivityMapper.xml index fecd0b0210f..c3de19773b6 100644 --- a/sonar-core/src/main/resources/org/sonar/core/activity/db/ActivityMapper.xml +++ b/sonar-core/src/main/resources/org/sonar/core/activity/db/ActivityMapper.xml @@ -3,40 +3,13 @@ <mapper namespace="org.sonar.core.activity.db.ActivityMapper"> - <insert id="insert" parameterType="Activity" useGeneratedKeys="false" > + <insert id="insert" parameterType="Activity" useGeneratedKeys="false"> insert into activities (created_at, log_key, log_type, log_action, user_login, data_field, log_message) - values (#{createdAt}, #{key}, #{type}, #{action}, #{author}, #{data}, #{message}) + values (#{createdAt,jdbcType=TIMESTAMP}, #{key,jdbcType=VARCHAR}, #{type,jdbcType=VARCHAR}, + #{action,jdbcType=VARCHAR}, + #{author,jdbcType=VARCHAR}, #{data,jdbcType=VARCHAR}, #{message,jdbcType=VARCHAR}) </insert> - <select id="selectAll" parameterType="map" resultType="Activity" fetchSize="${_scrollFetchSize}" resultSetType="FORWARD_ONLY"> - SELECT - created_at as "createdAt", - log_type as "type", - user_login as "author", - data_field as "data", - log_message as "message", - log_key as "key", - log_action as "action" - FROM activities - </select> - - - <select id="selectAfterDate" parameterType="map" resultType="Activity" fetchSize="${_scrollFetchSize}" resultSetType="FORWARD_ONLY"> - SELECT - created_at as "createdAt", - log_type as "type", - user_login as "author", - data_field as "data", - log_message as "message", - log_key as "key", - log_action as "action" - FROM activities - <where> - <if test="date != null"> - created_at >= #{date} - </if> - </where> - </select> </mapper> |