gerrit.onap Code Review - sdc.git/blob

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