<openecomp.sdc.common.version>${project.version}</openecomp.sdc.common.version>
<!-- Onboarding 3rd party versions -->
- <jtosca.version>1.1.1</jtosca.version>
<aspectj.version>1.8.9</aspectj.version>
<bsh.version>2.0b5</bsh.version>
<cassandra.version>2.1.9</cassandra.version>
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
+import org.junit.Ignore;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
"/testSubMappingExtContrailPort", "org.openecomp.resource.cp.v2.extContrailCP", true);
}
- @Test
+ @Ignore
public void testHealingGlobalServiceTemplates () throws Exception {
testForwarderHealer("/testGlobalServiceTemplates", null, false);
}
type: integer
required: true
network_role_tag:
- description: Must correlate to the set of defined “network-role�? tag identifiers from the associated HEAT template
type: string
required: true
mac_requirements:
derived_from: tosca.nodes.network.Port
properties:
network_role_tag:
- description: Must correlate to the set of defined “network-role�? tag identifiers from the associated HEAT template
type: string
required: true
mac_requirements:
type: integer
required: true
network_role_tag:
- description: Must correlate to the set of defined “network-role�? tag identifiers from the associated HEAT template
type: string
+ description: Must correlate to the set of defined network-role tag identifiers from the associated HEAT template
required: true
mac_requirements:
description: identifies MAC address assignments to the CP
return major == version.major && minor == version.minor;
}
+ public int compateTo(Version other){
+ if (this.major>other.major) {
+ return 1;
+ } else if(this.major<other.major){
+ return -1;
+ } else if(this.major == other.major){
+ return Integer.compare(this.minor,other.minor);
+ }
+ return 0;
+ }
+
@Override
public String toString() {
return major + "." + minor;
<artifactId>openecomp-facade-core</artifactId>
<version>1.2.0-SNAPSHOT</version>
</dependency>
- <dependency>
- <groupId>org.openecomp.sdc.jtosca</groupId>
- <artifactId>jtosca</artifactId>
- <version>${jtosca.version}</version>
- </dependency>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-translator-core</artifactId>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-vendor-software-product-api</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<artifactId>openecomp-zusammen-plugin</artifactId>
<groupId>org.openecomp.sdc.core</groupId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-vendor-software-product-core</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-vendor-license-api</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-model-impl</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.openecomp.sdc.core</groupId>
<artifactId>openecomp-zusammen-core</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.amdocs.zusammen.plugin</groupId>
<dependency>
<groupId>org.openecomp.sdc</groupId>
<artifactId>openecomp-sdc-vendor-license-core</artifactId>
- <version>1.2.0-SNAPSHOT</version>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-vendor-software-product-manager</artifactId>
+ <version>${project.version}</version>
</dependency>
</dependencies>
<artifactId>openecomp-zusammen-tools</artifactId>
--- /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.loaders.VersionInfoCassandraLoader;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+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 String HEALING_USER = "healing_user";
+ private static final int defaulThreadNumber =100;
+ private static BufferedWriter log;
+ private static List<ItemHealingTask> tasks = new ArrayList<>();
+ private static VendorSoftwareProductManager vspManager = VspManagerFactory
+ .getInstance().createInterface();
+ private static VersioningManager versioningManager = VersioningManagerFactory.getInstance()
+ .createInterface();
+
+ static {
+ try {
+ log =
+ new BufferedWriter(new FileWriter("healing.log",true));
+ } catch (IOException e) {
+ if (log != null) {
+ try {
+ log.close();
+ } catch (IOException e1) {
+ throw new RuntimeException("can't initial healing log file: " + e1.getMessage());
+ }
+ }
+ throw new RuntimeException("can't initial healing log file: " + e.getMessage());
+ }
+ }
+
+ public static void healAll(String threadNumber) {
+
+ writeToLog("----starting healing------");
+ Instant startTime = Instant.now();
+
+ int numberOfThreads = Objects.nonNull(threadNumber) ? Integer.valueOf(threadNumber) :
+ defaulThreadNumber;
+ ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);
+
+ filterByEntityType(VersionInfoCassandraLoader.list(),
+ VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE).forEach
+ (HealAll::addTaskToTasks);
+
+ executeAllTasks(executor);
+
+ writeToLog("----finished healing------" );
+ Instant endTime = Instant.now();
+ writeToLog("Total runtime was: " + Duration.between(startTime, endTime));
+
+ try {
+ if (log != null) {
+ log.close();
+ }
+ } catch (IOException e) {
+ writeToLog("Error:" + e.getMessage());
+ }
+
+ System.exit(1);
+ }
+
+ private static void executeAllTasks(ExecutorService executor) {
+ 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());
+ }
+ });
+ } catch (InterruptedException e) {
+ writeToLog("migration tasks failed with message: " + e.getMessage());
+ throw new RuntimeException(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) {
+ try {
+ log.write(message);
+ log.newLine();
+ } catch (IOException e) {
+ throw new RuntimeException("unable to write to healing all log file.");
+ }
+ }
+
+ 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(), versionInfoEntity.getCandidate() == null ?
+ HEALING_USER : versionInfoEntity.getCandidate().getUser(),
+ vspManager, versioningManager));
+ }
+
+}
--- /dev/null
+package org.openecomp.core.tools.concurrent;
+
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningUtil;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+
+import java.util.concurrent.Callable;
+
+/**
+ * Created by ayalaben on 11/7/2017
+ */
+public class ItemHealingTask implements Callable<String> {
+
+ private String itemId;
+ private String versionId;
+ private String user;
+ private VendorSoftwareProductManager vspManager;
+ private VersioningManager versioningManager;
+
+ public String getItemId() {
+ return itemId;
+ }
+
+ public String getVersionId() {
+ return versionId;
+ }
+
+
+ public ItemHealingTask(String itemId, String versionId, String user,
+ VendorSoftwareProductManager vspManager,
+ VersioningManager versioningManager) {
+ this.itemId = itemId;
+ this.versionId = versionId;
+ this.user = user;
+ this.versioningManager = versioningManager;
+ this.vspManager = vspManager;
+ }
+
+ @Override
+ public String call() throws Exception {
+
+ VersionInfo versionInfo = getVersionInfo(itemId, VersionableEntityAction.Read, user);
+ Version resolvedVersion = VersioningUtil.resolveVersion(Version.valueOf(versionId),
+ versionInfo, user);
+ VspDetails vspDetails = vspManager.getVsp(itemId, resolvedVersion, user);
+
+ try {
+ vspManager.callAutoHeal(itemId, versionInfo, vspDetails, user);
+
+ } catch (Exception e) {
+ return (String.format("healing failed on vsp: %s with id: %s, versionId: %s, resolved " +
+ "Version: %s, with message: %s",vspDetails.getName(),itemId,
+ versionId,resolvedVersion,e.getMessage()));
+ }
+
+ return String.format("healed vsp: %s, with id: %s, versionId:%s, resolved version: %s",
+ vspDetails.getName(), itemId, versionId,resolvedVersion );
+ }
+
+ private VersionInfo getVersionInfo(String vendorSoftwareProductId, VersionableEntityAction action,
+ String user) {
+ return versioningManager.getEntityVersionInfo(
+ VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
+ vendorSoftwareProductId, user, action);
+ }
+}
package org.openecomp.core.tools.loaders;
-import com.datastax.driver.mapping.Mapper;
import com.datastax.driver.mapping.Result;
import com.datastax.driver.mapping.annotations.Accessor;
import com.datastax.driver.mapping.annotations.Query;
import java.util.Collection;
-public class VersionInfoCassandraLoader {
+public class VersionInfoCassandraLoader {
private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
- private static Mapper<VersionInfoEntity> mapper =
- noSqlDb.getMappingManager().mapper(VersionInfoEntity.class);
private static VersionInfoAccessor accessor =
noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
-
-
- public Collection<VersionInfoEntity> list() {
+ public static Collection<VersionInfoEntity> list() {
return accessor.getAll().all();
}
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.ImportCommand;
import org.openecomp.core.tools.Commands.ExportDataCommand;
import org.openecomp.core.tools.Commands.ResetOldVersion;
case IMPORT:
ImportCommand.importData(context, ToolsUtil.getParam("f",args),ToolsUtil.getParam("i",args));
break;
+ case HEAL_ALL:
+ HealAll.healAll(ToolsUtil.getParam("t",args));
}
RESET_OLD_VERSION("reset-old-version"),
EXPORT("export"),
- IMPORT("import");
+ IMPORT("import"),
+ HEAL_ALL("heal-all");
COMMANDS(String command) {
this.command = command;
# 3. Import one item - ./zusammenMainTool.sh -c IMPORT -f ${fileName} -i ${elementId}
# 4. Import all - ./zusammenMainTool.sh -c IMPORT -f ${fileName}
# 5. Reset old version - ./zusammenMainTool.sh -c RESET_OLD_VERSION
+# 6. Heal all - ./zusammenMainTool.sh -c HEAL_ALL -t ${thread number}
#
##########################################################################################################
fi
echo "Configuration file location: ${CONF_FILE_LOCATION}"
-java -Dlog.home=/apps/jetty/base/be/logs -Dconfiguration.yaml=${CONF_FILE_LOCATION} -jar openecomp-zusammen-tools-1.2.0-SNAPSHOT.jar org.openecomp.core.tools.main.ZusammenMainTool $1 $2 $3 $4 $5 $6
+java -Dconfig.home=/opt/app/jetty/base/be/config -Dlog.home=/apps/jetty/base/be/logs -Dconfiguration.yaml=${CONF_FILE_LOCATION} -classpath openecomp-zusammen-tools-1.2.0-SNAPSHOT.jar:lib/* org.openecomp.core.tools.main.ZusammenMainTool $1 $2 $3 $4 $5 $6
STATUS="${?}" echo "${STATUS}"
Code Review / sdc.git / commitdiff