gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.core.zusammen.db.impl;
   2
   3 import com.amdocs.zusammen.adaptor.inbound.api.health.HealthAdaptorFactory;
   4 import com.amdocs.zusammen.adaptor.inbound.api.item.ElementAdaptorFactory;
   5 import com.amdocs.zusammen.adaptor.inbound.api.item.ItemAdaptorFactory;
   6 import com.amdocs.zusammen.adaptor.inbound.api.item.ItemVersionAdaptorFactory;
   7 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
   8 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflict;
   9 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
  10 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict;
  11 import com.amdocs.zusammen.adaptor.inbound.api.types.item.MergeResult;
  12 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
  13 import com.amdocs.zusammen.commons.health.data.HealthInfo;
  14 import com.amdocs.zusammen.datatypes.Id;
  15 import com.amdocs.zusammen.datatypes.SessionContext;
  16 import com.amdocs.zusammen.datatypes.Space;
  17 import com.amdocs.zusammen.datatypes.item.ElementContext;
  18 import com.amdocs.zusammen.datatypes.item.Info;
  19 import com.amdocs.zusammen.datatypes.item.Item;
  20 import com.amdocs.zusammen.datatypes.item.ItemVersion;
  21 import com.amdocs.zusammen.datatypes.item.ItemVersionData;
  22 import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
  23 import com.amdocs.zusammen.datatypes.item.Resolution;
  24 import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
  25 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  26 import com.amdocs.zusammen.datatypes.response.Response;
  27 import com.amdocs.zusammen.datatypes.response.ReturnCode;
  28 import org.openecomp.core.zusammen.db.ZusammenConnector;
  29 import org.openecomp.core.zusammen.impl.CassandraConnectionInitializer;
  30 import org.openecomp.core.zusammen.impl.ItemElementLoggerTargetServiceName;
  31 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  32 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  33 import org.openecomp.sdc.logging.types.LoggerConstants;
  34 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  35
  36 import java.util.Collection;
  37
  38 public class ZusammenConnectorImpl implements ZusammenConnector {
  39
  40   private static final String GET_ELEMENT_ERR_MSG =
  41       "Failed to get element. Item Id: %s, version Id: %s, element Id: %s message: %s";
  42   private static final String GET_ELEMENT_IN_REV_ERR_MSG =
  43       "Failed to get element. Item Id: %s, version Id: %s, revision Id: %s, element Id: %s message: %s";
  44   private ItemAdaptorFactory itemAdaptorFactory;
  45   private ItemVersionAdaptorFactory versionAdaptorFactory;
  46   private ElementAdaptorFactory elementAdaptorFactory;
  47   private HealthAdaptorFactory healthAdaptorFactory;
  48
  49   public ZusammenConnectorImpl(
  50       ItemAdaptorFactory itemAdaptorFactory,
  51       ItemVersionAdaptorFactory versionAdaptorFactory,
  52       ElementAdaptorFactory elementAdaptorFactory,
  53       HealthAdaptorFactory healthAdaptorFactory) {
  54     this.itemAdaptorFactory = itemAdaptorFactory;
  55     this.versionAdaptorFactory = versionAdaptorFactory;
  56     this.elementAdaptorFactory = elementAdaptorFactory;
  57     this.healthAdaptorFactory = healthAdaptorFactory;
  58     CassandraConnectionInitializer.setCassandraConnectionPropertiesToSystem();
  59   }
  60
  61   @Override
  62   public Collection<HealthInfo> checkHealth(SessionContext sessionContext) {
  63     return healthAdaptorFactory.createInterface(sessionContext).getHealthStatus(sessionContext);
  64   }
  65
  66   @Override
  67   public String getVersion(SessionContext sessionContext) {
  68     return healthAdaptorFactory.createInterface(sessionContext).getVersion();
  69   }
  70
  71   @Override
  72   public Collection<Item> listItems(SessionContext context) {
  73     Response<Collection<Item>> response = itemAdaptorFactory.createInterface(context).list(context);
  74     if (!response.isSuccessful()) {
  75       throw new RuntimeException(
  76           "Failed to list Items. message:" + response.getReturnCode().toString());
  77     }
  78     return response.getValue();
  79   }
  80
  81   @Override
  82   public Item getItem(SessionContext context, Id itemId) {
  83     Response<Item> response = itemAdaptorFactory.createInterface(context).get(context, itemId);
  84     if (!response.isSuccessful()) {
  85       throw new RuntimeException(
  86           "Failed to get Item. message:" + response.getReturnCode().toString());
  87     }
  88     return response.getValue();
  89   }
  90
  91   @Override
  92   public Id createItem(SessionContext context, Info info) {
  93     Response<Id> response = itemAdaptorFactory.createInterface(context).create(context, info);
  94     if (!response.isSuccessful()) {
  95       throw new RuntimeException(
  96           "Failed to create Item. message:" + response.getReturnCode().toString());
  97     }
  98     return response.getValue();
  99   }
 100
 101   @Override
 102   public void updateItem(SessionContext context, Id itemId, Info info) {
 103     Response<Void> response =
 104         itemAdaptorFactory.createInterface(context).update(context, itemId, info);
 105
 106     if (!response.isSuccessful()) {
 107       throw new RuntimeException("failed to update Item . ItemId:" + itemId + "" +
 108           " message:" + response.getReturnCode().toString());
 109     }
 110   }
 111
 112   @Override
 113   public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 114     Response<Collection<ItemVersion>> versions =
 115         versionAdaptorFactory.createInterface(context).list(context, Space.PUBLIC, itemId);
 116     if (!versions.isSuccessful()) {
 117       logErrorMessageToMdc(ItemElementLoggerTargetServiceName.ITEM_VERSION_RETRIEVAL, versions
 118           .getReturnCode());
 119       throw new RuntimeException(versions.getReturnCode().toString());
 120     }
 121     return versions.getValue();
 122   }
 123
 124   @Override
 125   public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 126     Response<ItemVersion> response = versionAdaptorFactory.createInterface(context)
 127         .get(context, Space.PUBLIC, itemId, versionId);
 128     if (!response.isSuccessful()) {
 129       throw new RuntimeException(
 130           String.format("failed to get public Item Version. ItemId: %s, versionId: %s, message: %s",
 131               itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 132     }
 133     return response.getValue();
 134   }
 135
 136   @Override
 137   public Id createVersion(SessionContext context, Id itemId, Id baseVersionId,
 138                           ItemVersionData itemVersionData) {
 139     Response<Id> response = versionAdaptorFactory.createInterface(context).create(context, itemId,
 140         baseVersionId, itemVersionData);
 141     if (response.isSuccessful()) {
 142       return response.getValue();
 143     } else {
 144       throw new RuntimeException(String.format(
 145           "failed to create Item Version. ItemId: %s, base versionId: %s, message: %s",
 146           itemId.getValue(), baseVersionId.getValue(), response.getReturnCode().toString()));
 147     }
 148   }
 149
 150   @Override
 151   public void updateVersion(SessionContext context, Id itemId, Id versionId,
 152                             ItemVersionData itemVersionData) {
 153     Response<Void> response = versionAdaptorFactory.createInterface(context)
 154         .update(context, itemId, versionId, itemVersionData);
 155     if (!response.isSuccessful()) {
 156       throw new RuntimeException(
 157           String.format("failed to update Item Version. ItemId: %s, versionId: %s, message: %s",
 158               itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 159     }
 160   }
 161
 162   @Override
 163   public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 164     Response<ItemVersion> response = versionAdaptorFactory.createInterface(context)
 165         .get(context, Space.PRIVATE, itemId, versionId);
 166     if (!response.isSuccessful()) {
 167       throw new RuntimeException(
 168           String.format("failed to get Item Version. ItemId: %s, versionId: %s, message: %s",
 169               itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 170     }
 171     return response.getValue();
 172   }
 173
 174   @Override
 175   public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 176     Response<ItemVersionStatus> response =
 177         versionAdaptorFactory.createInterface(context).getStatus(context, itemId, versionId);
 178     if (!response.isSuccessful()) {
 179       throw new RuntimeException(
 180           String.format("failed to get Item Version status. ItemId: %s, versionId: %s, message: %s",
 181               itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 182     }
 183     return response.getValue();
 184   }
 185
 186   @Override
 187   public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 188     Response<Void> response = versionAdaptorFactory.createInterface(context)
 189         .tag(context, itemId, versionId, null, tag);
 190     if (!response.isSuccessful()) {
 191       throw new RuntimeException(String.format(
 192           "failed to tag Item Version with tag %s. ItemId: %s, versionId: %s, message: %s",
 193           tag.getName(), itemId.getValue(), versionId.getValue(),
 194           response.getReturnCode().toString()));
 195     }
 196   }
 197
 198   @Override
 199   public void resetVersionRevision(SessionContext context, Id itemId, Id versionId,
 200                                    Id revisionId) {
 201     Response<Void> response = versionAdaptorFactory.createInterface(context)
 202         .resetRevision(context, itemId, versionId, revisionId);
 203     if (!response.isSuccessful()) {
 204       throw new RuntimeException(String.format(
 205           "failed to reset Item Version back to revision: %s. ItemId: %s, versionId: %s, message:" +
 206               " %s",
 207           revisionId.getValue(), itemId.getValue(), versionId.getValue(),
 208           response.getReturnCode().toString()));
 209     }
 210   }
 211
 212   @Override
 213   public void revertVersionRevision(SessionContext context, Id itemId, Id versionId,
 214                                     Id revisionId) {
 215     Response<Void> response = versionAdaptorFactory.createInterface(context)
 216         .revertRevision(context, itemId, versionId, revisionId);
 217     if (!response.isSuccessful()) {
 218       throw new RuntimeException(String.format(
 219           "failed to revert Item Version back to revision: %s. ItemId: %s, versionId: %s, " +
 220               "message: %s",
 221           revisionId.getValue(), itemId.getValue(), versionId.getValue(),
 222           response.getReturnCode().toString()));
 223     }
 224   }
 225
 226   @Override
 227   public ItemVersionRevisions listVersionRevisions(SessionContext context, Id itemId,
 228                                                    Id versionId) {
 229     Response<ItemVersionRevisions> response =
 230         versionAdaptorFactory.createInterface(context)
 231             .listRevisions(context, itemId, versionId);
 232     if (!response.isSuccessful()) {
 233       throw new RuntimeException(String.format(
 234           "failed to list revisions of Item Version. ItemId: %s, versionId: %s, message: %s",
 235           itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 236     }
 237     return response.getValue();
 238   }
 239
 240
 241   @Override
 242   public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 243     Response<Void> response =
 244         versionAdaptorFactory.createInterface(context).publish(context, itemId, versionId, message);
 245     if (!response.isSuccessful()) {
 246       throw new RuntimeException(String.format(
 247           "failed to publish item Version. ItemId: %s, versionId: %s, message: %s",
 248           itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 249     }
 250   }
 251
 252   @Override
 253   public void syncVersion(SessionContext context, Id itemId, Id versionId) {
 254     Response<MergeResult> response =
 255         versionAdaptorFactory.createInterface(context).sync(context, itemId, versionId);
 256     if (!response.isSuccessful()) {
 257       throw new RuntimeException(String.format(
 258           "failed to sync item Version. ItemId: %s, versionId: %s, message: %s",
 259           itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 260     }
 261   }
 262
 263   @Override
 264   public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 265     Response<MergeResult> response =
 266         versionAdaptorFactory.createInterface(context).forceSync(context, itemId, versionId);
 267     if (!response.isSuccessful()) {
 268       throw new RuntimeException(String.format(
 269           "failed to force sync item Version. ItemId: %s, versionId: %s, message: %s",
 270           itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 271     }
 272   }
 273
 274   @Override
 275   public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 276     Response<ItemVersionConflict> response =
 277         versionAdaptorFactory.createInterface(context).getConflict(context, itemId, versionId);
 278     if (!response.isSuccessful()) {
 279       throw new RuntimeException(String
 280           .format("failed to get Item Version conflict. ItemId: %s, versionId: %s, message: %s",
 281               itemId.getValue(), versionId.getValue(), response.getReturnCode().toString()));
 282     }
 283     return response.getValue();
 284   }
 285
 286   @Override
 287   public Collection<ElementInfo> listElements(SessionContext context,
 288                                               ElementContext elementContext,
 289                                               Id parentElementId) {
 290     Response<Collection<ElementInfo>> response = elementAdaptorFactory
 291         .createInterface(context).list(context, elementContext, parentElementId);
 292     if (response.isSuccessful()) {
 293       return response.getValue();
 294     } else {
 295       logErrorMessageToMdc(ItemElementLoggerTargetServiceName.ELEMENT_GET_BY_PROPERTY,
 296           response.getReturnCode());
 297       throw new RuntimeException(response.getReturnCode().toString());
 298     }
 299   }
 300
 301
 302   @Override
 303   public ElementInfo getElementInfo(SessionContext context, ElementContext elementContext,
 304                                     Id elementId) {
 305     Response<ElementInfo> response =
 306         elementAdaptorFactory.createInterface(context).getInfo(context, elementContext, elementId);
 307     if (!response.isSuccessful()) {
 308       throw buildGetElementException(elementContext, elementId,
 309           response.getReturnCode().toString());
 310
 311     }
 312     return response.getValue();
 313   }
 314
 315   @Override
 316   public Element getElement(SessionContext context, ElementContext elementContext,
 317                             Id elementId) {
 318     Response<Element> response =
 319         elementAdaptorFactory.createInterface(context).get(context, elementContext, elementId);
 320     if (!response.isSuccessful()) {
 321       throw buildGetElementException(elementContext, elementId,
 322           response.getReturnCode().toString());
 323     }
 324     return response.getValue();
 325   }
 326
 327   @Override
 328   public ElementConflict getElementConflict(SessionContext context, ElementContext elementContext,
 329                                             Id elementId) {
 330     Response<ElementConflict> response = elementAdaptorFactory.createInterface(context)
 331         .getConflict(context, elementContext, elementId);
 332     if (!response.isSuccessful()) {
 333       throw new RuntimeException(String.format(
 334           "Failed to get element conflict. Item Id: %s, version Id: %s, element Id: %s message: %s",
 335           elementContext.getItemId().getValue(), elementContext.getVersionId().getValue(),
 336           elementId.getValue(), response.getReturnCode().toString()));
 337     }
 338     return response.getValue();
 339   }
 340
 341   @Override
 342   public Element saveElement(SessionContext context, ElementContext elementContext,
 343                              ZusammenElement element, String message) {
 344     Response<Element> response = elementAdaptorFactory.createInterface(context)
 345         .save(context, elementContext, element, message);
 346     if (!response.isSuccessful()) {
 347       throw new RuntimeException(String
 348           .format("Failed to create element %s. ItemId: %s, versionId: %s, message: %s",
 349               element.getElementId().getValue(), elementContext.getItemId().getValue(),
 350               elementContext.getVersionId().getValue(), response.getReturnCode().toString()));
 351     }
 352     return response.getValue();
 353   }
 354
 355   @Override
 356   public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 357                                      ZusammenElement element,
 358                                      Resolution resolution) {
 359     Response<Void> response = elementAdaptorFactory.createInterface(context)
 360         .resolveConflict(context, elementContext, element, resolution);
 361     if (!response.isSuccessful()) {
 362       throw new RuntimeException(
 363           "Failed to resolve conflict. message:" + response.getReturnCode().toString());
 364     }
 365   }
 366
 367   @Override
 368   public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 369                                   String revision_id) {
 370
 371   }
 372
 373   private RuntimeException buildGetElementException(ElementContext elementContext, Id elementId,
 374                                                     String zusammenErrorMessage) {
 375     if (elementContext.getRevisionId() == null) {
 376       return new RuntimeException(String.format(GET_ELEMENT_ERR_MSG,
 377           elementContext.getItemId().getValue(), elementContext.getVersionId().getValue(),
 378           elementId.getValue(), zusammenErrorMessage));
 379     }
 380     return new RuntimeException(String.format(GET_ELEMENT_IN_REV_ERR_MSG,
 381         elementContext.getItemId().getValue(), elementContext.getVersionId().getValue(),
 382         elementContext.getRevisionId().getValue(),
 383         elementId.getValue(), zusammenErrorMessage));
 384   }
 385
 386   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 387                                         itemElementLoggerTargetServiceName,
 388                                     ReturnCode returnCode) {
 389     logErrorMessageToMdc(itemElementLoggerTargetServiceName, returnCode.toString());
 390   }
 391
 392   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 393                                         itemElementLoggerTargetServiceName,
 394                                     String message) {
 395     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 396         itemElementLoggerTargetServiceName.getDescription(),
 397         ErrorLevel.ERROR.name(),
 398         LoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode(),
 399         message);
 400   }
 401
 402
 403 }