openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-core/src/main/java/org/openecomp/core/zusammen/db/impl/ZusammenConnectorImpl.java

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