Exemplo n.º 1
0
 static void createDefault(final OwnerFullName ownerFullName) throws MetadataException {
   try {
     try {
       NetworkGroup net =
           Transactions.find(
               new NetworkGroup(
                   AccountFullName.getInstance(ownerFullName.getAccountNumber()),
                   NETWORK_DEFAULT_NAME));
       if (net == null) {
         create(ownerFullName, NETWORK_DEFAULT_NAME, "default group");
       }
     } catch (NoSuchElementException ex) {
       try {
         create(ownerFullName, NETWORK_DEFAULT_NAME, "default group");
       } catch (ConstraintViolationException ex1) {
       }
     } catch (TransactionException ex) {
       try {
         create(ownerFullName, NETWORK_DEFAULT_NAME, "default group");
       } catch (ConstraintViolationException ex1) {
       }
     }
   } catch (DuplicateMetadataException ex) {
   }
 }
Exemplo n.º 2
0
  public CreateVolumeResponseType CreateVolume(final CreateVolumeType request)
      throws EucalyptusCloudException, AuthException {
    Context ctx = Contexts.lookup();
    Long volSize = request.getSize() != null ? Long.parseLong(request.getSize()) : null;
    final String snapId = request.getSnapshotId();
    String partition = request.getAvailabilityZone();

    if ((request.getSnapshotId() == null && request.getSize() == null)) {
      throw new EucalyptusCloudException("One of size or snapshotId is required as a parameter.");
    }

    if (snapId != null) {
      try {
        Transactions.find(Snapshot.named(null, snapId));
      } catch (ExecutionException ex) {
        throw new EucalyptusCloudException(
            "Failed to create volume because the referenced snapshot id is invalid: " + snapId);
      }
    }
    final Integer newSize = new Integer(request.getSize() != null ? request.getSize() : "-1");
    Exception lastEx = null;
    for (int i = 0; i < VOL_CREATE_RETRIES; i++) {
      try {
        final ServiceConfiguration sc =
            Topology.lookup(Storage.class, Partitions.lookupByName(partition));
        final UserFullName owner = ctx.getUserFullName();
        Function<Long, Volume> allocator =
            new Function<Long, Volume>() {

              @Override
              public Volume apply(Long size) {
                try {
                  return Volumes.createStorageVolume(
                      sc, owner, snapId, Ints.checkedCast(size), request);
                } catch (ExecutionException ex) {
                  throw Exceptions.toUndeclared(ex);
                }
              }
            };
        Volume newVol = RestrictedTypes.allocateMeasurableResource(newSize.longValue(), allocator);
        CreateVolumeResponseType reply = request.getReply();
        reply.setVolume(newVol.morph(new edu.ucsb.eucalyptus.msgs.Volume()));
        return reply;
      } catch (RuntimeException ex) {
        LOG.error(ex, ex);
        if (!(ex.getCause() instanceof ExecutionException)) {
          throw ex;
        } else {
          lastEx = ex;
        }
      }
    }
    throw new EucalyptusCloudException(
        "Failed to create volume after " + VOL_CREATE_RETRIES + " because of: " + lastEx, lastEx);
  }
Exemplo n.º 3
0
 public ImageInfo resetProductCodes() {
   try {
     Transactions.one(
         ImageInfo.self(this),
         new Callback<ImageInfo>() {
           @Override
           public void fire(final ImageInfo t) {
             t.getProductCodes().clear();
           }
         });
   } catch (final ExecutionException e) {
     LOG.debug(e, e);
   }
   return this;
 }
Exemplo n.º 4
0
 public ImageInfo resetPermission() {
   try {
     Transactions.one(
         new ImageInfo(this.displayName),
         new Callback<ImageInfo>() {
           @Override
           public void fire(final ImageInfo t) {
             t.getPermissions().clear();
             t.getPermissions().add(t.getOwnerAccountNumber());
             t.setImagePublic(ImageConfiguration.getInstance().getDefaultVisibility());
           }
         });
   } catch (final ExecutionException e) {
     LOG.debug(e, e);
   }
   return this;
 }
