public PutMetricAlarmResponseType putMetricAlarm(PutMetricAlarmType request)
      throws CloudWatchException {
    PutMetricAlarmResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_PUTMETRICALARM, ctx);

      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      final Boolean actionsEnabled = validateActionsEnabled(request.getActionsEnabled(), true);
      final Map<String, String> dimensionMap =
          TransformationFunctions.DimensionsToMap.INSTANCE.apply(
              validateDimensions(request.getDimensions()));
      final Collection<String> alarmActions =
          validateActions(request.getAlarmActions(), dimensionMap, "AlarmActions");
      final String alarmDescription = validateAlarmDescription(request.getAlarmDescription());
      final String alarmName = validateAlarmName(request.getAlarmName(), true);
      final ComparisonOperator comparisonOperator =
          validateComparisonOperator(request.getComparisonOperator(), true);
      Integer evaluationPeriods = validateEvaluationPeriods(request.getEvaluationPeriods(), true);
      final Integer period = validatePeriod(request.getPeriod(), true);
      validatePeriodAndEvaluationPeriodsNotAcrossDays(period, evaluationPeriods);
      final Collection<String> insufficientDataActions =
          validateActions(
              request.getInsufficientDataActions(), dimensionMap, "InsufficientDataActions");
      final String metricName = validateMetricName(request.getMetricName(), true);
      final String namespace = validateNamespace(request.getNamespace(), true);
      final Collection<String> okActions =
          validateActions(request.getOkActions(), dimensionMap, "OKActions");
      final Statistic statistic = validateStatistic(request.getStatistic(), true);
      final Double threshold = validateThreshold(request.getThreshold(), true);
      final Units unit = validateUnits(request.getUnit(), true);
      if (AlarmManager.countMetricAlarms(accountId) >= 5000) {
        throw new LimitExceededException("The maximum limit of 5000 alarms would be exceeded.");
      }
      AlarmManager.putMetricAlarm(
          accountId,
          actionsEnabled,
          alarmActions,
          alarmDescription,
          alarmName,
          comparisonOperator,
          dimensionMap,
          evaluationPeriods,
          insufficientDataActions,
          metricName,
          getMetricTypeFromNamespace(namespace),
          namespace,
          okActions,
          period,
          statistic,
          threshold,
          unit);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public PutMetricDataResponseType putMetricData(PutMetricDataType request)
      throws CloudWatchException {
    PutMetricDataResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      LOG.trace("put metric data called");
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_PUTMETRICDATA, ctx);

      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final List<MetricDatum> metricData = validateMetricData(request.getMetricData());
      final String namespace = validateNamespace(request.getNamespace(), true);
      final Boolean isUserAccountAdmin =
          Principals.isSameUser(
              Principals.systemUser(), Wrappers.unwrap(Context.class, Contexts.lookup()).getUser());
      LOG.trace("Namespace=" + namespace);
      LOG.trace("metricData=" + metricData);
      MetricType metricType = getMetricTypeFromNamespace(namespace);
      if (metricType == MetricType.System && !isUserAccountAdmin) {
        throw new InvalidParameterValueException(
            "The value AWS/ for parameter Namespace is invalid.");
      }
      MetricDataQueue.getInstance()
          .insertMetricData(ownerFullName.getAccountNumber(), namespace, metricData, metricType);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public DescribeAlarmsForMetricResponseType describeAlarmsForMetric(
      DescribeAlarmsForMetricType request) throws CloudWatchException {
    DescribeAlarmsForMetricResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_DESCRIBEALARMSFORMETRIC, ctx);
      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      final Map<String, String> dimensionMap =
          TransformationFunctions.DimensionsToMap.INSTANCE.apply(
              validateDimensions(request.getDimensions()));
      final String metricName = validateMetricName(request.getMetricName(), true);
      final String namespace = validateNamespace(request.getNamespace(), true);
      final Integer period = validatePeriod(request.getPeriod(), false);
      final Statistic statistic = validateStatistic(request.getStatistic(), false);
      final Units unit = validateUnits(request.getUnit(), true);
      Collection<AlarmEntity> results =
          AlarmManager.describeAlarmsForMetric(
              accountId, dimensionMap, metricName, namespace, period, statistic, unit);
      MetricAlarms metricAlarms = new MetricAlarms();
      metricAlarms.setMember(
          Lists.newArrayList(
              Collections2.<AlarmEntity, MetricAlarm>transform(
                  results, TransformationFunctions.AlarmEntityToMetricAlarm.INSTANCE)));
      reply.getDescribeAlarmsForMetricResult().setMetricAlarms(metricAlarms);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public GetMetricStatisticsResponseType getMetricStatistics(GetMetricStatisticsType request)
      throws CloudWatchException {
    GetMetricStatisticsResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();
    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_GETMETRICSTATISTICS, ctx);

      // TODO: parse statistics separately()?
      final OwnerFullName ownerFullName = ctx.getUserFullName();
      Statistics statistics = validateStatistics(request.getStatistics());
      final String namespace = validateNamespace(request.getNamespace(), true);
      final String metricName = validateMetricName(request.getMetricName(), true);
      final Date startTime =
          MetricManager.stripSeconds(validateStartTime(request.getStartTime(), true));
      final Date endTime = MetricManager.stripSeconds(validateEndTime(request.getEndTime(), true));
      final Integer period = validatePeriod(request.getPeriod(), true);
      validateDateOrder(startTime, endTime, "StartTime", "EndTime", true, true);
      validateNotTooManyDataPoints(startTime, endTime, period, 1440L);

      // TODO: null units here does not mean Units.NONE but basically a
      // wildcard.
      // Consider this case.
      final Units units = validateUnits(request.getUnit(), false);
      final Map<String, String> dimensionMap =
          TransformationFunctions.DimensionsToMap.INSTANCE.apply(
              validateDimensions(request.getDimensions()));
      Collection<MetricStatistics> metrics;
      metrics =
          MetricManager.getMetricStatistics(
              ownerFullName.getAccountNumber(),
              metricName,
              namespace,
              dimensionMap,
              getMetricTypeFromNamespace(namespace),
              units,
              startTime,
              endTime,
              period);
      reply.getGetMetricStatisticsResult().setLabel(metricName);
      ArrayList<Datapoint> datapoints = convertMetricStatisticsToDataoints(statistics, metrics);
      if (datapoints.size() > 0) {
        Datapoints datapointsReply = new Datapoints();
        datapointsReply.setMember(datapoints);
        reply.getGetMetricStatisticsResult().setDatapoints(datapointsReply);
      }
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public ListMetricsResponseType listMetrics(ListMetricsType request) throws CloudWatchException {
    ListMetricsResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_LISTMETRICS, ctx);

      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String namespace = validateNamespace(request.getNamespace(), false);
      final String metricName = validateMetricName(request.getMetricName(), false);
      final Map<String, String> dimensionMap =
          TransformationFunctions.DimensionFiltersToMap.INSTANCE.apply(
              validateDimensionFilters(request.getDimensions()));

      // take all stats updated after two weeks ago
      final Date after = new Date(System.currentTimeMillis() - 2 * 7 * 24 * 60 * 60 * 1000L);
      final Date before = null; // no bound on time before stats are updated
      // (though maybe 'now')
      final Integer maxRecords = 500; // per the API docs
      final String nextToken = request.getNextToken();
      final List<ListMetric> results =
          ListMetricManager.listMetrics(
              ownerFullName.getAccountNumber(),
              metricName,
              namespace,
              dimensionMap,
              after,
              before,
              maxRecords,
              nextToken);

      final Metrics metrics = new Metrics();
      metrics.setMember(
          Lists.newArrayList(
              Collections2.<ListMetric, Metric>transform(
                  results, TransformationFunctions.ListMetricToMetric.INSTANCE)));
      final ListMetricsResult listMetricsResult = new ListMetricsResult();
      listMetricsResult.setMetrics(metrics);
      if (maxRecords != null && results.size() == maxRecords) {
        listMetricsResult.setNextToken(results.get(results.size() - 1).getNaturalId());
      }
      reply.setListMetricsResult(listMetricsResult);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
 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) {
   }
 }
  public DisableAlarmActionsResponseType disableAlarmActions(DisableAlarmActionsType request)
      throws EucalyptusCloudException {
    DisableAlarmActionsResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_DISABLEALARMACTIONS, ctx);
      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      Collection<String> alarmNames = validateAlarmNames(request.getAlarmNames(), true);
      AlarmManager.disableAlarmActions(accountId, alarmNames);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
