import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
private void getRDSInstances() {
	DescribeDBInstancesResult response = rdsClient.describeDBInstances(new DescribeDBInstancesRequest());
	
	List<PulseInstance> rds = new ArrayList<PulseInstance>();

	PulseInstance pulse = null;
	for (DBInstance instance : response.getDBInstances()) {
		ListTagsForResourceResult result = rdsClient.listTagsForResource(new ListTagsForResourceRequest().withResourceName(instance.getDBInstanceArn()));
		
		for (com.amazonaws.services.rds.model.Tag tag : result.getTagList()) {
			if (tag.getKey().equals(properties.getTag()) && (tag.getValue().equals("TRUE") || tag.getValue().equals("True") || tag.getValue().equals("true"))) {
				pulse = new PulseInstance();
				pulse.setId(instance.getDBInstanceIdentifier());
				pulse.setName(instance.getDBInstanceIdentifier());
				pulse.setAddress(instance.getEndpoint().getAddress());
				pulse.setType(instance.getDBInstanceClass());
				
				rds.add(pulse);
			}
		}
	}
	
	GetMonitoringInstances.rds = rds;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
/**
 * Test helper - makes describe result with a named instance.
 */
private DescribeDBInstancesResult makeDescribeDBInstancesResult(String... instanceNames)
{
  DescribeDBInstancesResult result = new DescribeDBInstancesResult();
  List<DBInstance> dbInstances = new ArrayList<DBInstance>();
  if (ArrayUtils.isNotEmpty(instanceNames))
  {
    for (String instanceName : instanceNames)
    {
      DBInstance dbInstance = new DBInstance();
      dbInstance.setDBInstanceIdentifier(instanceName);
      dbInstances.add(dbInstance);
    }
  }
  result.setDBInstances(dbInstances);
  return result;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
public void describe(String dbInstanceIdentifier) throws Exception {
    while (true) {
        DescribeDBInstancesRequest request = new DescribeDBInstancesRequest()
                .withDBInstanceIdentifier(dbInstanceIdentifier);

        DescribeDBInstancesResult response = client.describeDBInstances(request);
        DBInstance dbInstance = response.getDBInstances().get(0);
        if (!dbInstance.getDBInstanceStatus().equalsIgnoreCase("creating")) {
            System.out.println("Done! " + response);
            System.out.println(dbInstance.getEndpoint().getAddress());
            System.out.println(dbInstance.getEndpoint().getPort());
            break;
        }

        System.out.println("Not done - will wait 10s: " + response);
        Thread.sleep(10000L);
    }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
private void fetchInstanceMetrics() throws CandlestackAWSException, CandlestackException {
	Set<String> replicaInstances = RDSUtil.getReplicaInstances( rdsClient );

	DescribeDBInstancesResult dbInstanceResults = rdsClient.describeDBInstances();
	for ( DBInstance dbInstance : dbInstanceResults.getDBInstances() ) {

		String dbInstanceId = dbInstance.getDBInstanceIdentifier();
		RDSType rdsType = RDSType.getTypeFromEngine( dbInstance.getEngine() );
		if ( !RDSUtil.isDBInstanceEligible( dbInstanceId, dbInstancePrefix, dbInstanceRegex, rdsType ) ) {
			continue;
		}

		for ( RDSCloudWatchMetric cloudWatchMetric : cloudWatchMetrics ) {
			if ( cloudWatchMetric.isRDSTypeSupported( rdsType ) && !cloudWatchMetric.isClusterOnlyMetric() && ( !cloudWatchMetric.isReplicaOnlyMetric() || replicaInstances.contains( dbInstanceId ) ) ) {
				cloudWatchAccessor.lookupAndSaveMetricData( cloudWatchMetric, dbInstanceId, RDSUtil.TYPE_NAME );
			}
		}

	}
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Override
public List<Endpoint> getReadReplicaEndpoints(String dbInstanceId) {
	List<Endpoint> endpoints = null;
	
	DescribeDBInstancesResult result = rds.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier(dbInstanceId));
	
	// If the master exist and has any read replicas
	if(result.getDBInstances().size() == 1 && result.getDBInstances().get(0).getReadReplicaDBInstanceIdentifiers().size() > 0) {
		endpoints = new ArrayList<Endpoint>();
		for(String readReplicaId : result.getDBInstances().get(0).getReadReplicaDBInstanceIdentifiers()) {
			DBInstance rrInstance = rds.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier(readReplicaId)).getDBInstances().get(0);
			if (rrInstance.getDBInstanceStatus().equals("available")) {
				endpoints.add(rrInstance.getEndpoint());
			}
		}
		if(endpoints.size() == 0) {
			endpoints = null;
		}
		
	}
	
	return endpoints;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
private boolean isDatabaseAvailable(RetryContext context) {
    DescribeDBInstancesResult describeDBInstancesResult;
    try {
        describeDBInstancesResult = this.amazonRDS.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier((String) context.getAttribute(DB_INSTANCE_ATTRIBUTE_NAME)));
    } catch (DBInstanceNotFoundException e) {
        LOGGER.warn("Database Instance with name {} has been removed or is not configured correctly, no retry possible", getDbInstanceIdentifier());
        //Database has been deleted while operating, hence we can not retry
        return false;
    }

    if (describeDBInstancesResult.getDBInstances().size() == 1) {
        DBInstance dbInstance = describeDBInstancesResult.getDBInstances().get(0);
        InstanceStatus instanceStatus = InstanceStatus.fromDatabaseStatus(dbInstance.getDBInstanceStatus());
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Status of database to be retried is {}", instanceStatus);
        }
        return instanceStatus.isRetryable();
    } else {
        throw new IllegalStateException("Multiple databases found for same identifier, this is likely an incompatibility with the Amazon SDK");
    }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Bean
public AmazonRDS amazonRDS() {
    AmazonRDSClient client = Mockito.mock(AmazonRDSClient.class);
    when(client.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier("test"))).thenReturn(
            new DescribeDBInstancesResult().
                    withDBInstances(new DBInstance().
                            withDBInstanceStatus("available").
                            withDBName("test").
                            withDBInstanceIdentifier("test").
                            withEngine("mysql").
                            withMasterUsername("admin").
                            withEndpoint(new Endpoint().
                                    withAddress("localhost").
                                    withPort(3306)
                            ).withReadReplicaDBInstanceIdentifiers("read1")
                    )
    );
    return client;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Test
public void canRetry_retryPossibleDueToAvailableDatabase_returnsTrue() throws Exception {
    //Arrange
    AmazonRDS amazonRDS = mock(AmazonRDS.class);

    DatabaseInstanceStatusRetryPolicy policy = new DatabaseInstanceStatusRetryPolicy(amazonRDS, "test");
    when(amazonRDS.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier("test"))).
            thenReturn(new DescribeDBInstancesResult().withDBInstances(new DBInstance().withDBInstanceStatus("available")));

    RetryContext retryContext = policy.open(new RetryContextSupport(null));

    //Act
    policy.registerThrowable(retryContext, new TransientDataAccessResourceException("not available"));

    //Assert
    assertTrue(policy.canRetry(retryContext));
    policy.close(retryContext);
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Test
public void canRetry_withResourceIdResolver_returnsTrue() throws Exception {
    //Arrange
    AmazonRDS amazonRDS = mock(AmazonRDS.class);
    ResourceIdResolver resourceIdResolver = mock(ResourceIdResolver.class);

    DatabaseInstanceStatusRetryPolicy policy = new DatabaseInstanceStatusRetryPolicy(amazonRDS, "foo");
    when(amazonRDS.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier("test"))).
            thenReturn(new DescribeDBInstancesResult().withDBInstances(new DBInstance().withDBInstanceStatus("available")));

    when(resourceIdResolver.resolveToPhysicalResourceId("foo")).thenReturn("test");

    policy.setResourceIdResolver(resourceIdResolver);


    RetryContext retryContext = policy.open(new RetryContextSupport(null));

    //Act
    policy.registerThrowable(retryContext, new TransientDataAccessResourceException("not available"));

    //Assert
    assertTrue(policy.canRetry(retryContext));
    policy.close(retryContext);
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Test
public void canRetry_multipleDatabasesFoundForInstanceIdentifier_reportsException() throws Exception {
    //Arrange
    this.expectedException.expect(IllegalStateException.class);
    this.expectedException.expectMessage("Multiple databases found for same identifier");

    AmazonRDS amazonRDS = mock(AmazonRDS.class);

    DatabaseInstanceStatusRetryPolicy policy = new DatabaseInstanceStatusRetryPolicy(amazonRDS, "test");

    DescribeDBInstancesResult describeDBInstancesResult = new DescribeDBInstancesResult().withDBInstances(new DBInstance(), new DBInstance());
    when(amazonRDS.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier("test"))).
            thenReturn(describeDBInstancesResult);

    RetryContext retryContext = policy.open(new RetryContextSupport(null));

    //Act
    policy.registerThrowable(retryContext, new TransientDataAccessResourceException("not available"));

    //Assert
    policy.canRetry(retryContext);
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Bean
public AmazonRDSClient amazonRDS() {
    AmazonRDSClient client = Mockito.mock(AmazonRDSClient.class);
    when(client.describeDBInstances(new DescribeDBInstancesRequest().withDBInstanceIdentifier("test"))).thenReturn(
            new DescribeDBInstancesResult().
                    withDBInstances(new DBInstance().
                            withDBInstanceStatus("available").
                            withDBName("test").
                            withDBInstanceIdentifier("test").
                            withEngine("mysql").
                            withMasterUsername("admin").
                            withEndpoint(new Endpoint().
                                    withAddress("localhost").
                                    withPort(3306)
                            ).withReadReplicaDBInstanceIdentifiers("read1")
                    )
    );
    return client;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
public String getDBEndPoint(String dbInstanceId, int timeout){
    DescribeDBInstancesRequest ddbir = new DescribeDBInstancesRequest()
            .withDBInstanceIdentifier(dbInstanceId);
    System.out.println("Waiting for DB endpoints");
    while(timeout -- > 0){
        System.out.print("-");
        DescribeDBInstancesResult ddbi = rdsClient.describeDBInstances(ddbir);
        Endpoint endpoint = ddbi.getDBInstances().get(0).getEndpoint();
        if(endpoint != null && endpoint.toString().length()!=0)
            return endpoint.getAddress()+":"+endpoint.getPort();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            Logger.getLogger(BeanstalkConnector.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    return "";
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
public List<DBInstance> getDBInstancesForVpc(String vpcId) {	
	DescribeDBInstancesResult result = rdsClient.describeDBInstances();
	List<DBInstance> dbInstances = result.getDBInstances();
	
	List<DBInstance> filtered = new LinkedList<DBInstance>(); 
	for(DBInstance dbInstance : dbInstances) {
		DBSubnetGroup dbSubnetGroup = dbInstance.getDBSubnetGroup();
		if (dbSubnetGroup!=null) {
			String groupVpcId = dbSubnetGroup.getVpcId();
			if (groupVpcId.equals(vpcId)) {
				filtered.add(dbInstance);
			}
		}
	}
	return filtered;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
/**
 * @inheritDoc
 */
@Override
public DatabaseInstance describeInstance( String instanceName,
                                          Identity identity )
{
    AmazonRDS rds =
        ActivityUtils.createClient( AmazonRDSClient.class, identity );
    DescribeDBInstancesResult results =
        rds.describeDBInstances( new DescribeDBInstancesRequest().withDBInstanceIdentifier( instanceName ) );
    if ( results.getDBInstances().isEmpty() )
    {
        return null;
    }
    DBInstance result = results.getDBInstances().get( 0 );
    return toDatabaseInstance( result );
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
/**
 * Gets a description of the requested RDS instance.  Throws if not found.
 */
public DBInstance describeInstance(String instanceName)
{
  LOGGER.debug("describeDBInstances(instanceName: " + instanceName + ")");
  StopWatch stopWatch = new StopWatch();
  try
  {
    stopWatch.start();
    DescribeDBInstancesRequest request = new DescribeDBInstancesRequest();
    request.setDBInstanceIdentifier(instanceName);
    DescribeDBInstancesResult result = awsRdsClient.describeDBInstances(request);
    if (result == null || CollectionUtils.isEmpty(result.getDBInstances()))
    {
      // Note: this branch should never execute.  We expect Amazon to throw DBInstanceNotFoundException instead.
      throw new DBSnapshotNotFoundException("RDS cannot find instance '" + instanceName + "'");
    }
    else if (result.getDBInstances().size() > 1)
    {
      LOGGER.warn("Expected 1 instance named '" + instanceName + "', found " + result.getDBInstances().size());
    }
    return result.getDBInstances().get(0);
  }
  finally
  {
    stopWatch.stop();
    LOGGER.debug("describeDBInstances time elapsed: " + stopWatch);
  }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
private static DBInstance getDbInstance(final AmazonRDSClient amazonRds, final String rdsInstanceId) {
    try {
        final DescribeDBInstancesRequest request = new DescribeDBInstancesRequest()
                .withDBInstanceIdentifier(rdsInstanceId);
        final DescribeDBInstancesResult response = amazonRds.describeDBInstances(request);

        return response.getDBInstances().get(0);

    } catch (DBInstanceNotFoundException e) {
        throw new IllegalStateException("Could not find DB instance!");
    }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Override
public Map<String, InstanceState> getInstanceState(
    RDSInstanceTemplate template, Collection<String> virtualInstanceIds) {
  Map<String, InstanceState> instanceStateByVirtualInstanceId =
      Maps.newHashMapWithExpectedSize(virtualInstanceIds.size());

  // RDS does not allow batching of DB instance status requests.
  for (String virtualInstanceId : virtualInstanceIds) {
    InstanceState instanceState;
    try {
      DescribeDBInstancesResult result = client.describeDBInstances(
          new DescribeDBInstancesRequest()
              .withDBInstanceIdentifier(virtualInstanceId));
      LOG.info("<< Result: {}", result);

      // Paging not required, should only ever be one instance returned
      if (result.getDBInstances().size() > 0) {
        DBInstance dbInstance = result.getDBInstances().get(0);
        RDSStatus status = RDSStatus.valueOfRDSString(dbInstance.getDBInstanceStatus());
        instanceState = RDSInstanceState.fromRdsStatus(status);
      } else {
        instanceState = RDSInstanceState.fromRdsStatus(null);
      }
    } catch (DBInstanceNotFoundException e) {
      instanceState = RDSInstanceState.fromRdsStatus(null);
    }
    instanceStateByVirtualInstanceId.put(virtualInstanceId, instanceState);
  }

  return instanceStateByVirtualInstanceId;
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
/**
 * Iterates through the instances identified by the specified virtual instance IDs
 * and calls the specified handler on each instance.
 *
 * @param virtualInstanceIds the virtual instance IDs
 * @param instanceHandler    the instance handler
 */
private void forEachInstance(Collection<String> virtualInstanceIds,
    RDSProvider.InstanceHandler instanceHandler) {
  // TODO RDS does not currently support the withFilters parameter, so we have to load one at a
  // time by id
  //DescribeDBInstancesResult result = client.describeDBInstances(new DescribeDBInstancesRequest()
  //    .withFilters(new Filter().withFilterName("tag:" + Tags.CLOUDERA_DIRECTOR_ID)
  //        .withFilterValue(virtualInstanceIds)));
  for (String virtualInstanceId : virtualInstanceIds) {
    DescribeDBInstancesResult result = client.describeDBInstances(new DescribeDBInstancesRequest()
        .withDBInstanceIdentifier(virtualInstanceId));
    forEachInstance(result, instanceHandler);
  }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Scheduled(fixedRate = 300_000)
public void run() {
    for (final String accountId : allAccountIds.get()) {
        for (final String region : jobsProperties.getWhitelistedRegions()) {
            try {
                final AmazonRDSClient amazonRDSClient = clientProvider.getClient(AmazonRDSClient.class, accountId,
                        Region.getRegion(Regions.fromName(region)));

                Optional<String> marker = Optional.empty();

                do {
                    final DescribeDBInstancesRequest request = new DescribeDBInstancesRequest();
                    marker.ifPresent(request::setMarker);
                    final DescribeDBInstancesResult result = amazonRDSClient.describeDBInstances(request);
                    marker = Optional.ofNullable(trimToNull(result.getMarker()));

                    result.getDBInstances().stream()
                            .filter(DBInstance::getPubliclyAccessible)
                            .filter(dbInstance -> dbInstance.getEndpoint() != null)
                            .forEach(dbInstance -> {
                                final Map<String, Object> metadata = newHashMap();
                                metadata.put("unsecuredDatabase", dbInstance.getEndpoint().getAddress());
                                metadata.put("errorMessages", "Unsecured Database! Your DB can be reached from outside");
                                writeViolation(accountId, region, metadata, dbInstance.getEndpoint().getAddress());

                            });

                } while (marker.isPresent());

            } catch (final Exception e) {
                jobExceptionHandler.onException(e, ImmutableMap.of(
                        "job", this.getClass().getSimpleName(),
                        "aws_account_id", accountId,
                        "aws_region", region));
            }
        }
    }
}
 

import com.amazonaws.services.rds.model.DescribeDBInstancesResult; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    this.clientProviderMock = mock(ClientProvider.class);
    this.jobsPropertiesMock = mock(JobsProperties.class);
    this.violationSinkMock = mock(ViolationSink.class);
    this.amazonRDSClientMock = mock(AmazonRDSClient.class);
    this.accountIdSupplierMock = mock(AccountIdSupplier.class);
    this.exceptionHandlerMock = mock(JobExceptionHandler.class);

    when(accountIdSupplierMock.get()).thenReturn(newHashSet("54321"));

    // Jobsproperties
    when(jobsPropertiesMock.getWhitelistedRegions()).thenReturn(newArrayList("eu-west-1"));

    // Dbinstances
    final Endpoint endpoint = new Endpoint();
    endpoint.setAddress("aws.db.cn");
    final Endpoint endpoint2 = new Endpoint();
    endpoint2.setAddress("aws.db2.cn");
    final DBInstance dbInstance1 = new DBInstance();
    dbInstance1.setPubliclyAccessible(true);
    dbInstance1.setEndpoint(endpoint);
    final DBInstance dbInstance2 = new DBInstance();
    dbInstance2.setPubliclyAccessible(false);
    dbInstance2.setEndpoint(endpoint);
    final DBInstance dbInstance3 = new DBInstance();
    dbInstance3.setPubliclyAccessible(true);
    dbInstance3.setEndpoint(endpoint2);
    describeDBInstancesResultMock = new DescribeDBInstancesResult();
    describeDBInstancesResultMock.setDBInstances(newArrayList(dbInstance1, dbInstance2, dbInstance3));

    // clientprovider
    when(clientProviderMock.getClient(any(), any(String.class), any(Region.class))).thenReturn(amazonRDSClientMock);

}