Exemplo n.º 5
0
  public static Volume checkVolumeReady(final Volume vol) throws EucalyptusCloudException {
    if (vol.isReady()) {
      return vol;
    } else {
      // TODO:GRZE:REMOVE temporary workaround to update the volume state.
      final ServiceConfiguration sc =
          Topology.lookup(Storage.class, Partitions.lookupByName(vol.getPartition()));
      final DescribeStorageVolumesType descVols =
          new DescribeStorageVolumesType(Lists.newArrayList(vol.getDisplayName()));
      try {
        Transactions.one(
            Volume.named(null, vol.getDisplayName()),
            new Callback<Volume>() {

              @Override
              public void fire(final Volume t) {
                try {
                  final DescribeStorageVolumesResponseType volState =
                      AsyncRequests.sendSync(sc, descVols);
                  if (!volState.getVolumeSet().isEmpty()) {
                    final State newVolumeState =
                        Volumes.transformStorageState(
                            vol.getState(), volState.getVolumeSet().get(0).getStatus());
                    vol.setState(newVolumeState);
                  }
                } catch (final Exception ex) {
                  LOG.error(ex);
                  Logs.extreme().error(ex, ex);
                  throw Exceptions.toUndeclared(
                      "Failed to update the volume state "
                          + vol.getDisplayName()
                          + " not yet ready",
                      ex);
                }
              }
            });
      } catch (final ExecutionException ex) {
        throw new EucalyptusCloudException(ex.getCause());
      }
      if (!vol.isReady()) {
        throw new EucalyptusCloudException("Volume " + vol.getDisplayName() + " not yet ready");
      }
      return vol;
    }
  }
 @Override
 public boolean delete(final AutoScalingMetadata metadata) throws AutoScalingMetadataException {
   if (metadata instanceof AutoScalingMetadataWithResourceName) {
     try {
       return Transactions.delete(
           exampleWithUuid(
               AutoScalingResourceName.parse(
                       ((AutoScalingMetadataWithResourceName) metadata).getArn(), type)
                   .getUuid()));
     } catch (NoSuchElementException e) {
       return false;
     } catch (Exception e) {
       throw new AutoScalingMetadataException(
           "Error deleting " + typeDescription + " '" + describe(metadata) + "'", e);
     }
   } else {
     return super.delete(metadata);
   }
 }
Exemplo n.º 7
0
  public static Volume createStorageVolume(
      final ServiceConfiguration sc,
      final UserFullName owner,
      final String snapId,
      final Integer newSize,
      final BaseMessage request)
      throws ExecutionException {
    final String newId = ResourceIdentifiers.generateString(ID_PREFIX);
    LOG.debug("Creating volume");
    final Volume newVol =
        Transactions.save(
            Volume.create(sc, owner, snapId, newSize, newId),
            new Callback<Volume>() {

              @Override
              public void fire(final Volume t) {
                t.setState(State.GENERATING);
                try {
                  final CreateStorageVolumeType req =
                      new CreateStorageVolumeType(t.getDisplayName(), t.getSize(), snapId, null)
                          .regarding(request);
                  final CreateStorageVolumeResponseType ret = AsyncRequests.sendSync(sc, req);
                  LOG.debug("Volume created");

                  if (t.getSize() != null && t.getSize() > 0) {
                    fireUsageEvent(t, VolumeEvent.forVolumeCreate());
                  }
                } catch (final Exception ex) {
                  LOG.error("Failed to create volume: " + t, ex);
                  t.setState(State.FAIL);
                  throw Exceptions.toUndeclared(ex);
                }
              }
            });
    return newVol;
  }