Exemple #8
0
 private void fireUsageEvent(
     final OwnerFullName ownerFullName,
     final Supplier<EventActionInfo<AddressAction>> actionInfoSupplier) {
   if (!Principals.isFakeIdentityAccountNumber(ownerFullName.getAccountNumber())) {
     try {
       ListenerRegistry.getInstance()
           .fireEvent(
               AddressEvent.with(
                   getNaturalId(),
                   getDisplayName(),
                   ownerFullName,
                   Accounts.lookupAccountById(ownerFullName.getAccountNumber()).getName(),
                   actionInfoSupplier.get()));
     } catch (final Exception e) {
       LOG.error(e, e);
     }
   }
 }
  public DescribeAlarmsResponseType describeAlarms(DescribeAlarmsType request)
      throws CloudWatchException {
    DescribeAlarmsResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_DESCRIBEALARMS, ctx);

      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      final String actionPrefix = validateActionPrefix(request.getActionPrefix(), false);
      final String alarmNamePrefix = validateAlarmNamePrefix(request.getAlarmNamePrefix(), false);
      final Collection<String> alarmNames = validateAlarmNames(request.getAlarmNames(), false);
      validateNotBothAlarmNamesAndAlarmNamePrefix(alarmNames, alarmNamePrefix);
      final Integer maxRecords = validateMaxRecords(request.getMaxRecords());
      final String nextToken = request.getNextToken();
      final StateValue stateValue = validateStateValue(request.getStateValue(), false);
      List<AlarmEntity> results =
          AlarmManager.describeAlarms(
              accountId,
              actionPrefix,
              alarmNamePrefix,
              alarmNames,
              maxRecords,
              stateValue,
              nextToken);
      if (maxRecords != null && results.size() == maxRecords) {
        reply
            .getDescribeAlarmsResult()
            .setNextToken(results.get(results.size() - 1).getNaturalId());
      }
      MetricAlarms metricAlarms = new MetricAlarms();
      metricAlarms.setMember(
          Lists.newArrayList(
              Collections2.<AlarmEntity, MetricAlarm>transform(
                  results, TransformationFunctions.AlarmEntityToMetricAlarm.INSTANCE)));
      reply.getDescribeAlarmsResult().setMetricAlarms(metricAlarms);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public SetAlarmStateResponseType setAlarmState(SetAlarmStateType request)
      throws CloudWatchException {
    SetAlarmStateResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();
    try {

      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_SETALARMSTATE, ctx);
      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      final String alarmName = validateAlarmName(request.getAlarmName(), true);
      final String stateReason = validateStateReason(request.getStateReason(), true);
      final String stateReasonData = validateStateReasonData(request.getStateReasonData(), false);
      final StateValue stateValue = validateStateValue(request.getStateValue(), true);
      AlarmManager.setAlarmState(accountId, alarmName, stateReason, stateReasonData, stateValue);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public DescribeAlarmHistoryResponseType describeAlarmHistory(DescribeAlarmHistoryType request)
      throws CloudWatchException {
    DescribeAlarmHistoryResponseType reply = request.getReply();
    final Context ctx = Contexts.lookup();

    try {
      // IAM Action Check
      checkActionPermission(PolicySpec.CLOUDWATCH_DESCRIBEALARMHISTORY, ctx);

      final OwnerFullName ownerFullName = ctx.getUserFullName();
      final String accountId = ownerFullName.getAccountNumber();
      final String alarmName = validateAlarmName(request.getAlarmName(), false);
      final Date endDate = validateEndDate(request.getEndDate(), false);
      final Date startDate = validateStartDate(request.getStartDate(), false);
      validateDateOrder(startDate, endDate, "StartDate", "EndDate", false, false);
      final HistoryItemType historyItemType =
          validateHistoryItemType(request.getHistoryItemType(), false);
      final Integer maxRecords = validateMaxRecords(request.getMaxRecords());
      final String nextToken = request.getNextToken();
      List<AlarmHistory> results =
          AlarmManager.describeAlarmHistory(
              accountId, alarmName, endDate, historyItemType, maxRecords, startDate, nextToken);
      if (maxRecords != null && results.size() == maxRecords) {
        reply
            .getDescribeAlarmHistoryResult()
            .setNextToken(results.get(results.size() - 1).getNaturalId());
      }
      AlarmHistoryItems alarmHistoryItems = new AlarmHistoryItems();
      alarmHistoryItems.setMember(
          Lists.newArrayList(
              Collections2.<AlarmHistory, AlarmHistoryItem>transform(
                  results, TransformationFunctions.AlarmHistoryToAlarmHistoryItem.INSTANCE)));
      reply.getDescribeAlarmHistoryResult().setAlarmHistoryItems(alarmHistoryItems);
    } catch (Exception ex) {
      handleException(ex);
    }
    return reply;
  }
  public static NetworkGroup create(
      final OwnerFullName ownerFullName, final String groupName, final String groupDescription)
      throws MetadataException {
    UserFullName userFullName = null;
    if (ownerFullName instanceof UserFullName) {
      userFullName = (UserFullName) ownerFullName;
    } else {
      try {
        Account account = Accounts.lookupAccountById(ownerFullName.getAccountNumber());
        User admin =
            Iterables.find(
                account.getUsers(),
                new Predicate<User>() {

                  @Override
                  public boolean apply(User input) {
                    return input.isAccountAdmin();
                  }
                });
        userFullName = UserFullName.getInstance(admin);
      } catch (Exception ex) {
        LOG.error(ex, ex);
        throw new NoSuchMetadataException(
            "Failed to create group because owning user could not be identified.", ex);
      }
    }

    final EntityTransaction db = Entities.get(NetworkGroup.class);
    try {
      NetworkGroup net =
          Entities.uniqueResult(
              new NetworkGroup(
                  AccountFullName.getInstance(userFullName.getAccountNumber()), groupName));
      if (net == null) {
        final NetworkGroup entity =
            Entities.persist(new NetworkGroup(userFullName, groupName, groupDescription));
        db.commit();
        return entity;
      } else {
        db.rollback();
        throw new DuplicateMetadataException(
            "Failed to create group: " + groupName + " for " + userFullName.toString());
      }
    } catch (final NoSuchElementException ex) {
      final NetworkGroup entity =
          Entities.persist(new NetworkGroup(userFullName, groupName, groupDescription));
      db.commit();
      return entity;
    } catch (final ConstraintViolationException ex) {
      Logs.exhaust().error(ex);
      db.rollback();
      throw new DuplicateMetadataException(
          "Failed to create group: " + groupName + " for " + userFullName.toString(), ex);
    } catch (final Exception ex) {
      Logs.exhaust().error(ex, ex);
      db.rollback();
      throw new MetadataException(
          "Failed to create group: " + groupName + " for " + userFullName.toString(),
          PersistenceExceptions.transform(ex));
    }
  }