+++ /dev/null
-package org.openecomp.core.tools.Commands;
-
-import org.apache.commons.collections.CollectionUtils;
-import org.openecomp.core.tools.concurrent.ItemHealingTask;
-import org.openecomp.core.tools.exceptions.HealingRuntimeException;
-import org.openecomp.core.tools.loaders.VersionInfoCassandraLoader;
-import org.openecomp.sdc.healing.api.HealingManager;
-import org.openecomp.sdc.healing.factory.HealingManagerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
-import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
-import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
-
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.stream.Stream;
-
-/**
- * Created by ayalaben on 11/6/2017
- */
-public class HealAll {
-
- private static final int DEFAULT_THREAD_NUMBER = 100;
- private static List<ItemHealingTask> tasks = new ArrayList<>();
- private static VendorSoftwareProductManager vspManager = VspManagerFactory
- .getInstance().createInterface();
- private static HealingManager healingManager = HealingManagerFactory.getInstance()
- .createInterface();
-
- private HealAll() {
- }
-
- public static void healAll(String threadNumber) {
-
- String logFileName = "healing.log";
- try (BufferedWriter log = new BufferedWriter(new FileWriter(logFileName, true))) {
-
- writeToLog("----starting healing------", log);
- Instant startTime = Instant.now();
-
- int numberOfThreads = Objects.nonNull(threadNumber) ? Integer.valueOf(threadNumber) :
- DEFAULT_THREAD_NUMBER;
- ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);
-
- filterByEntityType(VersionInfoCassandraLoader.list(),
- VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE).forEach
- (HealAll::addTaskToTasks);
-
- executeAllTasks(executor, log);
-
- writeToLog("----finished healing------", log);
- Instant endTime = Instant.now();
- writeToLog("Total runtime was: " + Duration.between(startTime, endTime), log);
- } catch (IOException e) {
- throw new HealingRuntimeException("can't initial healing log file '" + logFileName + "'", e);
- }
-
- System.exit(1);
- }
-
- private static void executeAllTasks(ExecutorService executor, BufferedWriter log) {
- List<Future<String>> futureTasks;
- try {
- futureTasks = executor.invokeAll(tasks);
- futureTasks.forEach(future -> {
- try {
- log.write(future.get());
- log.newLine();
- } catch (Exception e) {
- writeToLog(e.getMessage(), log);
- }
- });
- } catch (InterruptedException e) {
- writeToLog("migration tasks failed with message: " + e.getMessage(), log);
- throw new HealingRuntimeException(e);
- }
-
- boolean isThreadOpen = true;
- while (isThreadOpen) {
- isThreadOpen = futureTasks.stream().anyMatch(future -> !future.isDone());
- }
- }
-
- private static Version resolveVersion(VersionInfoEntity versionInfoEntity) {
- if (Objects.nonNull(versionInfoEntity.getCandidate())) {
- return versionInfoEntity.getCandidate().getVersion();
- } else if (!CollectionUtils.isEmpty(versionInfoEntity.getViewableVersions())) {
- return versionInfoEntity.getViewableVersions().stream().max(Version::compateTo).get();
- }
- return versionInfoEntity.getActiveVersion();
- }
-
- private static void writeToLog(String message, BufferedWriter log) {
- try {
- log.write(message);
- log.newLine();
- } catch (IOException e) {
- throw new HealingRuntimeException("unable to write to healing all log file.", e);
- }
- }
-
- private static Stream<VersionInfoEntity> filterByEntityType(
- Collection<VersionInfoEntity> versionInfoEntities, String entityType) {
- return versionInfoEntities.stream().filter(versionInfoEntity -> versionInfoEntity
- .getEntityType().equals(entityType));
- }
-
- private static void addTaskToTasks(VersionInfoEntity versionInfoEntity) {
- tasks.add(new ItemHealingTask(versionInfoEntity.getEntityId(), resolveVersion
- (versionInfoEntity).toString(),
- vspManager, healingManager));
- }
-
-}
--- /dev/null
+package org.openecomp.core.tools.commands;
+
+import org.openecomp.core.tools.concurrent.ItemAddContributorsTask;
+import org.openecomp.core.tools.exceptions.CommandExecutionRuntimeException;
+import org.openecomp.core.tools.store.ItemHandler;
+import org.openecomp.core.tools.store.NotificationHandler;
+import org.openecomp.core.tools.store.PermissionHandler;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class AddContributorCommand {
+
+
+ private static final int DEFAULT_THREAD_NUMBER = 8;
+ private static final String ERROR_TRYING_TO_READ_FILE = "Error while trying to read item list";
+ private static final String COMMAND_ADD_CONTRIBUTOR_FAILED =
+ "Command AddContributor execution failed.";
+
+ private AddContributorCommand() {
+ // it's a utility class, prevent instantiation
+ }
+
+ public static void add(String itemListPath, String userListPath) {
+
+ List<String> itemList;
+ try {
+ itemList = getItemList(itemListPath);
+ } catch (IOException e) {
+ throw new CommandExecutionRuntimeException(ERROR_TRYING_TO_READ_FILE +
+ "from:" + itemListPath, e);
+ }
+ List<String> userList;
+ try {
+ userList = load(userListPath).collect(Collectors.toList());
+ } catch (IOException e) {
+ throw new CommandExecutionRuntimeException(ERROR_TRYING_TO_READ_FILE +
+ "from:" + userListPath, e);
+ }
+
+ List<ItemAddContributorsTask> tasks =
+ itemList.stream().map(itemid -> createTask(itemid, userList)).collect(Collectors.toList());
+
+ ExecutorService executor = null;
+
+ try {
+ executor = Executors.newFixedThreadPool(DEFAULT_THREAD_NUMBER);
+ executeAllTasks(executor, tasks);
+ } catch (InterruptedException e) {
+ throw new CommandExecutionRuntimeException(COMMAND_ADD_CONTRIBUTOR_FAILED, e);
+ } finally {
+ if (executor != null) {
+ executor.shutdownNow();
+ }
+ }
+ }
+
+ private static List<String> getItemList(String itemListPath) throws IOException {
+ List<String> itemList;
+ if (itemListPath != null) {
+ itemList = load(itemListPath).collect(Collectors.toList());
+ } else {
+ itemList = new ItemHandler().getItemList();
+ }
+
+ return itemList;
+ }
+
+ private static void executeAllTasks(ExecutorService executor,
+ Collection<? extends Callable<String>> tasks)
+ throws InterruptedException {
+ List<Future<String>> futureTasks;
+ futureTasks = executor.invokeAll(tasks);
+ boolean isThreadOpen = true;
+ while (isThreadOpen) {
+ isThreadOpen = futureTasks.stream().anyMatch(future -> !future.isDone());
+
+ }
+ }
+
+
+
+ private static ItemAddContributorsTask createTask(String itemId, List<String> users) {
+ return new ItemAddContributorsTask(new PermissionHandler(), new NotificationHandler(),
+ itemId, users);
+ }
+
+ private static Stream<String> load(String filePath)
+ throws IOException {
+ return Files.lines(Paths.get(filePath));
+
+ }
+
+
+}
--- /dev/null
+package org.openecomp.core.tools.commands;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.openecomp.core.tools.concurrent.ItemHealingTask;
+import org.openecomp.core.tools.exceptions.HealingRuntimeException;
+import org.openecomp.core.tools.loaders.VersionInfoCassandraLoader;
+import org.openecomp.sdc.healing.api.HealingManager;
+import org.openecomp.sdc.healing.factory.HealingManagerFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.stream.Stream;
+
+/**
+ * Created by ayalaben on 11/6/2017
+ */
+public class HealAll {
+
+ private static final int DEFAULT_THREAD_NUMBER = 100;
+ private static List<ItemHealingTask> tasks = new ArrayList<>();
+ private static VendorSoftwareProductManager vspManager = VspManagerFactory
+ .getInstance().createInterface();
+ private static HealingManager healingManager = HealingManagerFactory.getInstance()
+ .createInterface();
+
+ private HealAll() {
+ }
+
+ public static void healAll(String threadNumber) {
+
+ String logFileName = "healing.log";
+ try (BufferedWriter log = new BufferedWriter(new FileWriter(logFileName, true))) {
+
+ writeToLog("----starting healing------", log);
+ Instant startTime = Instant.now();
+
+ int numberOfThreads = Objects.nonNull(threadNumber) ? Integer.valueOf(threadNumber) :
+ DEFAULT_THREAD_NUMBER;
+ ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);
+
+ filterByEntityType(VersionInfoCassandraLoader.list(),
+ VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE).forEach
+ (HealAll::addTaskToTasks);
+
+ executeAllTasks(executor, log);
+
+ writeToLog("----finished healing------", log);
+ Instant endTime = Instant.now();
+ writeToLog("Total runtime was: " + Duration.between(startTime, endTime), log);
+ } catch (IOException e) {
+ throw new HealingRuntimeException("can't initial healing log file '" + logFileName + "'", e);
+ }
+
+ System.exit(1);
+ }
+
+ private static void executeAllTasks(ExecutorService executor, BufferedWriter log) {
+ List<Future<String>> futureTasks;
+ try {
+ futureTasks = executor.invokeAll(tasks);
+ futureTasks.forEach(future -> {
+ try {
+ log.write(future.get());
+ log.newLine();
+ } catch (Exception e) {
+ writeToLog(e.getMessage(), log);
+ }
+ });
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ writeToLog("migration tasks failed with message: " + e.getMessage(), log);
+ throw new HealingRuntimeException(e);
+ }
+
+ boolean isThreadOpen = true;
+ while (isThreadOpen) {
+ isThreadOpen = futureTasks.stream().anyMatch(future -> !future.isDone());
+ }
+ }
+
+
+ private static Version resolveVersion(VersionInfoEntity versionInfoEntity) {
+ if (Objects.nonNull(versionInfoEntity.getCandidate())) {
+ return versionInfoEntity.getCandidate().getVersion();
+ } else if (!CollectionUtils.isEmpty(versionInfoEntity.getViewableVersions())) {
+
+ return versionInfoEntity.getViewableVersions().stream().max(Version::compateTo)
+ .orElse(new Version());
+ }
+ return versionInfoEntity.getActiveVersion();
+ }
+
+ private static void writeToLog(String message, BufferedWriter log) {
+ try {
+ log.write(message);
+ log.newLine();
+ } catch (IOException e) {
+ throw new HealingRuntimeException("unable to write to healing all log file.", e);
+ }
+ }
+
+ private static Stream<VersionInfoEntity> filterByEntityType(
+ Collection<VersionInfoEntity> versionInfoEntities, String entityType) {
+ return versionInfoEntities.stream().filter(versionInfoEntity -> versionInfoEntity
+ .getEntityType().equals(entityType));
+ }
+
+ private static void addTaskToTasks(VersionInfoEntity versionInfoEntity) {
+ tasks.add(new ItemHealingTask(versionInfoEntity.getEntityId(), resolveVersion
+ (versionInfoEntity).toString(),
+ vspManager, healingManager));
+ }
+
+}
-package org.openecomp.core.tools.Commands;
+package org.openecomp.core.tools.commands;
import com.datastax.driver.core.ResultSet;
import org.openecomp.core.tools.store.HealingHandler;
public class SetHealingFlag {
+ private SetHealingFlag(){}
+
public static void populateHealingTable(String oldVersion) {
VersionCassandraLoader versionCassandraLoader = new VersionCassandraLoader();
ResultSet listItemVersion = versionCassandraLoader.listItemVersion();
- ArrayList<HealingEntity> healingEntities = new ArrayList<HealingEntity>();
+ ArrayList<HealingEntity> healingEntities = new ArrayList<>();
listItemVersion.iterator().forEachRemaining(entry -> healingEntities.add(new HealingEntity
(entry.getString(0),entry.getString(1),entry.getString(2),true,oldVersion)));
--- /dev/null
+package org.openecomp.core.tools.concurrent;
+
+import org.openecomp.core.tools.store.NotificationHandler;
+import org.openecomp.core.tools.store.PermissionHandler;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+
+
+public class ItemAddContributorsTask implements Callable<String> {
+
+ private static final String CONTRIBUTOR = "Contributor";
+ private static final String SUCCESSFUL_RETURN_MESSAGE = "Users added successfully as " +
+ "contributors to item id:%s.";
+ private final String itemId;
+ private final List<String> users;
+ private final PermissionHandler permissionHandler;
+ private final NotificationHandler notificationHandler;
+
+ public ItemAddContributorsTask(PermissionHandler permissionHandler, NotificationHandler
+ notificationHandler, String itemId, List<String> users) {
+ this.itemId = itemId.trim();
+ this.users = new ArrayList<>(users);
+ this.permissionHandler = permissionHandler;
+ this.notificationHandler = notificationHandler;
+ }
+
+ @Override
+ public String call() {
+ users.forEach(this::handleUser);
+ return String.format(SUCCESSFUL_RETURN_MESSAGE, itemId);
+ }
+
+ private void handleUser(String user) {
+ Optional<String> userPermission = getUserPermission(user);
+ if (!userPermission.isPresent()) {
+ setUserPermission(user, CONTRIBUTOR);
+ registerUserNotificationSubscription(user);
+ }
+ }
+
+ private void registerUserNotificationSubscription(String user) {
+ notificationHandler.registerNotificationForUserOnEntity(user, itemId);
+ }
+
+ private void setUserPermission(String user, String permission) {
+ permissionHandler.setItemUserPermission(itemId, user, permission);
+ }
+
+ private Optional<String> getUserPermission(String user) {
+ return permissionHandler.getItemUserPermission(itemId, user);
+ }
+}
--- /dev/null
+package org.openecomp.core.tools.exceptions;
+
+public class CommandExecutionRuntimeException extends RuntimeException {
+ public CommandExecutionRuntimeException(String message, Exception exception) {
+ super(message, exception);
+ }
+
+ public CommandExecutionRuntimeException(String message) {
+ super(message);
+ }
+}
import com.amdocs.zusammen.datatypes.SessionContext;
import com.amdocs.zusammen.datatypes.UserInfo;
-import org.openecomp.core.tools.Commands.HealAll;
-import org.openecomp.core.tools.Commands.SetHealingFlag;
+import org.openecomp.core.tools.commands.AddContributorCommand;
+import org.openecomp.core.tools.commands.HealAll;
+import org.openecomp.core.tools.commands.SetHealingFlag;
import org.openecomp.core.tools.exportinfo.ExportDataCommand;
import org.openecomp.core.tools.importinfo.ImportDataCommand;
import org.openecomp.core.tools.util.ToolsUtil;
public static void main(String[] args) {
- String command = ToolsUtil.getParam("c",args);
+ COMMANDS command = getCommand(args);
+
if(command == null){
printMessage(logger,
"parameter -c is mandatory. script usage: zusammenMainTool.sh -c {command name} " +
"[additional arguments depending on the command] ");
+ printMessage(logger,
+ "reset old version: -c RESET_OLD_VERSION [-v {version}]");
+ printMessage(logger,
+ "export: -c EXPORT [-i {item id}]");
+ printMessage(logger,
+ "import: -c IMPORT -f {zip file full path}");
+ printMessage(logger,
+ "heal all: -c HEAL_ALL [-t {number of threads}]");
+ printMessage(logger,
+ "add users as contributors: -c ADD_CONTRIBUTOR [-p {item id list file path}] -u {user " +
+ "list file path}");
System.exit(-1);
}
Instant startTime = Instant.now();
context.setTenant("dox");
- switch (COMMANDS.valueOf(command)){
+
+ switch (command){
case RESET_OLD_VERSION:
SetHealingFlag.populateHealingTable(ToolsUtil.getParam("v",args));
break;
break;
case HEAL_ALL:
HealAll.healAll(ToolsUtil.getParam("t",args));
+ break;
+ case ADD_CONTRIBUTOR:
+ AddContributorCommand.add(ToolsUtil.getParam("p",args),ToolsUtil.getParam("u",args));
}
}
- private enum COMMANDS{
-
-
- RESET_OLD_VERSION("reset-old-version"),
- EXPORT("export"),
- IMPORT("import"),
- HEAL_ALL("heal-all");
-
- COMMANDS(String command) {
- this.command = command;
+ private static COMMANDS getCommand(String[] args) {
+ String commandSrt = ToolsUtil.getParam("c",args);
+ try{
+ return COMMANDS.valueOf(commandSrt);
+ }catch (IllegalArgumentException iae){
+ printMessage(logger,"message:"+commandSrt+ " is illegal.");
}
-
- private String command;
+ return null;
}
+ private enum COMMANDS{
+ RESET_OLD_VERSION,
+ EXPORT,
+ IMPORT,
+ HEAL_ALL,
+ ADD_CONTRIBUTOR;
+ }
}
--- /dev/null
+package org.openecomp.core.tools.store;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ItemHandler {
+
+ public List<String> getItemList() {
+ ResultSet resultSet = NoSqlDbFactory.getInstance().createInterface()
+ .getMappingManager().createAccessor(ItemAccessor.class).list();
+ List<Row> rows = resultSet.all();
+
+ if (rows != null) {
+ return rows.stream().map(row -> row.getString("item_id")).collect(Collectors.toList());
+ }
+ return Collections.emptyList();
+ }
+
+ @Accessor
+ interface ItemAccessor {
+ @Query("SELECT item_id FROM zusammen_dox.item")
+ ResultSet list();
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package org.openecomp.core.tools.store;
+
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class NotificationHandler {
+
+ public void registerNotificationForUserOnEntity(String user, String entityId) {
+
+ Set<String> userSet = new HashSet<>();
+ userSet.add(user);
+ NoSqlDbFactory.getInstance().createInterface().getMappingManager()
+ .createAccessor(NotificationAccessor.class)
+ .updateNotificationSubscription(userSet, entityId);
+ }
+
+ @Accessor
+ interface NotificationAccessor {
+
+ @Query("UPDATE dox.notification_subscribers SET subscribers = subscribers + ? where " +
+ "entity_id = ?")
+ void updateNotificationSubscription(Set<String> users, String entityId);
+ }
+}
\ No newline at end of file
--- /dev/null
+package org.openecomp.core.tools.store;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public class PermissionHandler {
+
+ private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static PermissionAccessor accessor =
+ noSqlDb.getMappingManager().createAccessor(PermissionAccessor.class);
+
+
+ public Optional<String> getItemUserPermission(String itemId, String user) {
+ ResultSet resultSet = accessor.getItemUserPermission(itemId, user);
+ Row row = resultSet.one();
+
+ if (Objects.nonNull(row)) {
+ return Optional.of(row.getString("permission"));
+ } else {
+ return Optional.empty();
+ }
+ }
+
+ public void setItemUserPermission(String itemId, String user, String permission) {
+ accessor.setItemUserPermission(itemId, user, permission);
+ }
+
+
+ @Accessor
+ interface PermissionAccessor {
+
+
+ @Query("INSERT into dox.item_permissions (item_id,user_id,permission) VALUES (?,?,?)")
+ void setItemUserPermission(String permission, String itemId, String userId);
+
+
+ @Query("SELECT permission FROM dox.item_permissions WHERE item_id=? AND user_id=?")
+ ResultSet getItemUserPermission(String itemId, String userId);
+ }
+
+}
\ No newline at end of file
-package org.openecomp.core.tools.Commands.exportinfo.serialize;
+package org.openecomp.core.tools.commands.exportinfo.serialize;
import org.openecomp.core.tools.exportinfo.ExportSerializer;
import org.testng.annotations.Test;
Code Review / sdc.git / commitdiff