Exemplo n.º 8
0
  @Override
  public void run() {
    try {
      SnapshotInfo searchSnap = new SnapshotInfo();
      searchSnap.setStatus(StorageProperties.Status.deleting.toString());
      List<SnapshotInfo> snapshotsToBeDeleted = null;
      try {
        snapshotsToBeDeleted = Transactions.findAll(searchSnap);
      } catch (Exception e) {
        LOG.error("Failed to lookup snapshots marked for deletion", e);
        return;
      }
      if (snapshotsToBeDeleted != null && !snapshotsToBeDeleted.isEmpty()) {
        for (SnapshotInfo snap : snapshotsToBeDeleted) {
          String snapshotId = snap.getSnapshotId();
          LOG.info("Snapshot: " + snapshotId + " was marked for deletion. Cleaning up...");
          try {
            blockManager.deleteSnapshot(snapshotId);
          } catch (EucalyptusCloudException e1) {
            LOG.debug("Failed to delete " + snapshotId, e1);
            LOG.warn("Unable to delete " + snapshotId + ". Will retry later");
            continue;
          }
          SnapshotInfo snapInfo = new SnapshotInfo(snapshotId);

          SnapshotInfo foundSnapshotInfo;
          try (TransactionResource tran = Entities.transactionFor(SnapshotInfo.class)) {
            foundSnapshotInfo = Entities.uniqueResult(snapInfo);
            foundSnapshotInfo.setStatus(StorageProperties.Status.deleted.toString());
            foundSnapshotInfo.setDeletionTime(new Date());
            tran.commit();
          } catch (TransactionException | NoSuchElementException e) {
            LOG.error(e);
            continue;
          }

          if (StringUtils.isNotBlank(foundSnapshotInfo.getSnapshotLocation())) {
            try {
              String[] names =
                  SnapshotInfo.getSnapshotBucketKeyNames(foundSnapshotInfo.getSnapshotLocation());
              if (snapshotTransfer == null) {
                snapshotTransfer = new S3SnapshotTransfer();
              }
              snapshotTransfer.setSnapshotId(snapshotId);
              snapshotTransfer.setBucketName(names[0]);
              snapshotTransfer.setKeyName(names[1]);
              snapshotTransfer.delete();
            } catch (Exception e) {
              LOG.warn("Failed to delete snapshot " + snapshotId + " from objectstorage", e);
            }
          } else {
            LOG.debug(
                "Snapshot location missing for "
                    + snapshotId
                    + ". Skipping deletion from ObjectStorageGateway");
          }
        }
      } else {
        LOG.trace("No snapshots marked for deletion");
      }
    } catch (Exception e) { // could catch InterruptedException
      LOG.warn("Unable to remove snapshots marked for deletion", e);
      return;
    }
  }
Exemplo n.º 9
0
  public static synchronized void updateNetworkRangeConfiguration() {
    final AtomicReference<NetworkRangeConfiguration> equalityCheck =
        new AtomicReference<NetworkRangeConfiguration>(null);
    try {
      Transactions.each(
          new ClusterConfiguration(),
          new Callback<ClusterConfiguration>() {

            @Override
            public void fire(final ClusterConfiguration input) {
              NetworkRangeConfiguration comparisonConfig = new NetworkRangeConfiguration();
              comparisonConfig.setUseNetworkTags(input.getUseNetworkTags());
              comparisonConfig.setMinNetworkTag(input.getMinNetworkTag());
              comparisonConfig.setMaxNetworkTag(input.getMaxNetworkTag());
              comparisonConfig.setMinNetworkIndex(input.getMinNetworkIndex());
              comparisonConfig.setMaxNetworkIndex(input.getMaxNetworkIndex());
              Logs.extreme()
                  .debug(
                      "Updating cluster config: "
                          + input.getName()
                          + " "
                          + comparisonConfig.toString());
              if (equalityCheck.compareAndSet(null, comparisonConfig)) {
                Logs.extreme().debug("Initialized cluster config check: " + equalityCheck.get());
              } else {
                NetworkRangeConfiguration currentConfig = equalityCheck.get();
                List<String> errors = Lists.newArrayList();
                if (!currentConfig
                    .getUseNetworkTags()
                    .equals(comparisonConfig.getUseNetworkTags())) {
                  errors.add(
                      input.getName()
                          + " network config mismatch: vlan tagging  "
                          + currentConfig.getUseNetworkTags()
                          + " != "
                          + comparisonConfig.getUseNetworkTags());
                } else if (!currentConfig
                    .getMinNetworkTag()
                    .equals(comparisonConfig.getMinNetworkTag())) {
                  errors.add(
                      input.getName()
                          + " network config mismatch: min vlan tag "
                          + currentConfig.getMinNetworkTag()
                          + " != "
                          + comparisonConfig.getMinNetworkTag());
                } else if (!currentConfig
                    .getMaxNetworkTag()
                    .equals(comparisonConfig.getMaxNetworkTag())) {
                  errors.add(
                      input.getName()
                          + " network config mismatch: max vlan tag "
                          + currentConfig.getMaxNetworkTag()
                          + " != "
                          + comparisonConfig.getMaxNetworkTag());
                } else if (!currentConfig
                    .getMinNetworkIndex()
                    .equals(comparisonConfig.getMinNetworkIndex())) {
                  errors.add(
                      input.getName()
                          + " network config mismatch: min net index "
                          + currentConfig.getMinNetworkIndex()
                          + " != "
                          + comparisonConfig.getMinNetworkIndex());
                } else if (!currentConfig
                    .getMaxNetworkIndex()
                    .equals(comparisonConfig.getMaxNetworkIndex())) {
                  errors.add(
                      input.getName()
                          + " network config mismatch: max net index "
                          + currentConfig.getMaxNetworkIndex()
                          + " != "
                          + comparisonConfig.getMaxNetworkIndex());
                }
              }
            }
          });
    } catch (RuntimeException ex) {
      Logs.extreme().error(ex, ex);
      throw ex;
    } catch (TransactionException ex) {
      LOG.error(ex);
      Logs.extreme().error(ex, ex);
    }

    netConfig = new NetworkRangeConfiguration();
    final AtomicBoolean netTagging = new AtomicBoolean(true);
    try {
      Transactions.each(
          new ClusterConfiguration(),
          new Callback<ClusterConfiguration>() {

            @Override
            public void fire(final ClusterConfiguration input) {
              netTagging.compareAndSet(true, input.getUseNetworkTags());

              netConfig.setMinNetworkTag(
                  Ints.max(netConfig.getMinNetworkTag(), input.getMinNetworkTag()));
              netConfig.setMaxNetworkTag(
                  Ints.min(netConfig.getMaxNetworkTag(), input.getMaxNetworkTag()));

              netConfig.setMinNetworkIndex(
                  Longs.max(netConfig.getMinNetworkIndex(), input.getMinNetworkIndex()));
              netConfig.setMaxNetworkIndex(
                  Longs.min(netConfig.getMaxNetworkIndex(), input.getMaxNetworkIndex()));
            }
          });
      Logs.extreme().debug("Updated network configuration: " + netConfig.toString());
    } catch (final TransactionException ex) {
      Logs.extreme().error(ex, ex);
    }
    netConfig.setUseNetworkTags(netTagging.get());
    final EntityTransaction db = Entities.get(NetworkGroup.class);
    try {
      final List<NetworkGroup> ret = Entities.query(new NetworkGroup());
      for (NetworkGroup group : ret) {
        ExtantNetwork exNet = group.getExtantNetwork();
        if (exNet != null
            && (exNet.getTag() > netConfig.getMaxNetworkTag()
                || exNet.getTag() < netConfig.getMinNetworkTag())) {
          exNet.teardown();
          Entities.delete(exNet);
          group.setExtantNetwork(null);
        }
      }
      db.commit();
    } catch (final Exception ex) {
      Logs.extreme().error(ex, ex);
      LOG.error(ex);
      db.rollback();
    }
  }