作为管理员何时以及如何使用它？

今天最常见的用途是创建一个目录,任何人都可以在其中创建文件,但只有该目录中文件的所有者才能删除它.传统上,如果您有一个任何人都可以写入的目录,任何人都可以从中删除文件.在目录上设置粘滞位使得只有文件的所有者才能从世界可写目录中删除该文件.

经典的用法是/ tmp目录：

$ls -ld /tmp
drwxrwxrwt   29 root     root         5120 May 20 09:15 /tmp/

模式中的t是粘性位.如果没有设置,普通用户很容易通过删除/ tmp中的所有内容来造成破坏.由于许多守护进程将套接字放在/ tmp中,因此它本质上是一个本地DOS.

jar -xvf mysite.war -C /usr/local/tomcat/webapps/mysite/

它没有用.这个：

jar -xvf mysite.war /usr/local/tomcat/webapps/mysite/

是不是没有任何错误,但仍然没有任何想法？

如上所述：“… jar没有选项将文件直接提取到另一个文件夹……”所以你需要做的就是更改到你要提取的目录,然后引用jar文件从那里

mkdir newdir
cd newdir
jar -xvf /workspace/test/classes/test.jar

这也可以在Windows上为你做到这一点,因为默认情况下unzip不可用.

我使用的命令是：

jar cvf myWar.war *

文件内容是两个html文件和一个目录“.ebextensions”

难道我做错了什么？看起来这应该比我做的更容易.

谢谢！

jar cvf myWar.war *.[！.] *

使用此命令,还包括所有以点开头但排除的目录/文件.和……

无论你是否了解Phonegap,我的问题是：如果我通过在其中生成前台服务来确定流程的优先级,这是否会影响Activity生命周期？服务(及其进程)是否可能保持活动状态并且主要活动是否已从内存中清除？

如果无法保证活动生命周期受到影响,您能否说一下实践中可能发生的事情？

One solution I’ve thought of is to treat the Phonegap Activity as a sort of pseudo-Service by spawning a “dummy” or empty Service (utilizing startService and startForeground).

如果您可以这样做,您可以在本机Java代码中实现实际服务(而不仅仅是在本机Java代码中编写空服务),您可以避免所有这些废话.

The idea is that the lifecycle of the Phonegap Activity will be tied to the lifecycle of the Service and will thus continue executing Javascript code in the background.

AFAIK,WebView既不知道也不关心流程中是否有服务.当WebView不可见时,无法保证WebView将无限期地继续执行JavaScript.而且,由于您的PhoneGap应用程序几乎只是一个WebView,因此您依赖的是这种未记录的WebView行为.

If I prioritize a process by spawning a foreground service within it,does this affect the Activity lifecycle? Is it possible that the service (and its process) stays alive and that the main Activity is cleared from memory?

欢迎用户按下BACK按钮,销毁您的活动,并且不受您是否开始某项服务的影响.

欢迎用户使用任务管理器(例如,Android 4.0上的最新任务列表)来关闭后台进程,这不受您是否启动某项服务的影响.

欢迎用户通过“设置”强制停止您的应用,以防止您的代码在未经他们许可的情况下再次运行,并且不受您是否启动某项服务的影响.

欢迎操作系统自行终止您的进程 – startForeground()不是终身传递.

总而言之,在后三种情况下,活动和服务将在此过程中同时消失.只有BACK按钮(或您的调用finish()或一些未处理的异常)才会导致活动消失但服务仍然存在.

<asp:Label ID="lblPrinter" runat="server"  Text='<%# iif(eval("misc_text_2") is dbnull.value,"",iif(eval("misc_text_2") like "NA","None",iif(eval("misc_text_2") like "KP1","Kitchen Printer 1",iif(eval("misc_text_2") like "KP2","Kitchen Printer 2",iif(eval("misc_text_2") like "KP3","Kitchen Printer 3",iif(eval("misc_text_2") like "BP1","Bar Printer 1",iif(eval("misc_text_2") like "BP2","Bar Printer 2",iif(eval("misc_text_2") like "BP3","Bar Printer 3",Eval("misc_text_2")))))))))%>'></asp:Label>

我一直在收到错误异常详细信息：system.invalidCastException：从类型’dbnull’到类型’String’的转换无效.

我知道我错过了什么,但是……

提前致谢

我和我的键盘一起玩

将被转换为：

我用我的键盘大喊大叫

编辑：我意识到我在我的问题中不够清楚,文本输入大写,而不是最初的小写,文本转换：大写不适用于像这样输入的数据.

.Capitalize
{ text-transform: capitalize }

.Uppercase
{ text-transform: uppercase }

.Lowercase
{ text-transform: lowercase }

.nothing
{ text-transform: none }

不幸的是,没有Camel Case文本转换.

您可以始终使用Javascript来适当地转换文本,或者如果您使用的是脚本语言(如PHP或ASP),则可以在其中进行更改.

以下是从strtoupper PHP文档页面获取的示例：

function strtocamel($str,$capitalizefirst = true,$allowed = 'A-Za-z0-9') {
    return preg_replace(
        array(
            '/([A-Z][a-z])/e',// all occurances of caps followed by lowers
            '/([a-zA-Z])([a-zA-Z]*)/e',// all occurances of words w/ first char captured separately
            '/[^'.$allowed.']+/e',// all non allowed chars (non alpha numerics,by default)
            '/^([a-zA-Z])/e' // first alpha char
        ),array(
            '" ".$1',// add spaces
            'strtoupper("$1").strtolower("$2")',// capitalize first,lower the rest
            '',// delete undesired chars
            'strto'.($capitalizefirst ? 'upper' : 'lower').'("$1")' // force first char to upper or lower
        ),$str
    );
}

arrayofstring : array of string;
ArrayOfInteger: array of integer;
arrayofstringArrays : array of arrayofstring;

这种代码在很多地方重复,并且每次都为它们中的每一个重复“SetLength”,我想知道是否将所有这些东西的数组改为TList< Something>现在我们在Delphi XE4.

这样做有什么好处,资源,速度或类似的东西来支持我做出这个决定？

PS：我来自JAVA和Delphi给我感到黑暗和充满恐惧

动态数组通过指针提供对元素的直接访问.该语言隐藏了指针,但这基本上都是动态数组.但是你负责任何重新分配,如果你想插入或删除项目,那么你必须编写代码,并处理细节.

更高级别的集合类TStringList和TList< T>建立在动态数组之上.这是内部如何存储内容.但是集合类为你包装了这个.作为方法提供了诸如插入和删除等更高级别的操作.实质上,这些集合类比原始动态数组提供了更多的便利.

为了说明,请考虑插入项目的行为.对于动态数组,您可以这样做：

>调整阵列大小.
>将插入点之后的项目从位置i移动到i 1.
>分配插入的项目.

如果您不止一次需要编写此代码,那么,您做错了.

对于您写的高级集合：

List.Insert(Index,Value);

让班级来处理细节.

请注意,由于历史原因,并且因为字符串特别重要,开发人员倾向于使用定制的专用TStringList类而不是TList< string>.专用类再次提供TList< string>之外的功能.因为它专门研究字符串,并且可以提供定制到字符串的功能.同样,专用课程提供了便利.

动态阵列派上用场的一个地方就是当你不想招致终身管理的样板时.因此,对于没有针对类的ARC的桌面编译器,您需要明确地销毁TList< T>.实例.但动态阵列的生命周期由ARC管理.如果您一次性合成数组,然后不调整它们的大小,那么生命周期管理问题可以使数组更方便使用.

根据经验,喜欢高级集合类.它们应该是您的默认选择.有时动态数组是正确的选择,但这往往适用于更专业的场景.

private AmazonIdentityManagement client() {
    return AmazonIdentityManagementClientBuilder.standard()
            .withCredentials(new AWsstaticCredentialsProvider(new AWSCredentials() {
                @Override
                public String getAWSAccessKeyId() {
                    return bookmark.getCredentials().getUsername();
                }

                @Override
                public String getAWSSecretKey() {
                    return bookmark.getCredentials().getpassword();
                }
            }))
            .withClientConfiguration(configuration)
            .withRegion(Regions.DEFAULT_REGION).build();
}

void addRolesToIdentityPool(String unauthenticatedRoleName,String unauthenticatedRole,String authenticatedRoleName,String authenticatedRole,String identityPoolId,AmazonCognitoIdentity client,LambdaLogger logger) {
  // First update the roles to use the actual pool id in their conditions
  logger
      .log("Updating authenticated and unauthenticated roles to use the actual identity pool id: "
          + identityPoolId);
  AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard().build();
  UpdateAssumeRolePolicyRequest updateAssumeRolePolicyRequest = new UpdateAssumeRolePolicyRequest();
  updateAssumeRolePolicyRequest.setRoleName(unauthenticatedRoleName);
  updateAssumeRolePolicyRequest.setPolicyDocument(getAssumeRolePolicyDocument(false,identityPoolId,logger));
  iamClient.updateAssumeRolePolicy(updateAssumeRolePolicyRequest);
  updateAssumeRolePolicyRequest.setRoleName(authenticatedRoleName);
  updateAssumeRolePolicyRequest.setPolicyDocument(getAssumeRolePolicyDocument(true,logger));
  iamClient.updateAssumeRolePolicy(updateAssumeRolePolicyRequest);

  // And add the updated roles to the pool
  logger.log("Adding updated authenticated and unauthenticated roles to the identity pool");
  SetIdentityPoolRolesRequest setIdentityPoolRolesRequest = new SetIdentityPoolRolesRequest();
  setIdentityPoolRolesRequest.addRolesEntry("authenticated",authenticatedRole);
  setIdentityPoolRolesRequest.addRolesEntry("unauthenticated",unauthenticatedRole);
  setIdentityPoolRolesRequest.setIdentityPoolId(identityPoolId);
  client.setIdentityPoolRoles(setIdentityPoolRolesRequest);
}

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username\n" +
            "Ex: createuser <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        createuserRequest request = new createuserRequest()
            .withUserName(username);

        createuserResult response = iam.createuser(request);

        System.out.println("Successfully created user: " +
                response.getUser().getUserName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a certificate name\n" +
            "Ex: GetServerCertificate <certificate-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cert_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetServerCertificateRequest request = new GetServerCertificateRequest()
                    .withServerCertificateName(cert_name);

        GetServerCertificateResult response = iam.getServerCertificate(request);

        System.out.format("Successfully retrieved certificate with body %s",response.getServerCertificate().getCertificateBody());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a policy arn\n" +
            "Ex: GetPolicy <policy-arn>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String policy_arn = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetPolicyRequest request = new GetPolicyRequest()
            .withPolicyArn(policy_arn);

        GetPolicyResult response = iam.getPolicy(request);

        System.out.format("Successfully retrieved policy %s",response.getPolicy().getPolicyName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a certificate name\n" +
            "Ex: DeleteServerCertificate <certificate-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cert_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteServerCertificateRequest request =
            new DeleteServerCertificateRequest()
                .withServerCertificateName(cert_name);

        DeleteServerCertificateResult response =
            iam.deleteServerCertificate(request);

        System.out.println("Successfully deleted server certificate " +
                cert_name);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a role name and policy arn\n" +
            "Ex: DetachRolePolicy <role-name> <policy-arn>>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String role_name = args[0];
        String policy_arn = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DetachRolePolicyRequest request = new DetachRolePolicyRequest()
            .withRoleName(role_name)
            .withPolicyArn(policy_arn);

        DetachRolePolicyResult response = iam.detachRolePolicy(request);

        System.out.println("Successfully detached policy " + policy_arn +
                " from role " + role_name);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an account alias\n" +
            "Ex: DeleteAccountAlias <account-alias>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String alias = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
            .withAccountAlias(alias);

        DeleteAccountAliasResult response = iam.deleteAccountAlias(request);

        System.out.println("Successfully deleted account alias " + alias);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListUsersRequest request = new ListUsersRequest();

        while(!done) {
            ListUsersResult response = iam.listUsers(request);

            for(User user : response.getUsers()) {
                System.out.format("Retrieved user %s",user.getUserName());
            }

            request.setMarker(response.getMarker());

            if(!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an IAM user\n" +
            "Ex: CreateAccessKey <user>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String user = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreateAccessKeyRequest request = new CreateAccessKeyRequest()
            .withUserName(user);

        CreateAccessKeyResult response = iam.createAccessKey(request);

        System.out.println("Created access key: " + response.getAccessKey());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an access key id\n" +
            "Ex: AccessKeyLastUsed <access-key-id>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String access_id = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetAccessKeyLastUsedRequest request = new GetAccessKeyLastUsedRequest()
            .withAccessKeyId(access_id);

        GetAccessKeyLastUsedResult response = iam.getAccessKeyLastUsed(request);

        System.out.println("Access key was last used at: " +
                response.getAccessKeyLastUsed().getLastUsedDate());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a policy name\n" +
            "Ex: CreatePolicy <policy-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String policy_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreatePolicyRequest request = new CreatePolicyRequest()
            .withPolicyName(policy_name)
            .withPolicyDocument(POLICY_DOCUMENT);

        CreatePolicyResult response = iam.createPolicy(request);

        System.out.println("Successfully created policy: " +
                response.getPolicy().getPolicyName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username and access key id\n" +
            "Ex: DeleteAccessKey <username> <access-key-id>\n";

        if (args.length != 2) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];
        String access_key = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
            .withAccessKeyId(access_key)
            .withUserName(username);

        DeleteAccessKeyResult response = iam.deleteAccessKey(request);

        System.out.println("Successfully deleted access key " + access_key +
                " from user " + username);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an alias\n" +
            "Ex: CreateAccountAlias <alias>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String alias = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreateAccountAliasRequest request = new CreateAccountAliasRequest()
            .withAccountAlias(alias);

        CreateAccountAliasResult response = iam.createAccountAlias(request);

        System.out.println("Successfully created account alias: " + alias);
    }

@Override
public void execute() throws MojoExecutionException,MojoFailureException {
    Proxy proxy = new Proxy(httpsProxyHost,httpsProxyPort,httpsProxyUsername,httpsProxyPassword);
    AwsKeyPair keyPair = Util.getAwsKeyPair(serverId,awsAccessKey,awsSecretAccessKey,settings,decrypter);
    final AWSCredentialsProvider credentials = new AWsstaticCredentialsProvider(
            new BasicAWSCredentials(keyPair.key,keyPair.secret));
    ClientConfiguration cc = Util.createConfiguration(proxy);

    AmazonIdentityManagement iam = AmazonIdentityManagementClientBuilder //
            .standard() //
            .withRegion(region) //
            .withCredentials(credentials) //
            .withClientConfiguration(cc) //
            .build();
    String accountId = iam.getUser().getUser().getUserId();
    project.getProperties().setProperty("aws.account.id",accountId);
    getLog().info("The following properties have been set for the project");
    getLog().info("aws.account.id=" + accountId);
}

public static PrincipalAutoSuggestion fromCredentials(AWSCredentialsProvider awsCredentials,ClientConfiguration clientConfiguration) {

        AmazonIdentityManagement client = AmazonIdentityManagementClientBuilder.standard()
                .withCredentials(awsCredentials)
                .withClientConfiguration(transformAndVerifyOrThrow(clientConfiguration))
                .withRegion(RegionResolver.getRegion())
                .build();

        return new PrincipalAutoSuggestion(client);
    }

public static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials,ClientConfiguration clientConfiguration) {
    AmazonIdentityManagement client = AmazonIdentityManagementClientBuilder.standard()
        .withCredentials(awsCredentials)
        .withClientConfiguration(transformAndVerifyOrThrow(clientConfiguration))
        .withRegion(RegionResolver.getRegion())
        .build();
    return new IAMPolicyManager(client,awsCredentials,clientConfiguration);
}

private static void cleanUpIAM(Regions testRegion,String testResourcePrefix,Date createdBeforeThreshold,AWSCredentialsProvider awsCredentials) {
    AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard()
        .withCredentials(awsCredentials)
        .withRegion(testRegion)
        .build();
    IAMPolicyManager iamPolicyManager = IAMPolicyManager.fromCredentials(awsCredentials,new ClientConfiguration());

    LOG.info("Cleaning IAM policies...");
    ListPoliciesRequest listPoliciesRequest = new ListPoliciesRequest().withPathPrefix(IAMPolicyManager.PATH_PREFIX);
    List<Policy> policies = iamClient.listPolicies(listPoliciesRequest).getPolicies();
    for (Policy policy: policies) {
        if (policy.getPolicyName().startsWith(testResourcePrefix) &&
                policy.getCreateDate().before(createdBeforeThreshold)) {
            LOG.info("Cleaning up policy: " + policy.getPolicyName());

            IAMPolicyName iamPolicyName = IAMPolicyName.fromString(policy.getPolicyName());
            iamPolicyManager.detachAllPrincipals(iamPolicyName.group);

            DeletePolicyRequest deletePolicyRequest = new DeletePolicyRequest().withPolicyArn(policy.getArn());
            iamClient.deletePolicy(deletePolicyRequest);
        }
    }

    LOG.info("Cleaning IAM roles created for the assume role tests...");
    ListRolesRequest listRolesRequest = new ListRolesRequest().withPathPrefix(IAMHelper.PATH);
    List<Role> roles = iamClient.listRoles(listRolesRequest).getRoles();
    for (Role role: roles) {
        if (role.getRoleName().startsWith(AssumedRoleTestContext.ROLE_PREFIX) &&
                role.getCreateDate().before(createdBeforeThreshold)) {
            LOG.info("Cleaning up role: " + role.getRoleName());
            DeleteRoleRequest deleteRoleRequest = new DeleteRoleRequest().withRoleName(role.getRoleName());
            iamClient.deleteRole(deleteRoleRequest);
        }
    }

}

/**
 * Method gets the aws accountId from the specified credentials.
 *
 * @param privateKeyId
 * @param privateKey
 * @return account ID
 */
private String getAccountId(String privateKeyId,String privateKey) {
    AWSCredentials awsCredentials = new BasicAWSCredentials(privateKeyId,privateKey);

    AWsstaticCredentialsProvider awsstaticCredentialsProvider = new AWsstaticCredentialsProvider(
            awsCredentials);

    AmazonIdentityManagementClientBuilder amazonIdentityManagementClientBuilder = AmazonIdentityManagementClientBuilder
            .standard()
            .withCredentials(awsstaticCredentialsProvider)
            .withRegion(Regions.DEFAULT_REGION);

    AmazonIdentityManagementClient iamClient = (AmazonIdentityManagementClient) amazonIdentityManagementClientBuilder
            .build();

    String userId = null;
    try {
        if ((iamClient.getUser() != null) && (iamClient.getUser().getUser() != null)
                && (iamClient.getUser().getUser().getArn() != null)) {

            String arn = iamClient.getUser().getUser().getArn();
            /*
             * arn:aws:service:region:account:resource -> so limiting the split to 6 words and
             * extracting the accountId which is 5th one in list. If the user is not authorized
             * to perform iam:GetUser on that resource,still error mesage will have accountId
             */
            userId = arn.split(":",6)[4];
        }
    } catch (AmazonServiceException ex) {
        if (ex.getErrorCode().compareto("AccessDenied") == 0) {
            String msg = ex.getMessage();
            userId = msg.split(":",7)[5];
        } else {
            logSevere("Exception getting the accountId %s",ex);

        }
    }
    return userId;
}

public AAWStest() {
    super();
    if (Config.has(Config.Key.IAM_ROLE_ARN)) {
        final AWSSecurityTokenService sts = AWSSecurityTokenServiceClientBuilder.standard().withCredentials(new DefaultAWSCredentialsProviderChain()).build();
        this.credentialsProvider = new STSAssumeRoleSessionCredentialsProvider.Builder(Config.get(Config.Key.IAM_ROLE_ARN),IAM_SESSION_NAME).withStsClient(sts).build();
    } else {
        this.credentialsProvider = new DefaultAWSCredentialsProviderChain();
    }
    this.ec2 = AmazonEC2ClientBuilder.standard().withCredentials(this.credentialsProvider).build();
    this.iam = AmazonIdentityManagementClientBuilder.standard().withCredentials(this.credentialsProvider).build();
}

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an IAM  username\n" +
            "Ex: ListAccessKeys <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListAccessKeysRequest request = new ListAccessKeysRequest()
                .withUserName(username);

        while (!done) {

            ListAccessKeysResult response = iam.listAccessKeys(request);

            for (AccessKeyMetadata Metadata :
                    response.getAccessKeyMetadata()) {
                System.out.format("Retrieved access key %s",Metadata.getAccessKeyId());
            }

            request.setMarker(response.getMarker());

            if (!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username,access key id and status\n" +
            "Ex: UpdateAccessKey <username> <access-key-id> <Activate|Inactive>\n";

        if (args.length != 3) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];
        String access_id = args[1];
        String status = args[2];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
            .withAccessKeyId(access_id)
            .withUserName(username)
            .withStatus(status);

        UpdateAccessKeyResult response = iam.updateAccessKey(request);

        System.out.printf(
                "Successfully updated status of access key %s to" +
                "status %s for user %s",access_id,status,username);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply the current certificate name and\n" +
            "a new name. Ex:\n\n" +
            "UpdateServerCertificate <current-name> <new-name>\n";

        if (args.length != 2) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cur_name = args[0];
        String new_name = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateServerCertificateRequest request =
            new UpdateServerCertificateRequest()
                .withServerCertificateName(cur_name)
                .withNewServerCertificateName(new_name);

        UpdateServerCertificateResult response =
            iam.updateServerCertificate(request);

        System.out.printf("Successfully updated server certificate to name %s",new_name);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListServerCertificatesRequest request =
                new ListServerCertificatesRequest();

        while(!done) {

            ListServerCertificatesResult response =
                iam.listServerCertificates(request);

            for(ServerCertificateMetadata Metadata :
                    response.getServerCertificateMetadataList()) {
                System.out.printf("Retrieved server certificate %s",Metadata.getServerCertificateName());
            }

            request.setMarker(response.getMarker());

            if(!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply the current username and a new\n" +
            "username. Ex:\n\n" +
            "UpdateUser <current-name> <new-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cur_name = args[0];
        String new_name = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateUserRequest request = new UpdateUserRequest()
            .withUserName(cur_name)
            .withNewUserName(new_name);

        UpdateUserResult response = iam.updateUser(request);

        System.out.printf("Successfully updated user to username %s",new_name);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        ListAccountAliasesResult response = iam.listAccountAliases();

        for (String alias : response.getAccountAliases()) {
            System.out.printf("Retrieved account alias %s",alias);
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username\n" +
            "Ex: DeleteUser <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteUserRequest request = new DeleteUserRequest()
            .withUserName(username);

        try {
            iam.deleteUser(request);
        } catch (DeleteConflictException e) {
            System.out.println("Unable to delete user. Verify user is not" +
                    " associated with any resources");
            throw e;
        }

        System.out.println("Successfully deleted IAM user " + username);
    }

private void createAmazonapiclients() {
       cfnClient = AmazonCloudFormationClientBuilder.defaultClient();
       ec2Client = AmazonEC2ClientBuilder.defaultClient();
       snsClient = AmazonSNSClientBuilder.defaultClient();
       sqsClient = AmazonSQSClientBuilder.defaultClient();
       elbClient = AmazonElasticLoadBalancingClientBuilder.defaultClient();
       s3Client = AmazonS3ClientBuilder.defaultClient();
       rdsClient = AmazonRDSClientBuilder.defaultClient();
       iamClient = AmazonIdentityManagementClientBuilder.defaultClient();
}

IAMHelper(AWSCredentialsProvider awsCredentials,Region testRegion) {
    this.client = AmazonIdentityManagementClientBuilder.standard()
            .withCredentials(awsCredentials)
            .withRegion(testRegion.getName())
            .build();
}

public static void main(String[] args) {
    final String USAGE =
        "To run this example,supply a role name\n" +
        "Ex: AttachRolePolicy <role-name>\n";

    if (args.length != 1) {
        System.out.println(USAGE);
        System.exit(1);
    }

    String role_name = args[0];

    final AmazonIdentityManagement iam =
        AmazonIdentityManagementClientBuilder.defaultClient();

    ListAttachedRolePoliciesRequest request =
        new ListAttachedRolePoliciesRequest()
            .withRoleName(role_name);

    List<AttachedPolicy> matching_policies = new ArrayList<>();

    boolean done = false;

    while(!done) {
        ListAttachedRolePoliciesResult response =
            iam.listAttachedRolePolicies(request);

        matching_policies.addAll(
                response.getAttachedPolicies()
                        .stream()
                        .filter(p -> p.getPolicyName().equals(role_name))
                        .collect(Collectors.toList()));

        if(!response.getIsTruncated()) {
            done = true;
        }
        request.setMarker(response.getMarker());
    }

    if (matching_policies.size() > 0) {
        System.out.println(role_name +
                " policy is already attached to this role.");
        return;
    }

    AttachRolePolicyRequest attach_request =
        new AttachRolePolicyRequest()
            .withRoleName(role_name)
            .withPolicyArn(POLICY_ARN);

    iam.attachRolePolicy(attach_request);

    System.out.println("Successfully attached policy " + POLICY_ARN +
            " to role " + role_name);
}

public IAM(AWSCredentialsProvider credentials,Regions region) {
    iam = AmazonIdentityManagementClientBuilder.standard().withRegion(region).withCredentials(credentials).build();
    this.region = Region.getRegion(region);
}

public static AmazonIdentityManagement createIamClient(DefaultAWSCredentialsProviderChain credentialsProvider) {
    return AmazonIdentityManagementClientBuilder.defaultClient();
}

/**
 * Validates the configured IAM profile.
 *
 * @param configuration       the configuration to be validated
 * @param accumulator         the exception condition accumulator
 * @param localizationContext the localization context
 */
@VisibleForTesting
void checkIamProfileName(Configured configuration,PluginExceptionConditionAccumulator accumulator,LocalizationContext localizationContext) {

  String iamProfileName =
      configuration.getConfigurationValue(IAM_PROFILE_NAME,localizationContext);

  if (iamProfileName != null) {
    AmazonIdentityManagementClient iamClient = provider.getIdentityManagementClient();

    try {
      iamClient.getInstanceProfile(new GetInstanceProfileRequest()
          .withInstanceProfileName(iamProfileName));

    } catch (NoSuchEntityException e) {
      addError(accumulator,IAM_PROFILE_NAME,localizationContext,null,INVALID_IAM_PROFILE_NAME_MSG,iamProfileName);
    }
  }
}

GetCredentialReportResult getCredentialReportCSV(final String accountId) {
    final AmazonIdentityManagementClient client = getIAMClient(accountId);

    GenerateCredentialReportResult generationReport;
    int i = 0;
    do {
        Assert.state(i < MAX_RETRIES,"Maximum retries to generate credentials report exceeded");
        log.debug("Poll credentials report for account {}",accountId);
        try {
            MILLISECONDS.sleep(RETRY_TIMEOUT_MILLIS * i);
        } catch (final InterruptedException e) {
            throw new RuntimeException("Could not pull credentials report",e);
        }
        generationReport = client.generateCredentialReport();
        i++;

    } while (!COMPLETE.toString().equals(generationReport.getState()));

    return client.getCredentialReport();
}

@Before
public void setUp() throws Exception {
    this.violationSinkMock = mock(ViolationSink.class);
    this.clientProviderMock = mock(ClientProvider.class);
    this.accountIdsupplierMock = mock(AccountIdsupplier.class);
    this.jobsPropertiesMock = mock(JobsProperties.class);
    this.mockAmazonIdentityManagementClient = mock(AmazonIdentityManagementClient.class);
    this.mockAwsApplications = mock(AwsApplications.class);

    mockListRolesResult = new ListRolesResult();
    mockListRolesResult.setRoles(asList(
            createRole("aws-service-role",AWS_SERVICE_POLICY_DOCUMENT),createRole("cross-account-role",CROSS_ACCOUNT_POLICY_DOCUMENT),createRole("same-account-role",SAME_ACCOUNT_POLICY_DOCUMENT),createRole("deleted-role-reference-role",DELETED_ROLE_POLICY_DOCUMENT),createRole("management-account-role",MANAGEMENT_POLICY_DOCUMENT)));

    when(clientProviderMock.getClient(any(),any(String.class),any(Region.class))).thenReturn(mockAmazonIdentityManagementClient);
}

/**
 * Sets the "instanceProfile" and "serviceRole" properties according to the
 * set parameters.
 */
public void execute() {
    checkParams();
    AmazonIdentityManagementClient iamClient = getorCreateClient(AmazonIdentityManagementClient.class);
    getProject()
            .setProperty(
                    "instanceProfileArn",iamClient
                            .getInstanceProfile(
                                    new GetInstanceProfileRequest()
                                            .withInstanceProfileName(instanceProfile))
                            .getInstanceProfile().getArn());
    getProject()
            .setProperty(
                    "serviceRoleArn",iamClient
                            .getRole(
                                    new GetRoleRequest()
                                            .withRoleName(serviceRole))
                            .getRole().getArn());

}

public static void main(String... args) throws IOException {
    AWSCredentialsProvider credentials = CredentialsUtils.getAwsCredentials();

    AmazonS3 storage = new AmazonS3Client(credentials);
    storage.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonSQS queue = new AmazonSQSClient(credentials);
    queue.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonEC2 machines = new AmazonEC2Client(credentials);
    machines.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonIdentityManagement identityManagement = new AmazonIdentityManagementClient(credentials);
    identityManagement.setRegion(Region.getRegion(Regions.EU_WEST_1));

    if ("launch".equals(args[0])) {
        setup(storage,queue,machines,identityManagement);

        manageAnswers(queue);
    } else if ("run".equals(args[0])) {
        run(storage,queue);
    } else {
        System.out.println("Huh hoh! Don't kNow what you intended to do...");
    }
}

private static String getAWSAccountID() {
    try {
        String accessKey = AWS_ACCESS_KEY_ID;
        String secretKey = AWS_SECRET_KEY;

        if (Utilities.isEmpty(accessKey) || Utilities.isEmpty(secretKey)) {
            return null;
        }

        AWSCredentials creds = new BasicAWSCredentials(accessKey,secretKey);
        AmazonIdentityManagementClient iam = new AmazonIdentityManagementClient(creds);
        return iam.getUser().getUser().getArn().split(":")[4];
    } catch (AmazonClientException e) {
        throw new RuntimeException("Failed to get AWS account id",e);
    }
}

@BeforeMethod
public void setUp() {
    mockCredentials = mock(AWSCredentialsProvider.class);
    mockClient = mock(AmazonIdentityManagementClient.class);
    ClientConfiguration mockConfig = mock(ClientConfiguration.class);
    IAMPolicyManager policyManager = new IAMPolicyManager(mockClient,mockCredentials,mockConfig);

    // The mockito spy acts like original object but mocks out the getAccount() method. As the getAccount() calls
    // directly rather than via a client that we can pass in we need to mock this out using a spy.
    partiallyMockedPolicyManager = spy(policyManager);
    doReturn(ACCOUNT).when(partiallyMockedPolicyManager).getAccount();

    // Set up KMSEncryptor for testing the policy creation methods. This gets a bit complicated but we need to
    // mock all the AWS dependencies from the KMSManager before using it to create the KMSEncryptor. The getAliasArn
    // needs to be mocked out with a spy to stop the call to getAccount.
    mockKMSClient = mock(AWSKMSClient.class);
    KMSManager kmsManager = new KMSManager(mockKMSClient,mockConfig,group);
    KMSManager partiallyMockedKMSManager = spy(kmsManager);
    doReturn(KMS_ALIAS_ARN).when(partiallyMockedKMSManager).getAliasArn();
    kmsEncryptor = new KMSEncryptor(partiallyMockedKMSManager,group,mock(AwsCrypto.class),EncryptionStrength.AES_256);

    // Set up store for testing the policy creation methods. Mock out the getArn method with a spy to stop the
    // call to getAccount().
    mockDynamoDBClient = mock(AmazonDynamoDBClient.class);
    DynamoDB store = new DynamoDB(mockDynamoDBClient,new reentrantreadwritelock());
    partiallyMockedStore = spy(store);
    doReturn(DYNAMODB_ARN).when(partiallyMockedStore).getArn();
}

/**
 * Method gets the aws accountId from the specified credentials.
 *
 * @param privateKeyId
 * @param privateKey
 * @return account ID
 */
private String getAccountId(String privateKeyId,String privateKey) {
    AWSCredentials awsCredentials = new BasicAWSCredentials(privateKeyId,privateKey);

    AWsstaticCredentialsProvider awsstaticCredentialsProvider = new AWsstaticCredentialsProvider(
            awsCredentials);

    AmazonIdentityManagementClientBuilder amazonIdentityManagementClientBuilder = AmazonIdentityManagementClientBuilder
            .standard()
            .withCredentials(awsstaticCredentialsProvider)
            .withRegion(Regions.DEFAULT_REGION);

    AmazonIdentityManagementClient iamClient = (AmazonIdentityManagementClient) amazonIdentityManagementClientBuilder
            .build();

    String userId = null;
    try {
        if ((iamClient.getUser() != null) && (iamClient.getUser().getUser() != null)
                && (iamClient.getUser().getUser().getArn() != null)) {

            String arn = iamClient.getUser().getUser().getArn();
            /*
             * arn:aws:service:region:account:resource -> so limiting the split to 6 words and
             * extracting the accountId which is 5th one in list. If the user is not authorized
             * to perform iam:GetUser on that resource,still error mesage will have accountId
             */
            userId = arn.split(":",6)[4];
        }
    } catch (AmazonServiceException ex) {
        if (ex.getErrorCode().compareto("AccessDenied") == 0) {
            String msg = ex.getMessage();
            userId = msg.split(":",7)[5];
        } else {
            logSevere("Exception getting the accountId %s",ex);

        }
    }
    return userId;
}

/**
 * Binds all the Amazon services used.
 */
@Override
protected void configure() {
    final Region region = Region.getRegion(Regions.fromName(regionName));
    bind(AmazonEC2.class).toInstance(createAmazonClientInstance(AmazonEC2Client.class,region));
    bind(AmazonCloudFormation.class).toInstance(createAmazonClientInstance(AmazonCloudFormationClient.class,region));
    bind(AmazonIdentityManagement.class).toInstance(createAmazonClientInstance(AmazonIdentityManagementClient.class,region));
    bind(AWSKMS.class).toInstance(createAmazonClientInstance(AWSKMSClient.class,region));
    bind(AmazonS3.class).toInstance(createAmazonClientInstance(AmazonS3Client.class,region));
    bind(AmazonAutoScaling.class).toInstance(createAmazonClientInstance(AmazonAutoScalingClient.class,region));
    bind(AWSSecurityTokenService.class).toInstance(createAmazonClientInstance(AWSSecurityTokenServiceClient.class,region));
    bind(AWSLambda.class).toInstance(createAmazonClientInstance(AWSLambdaClient.class,region));
    bind(AmazonSNS.class).toInstance(createAmazonClientInstance(AmazonSNSClient.class,region));
}

@Override
public RolePolicies getRolePolicies(String roleName,Region region,String accountId) {
    final AmazonIdentityManagementClient iamClient = clientProvider
            .getClient(AmazonIdentityManagementClient.class,accountId,region);
    final Set<String> attachedPolicyNames = fetchAttachedPolicyNames(roleName,iamClient);
    final Set<String> inlinePolicyNames = fetchInlinePolicyNames(roleName,iamClient);
    // assuming that there is an inline policy with the same name as the role itself
    final String mainPolicy = inlinePolicyNames.contains(roleName) ? fetchMainPolicy(roleName,iamClient) : EMPTY_JSON;

    return new RolePolicies(attachedPolicyNames,inlinePolicyNames,mainPolicy);
}

private String fetchMainPolicy(String roleName,AmazonIdentityManagementClient iamClient) {
    return Optional.of(new GetRolePolicyRequest().withRoleName(roleName).withPolicyName(roleName))
            .map(iamClient::getRolePolicy)
            .map(GetRolePolicyResult::getPolicyDocument)
            .map(PolicyProviderImpl::urlDecode)
            .orElse(EMPTY_JSON);
}

private Set<String> fetchInlinePolicyNames(String roleName,AmazonIdentityManagementClient iamClient) {
    return Optional.of(new ListRolePoliciesRequest().withRoleName(roleName))
            .map(iamClient::listRolePolicies)
            .map(ListRolePoliciesResult::getPolicyNames)
            .map(nameList -> nameList.stream().collect(toSet()))
            .orElseGet(Collections::emptySet);
}

private Set<String> fetchAttachedPolicyNames(String roleName,AmazonIdentityManagementClient iamClient) {
    return Optional.of(new ListAttachedRolePoliciesRequest().withRoleName(roleName))
            .map(iamClient::listAttachedRolePolicies)
            .map(ListAttachedRolePoliciesResult::getAttachedPolicies)
            .map(attachedPolicies -> attachedPolicies.stream().map(AttachedPolicy::getPolicyName).collect(toSet()))
            .orElseGet(Collections::emptySet);
}

/**
 * Read AWS account ID
 */
public void retrieveAccountIdFromAwsAPI() {
    String accountId = "";

    try {
        AmazonIdentityManagementClient iamClient = new AmazonIdentityManagementClient(getCredentials());
        LOG.info("Current AWS user: " + iamClient.getUser().getUser().getUserId());
        accountId = iamClient.getUser().getUser().getArn();
    } catch (AmazonServiceException e) {
        if (e.getErrorCode().compareto("AccessDenied") == 0) {
            String arn = null;
            String msg = e.getMessage();
            // User:
            // arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob
            // is not authorized to perform: iam:GetUser on
            // resource:
            // arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob
            // arn:aws:sts::123456789012:assumed-role/Shibboleth-PowerUser/username
            int arnIdx = msg.indexOf("arn:aws");
            if (arnIdx != -1) {
                int arnSpace = msg.indexOf(" ",arnIdx);
                arn = msg.substring(arnIdx,arnSpace);

                // Remove "arn:aws:sts::"
                arn = arn.substring(13,13 + 12);
            }
            accountId = arn;
        }

        if ((accountId == null) || (accountId.length() == 0)) {
            LOG.warn("Cannot lookup account id: " + e.getMessage());
        }
    } catch (Exception ex) {
        LOG.error("Cannot lookup account id: " + ex.getMessage());
    }

    setAccountId(accountId);
}

/**
 * Via the default provider chain (i.e.,global keys for this Jenkins instance),return the account ID for the
 * currently authenticated user.
 * @param proxyHost hostname of the proxy to use (if any)
 * @param proxyPort port of the proxy to use (if any)
 * @return 12-digit account id
 */
public static String getAccountId(String proxyHost,int proxyPort) {

    String arn = "";
    try {
        ClientConfiguration clientCfg = new ClientConfiguration();
        if (proxyHost != null && proxyPort > 0 ) {
            clientCfg.setProxyHost(proxyHost);
            clientCfg.setProxyPort(proxyPort);
        }
        AmazonIdentityManagementClient iam = new AmazonIdentityManagementClient(clientCfg);
        GetUserResult user = iam.getUser();
        arn = user.getUser().getArn();
    } catch (AmazonServiceException e) {
        if (e.getErrorCode().compareto("AccessDenied") == 0) {
            String msg = e.getMessage();
            int arnIdx = msg.indexOf("arn:aws");
            if (arnIdx != -1) {
                int arnSpace = msg.indexOf(" ",arnSpace);
            }
        }
    }

    String accountId = arn.split(":")[ARN_ACCOUNT_ID_INDEX];
    return accountId;
}

public void execute() {
    AmazonIdentityManagementClient iamClient = getorCreateClient(AmazonIdentityManagementClient.class);
    iamClient.createInstanceProfile(new CreateInstanceProfileRequest()
            .withInstanceProfileName(instanceProfile));
    iamClient
            .addRoletoInstanceProfile(new AddRoletoInstanceProfileRequest()
                    .withRoleName(INSTANCEPROFILE_ROLE)
                    .withInstanceProfileName(instanceProfile));
}

public void execute() {
    AmazonIdentityManagementClient iamClient = getorCreateClient(AmazonIdentityManagementClient.class);
    iamClient
            .removeRoleFromInstanceProfile(new RemoveRoleFromInstanceProfileRequest()
                    .withRoleName(INSTANCEPROFILE_ROLE)
                    .withInstanceProfileName(instanceProfile));
    iamClient.deleteInstanceProfile(new DeleteInstanceProfileRequest()
            .withInstanceProfileName(instanceProfile));
    AmazonS3Client client = getorCreateClient(AmazonS3Client.class);

    AWSTestUtils.emptyAndDeleteBucket(client,bucketName);
}

AWSDatabase(final Map<String,AmazonEC2Client> ec2Clients,final Map<String,AmazonRDSClient> rdsClients,AmazonDynamoDBClient> dynamoClients,AmazonSQSClient> sqsClients,AmazonElastiCacheClient> elasticacheClients,final AmazonIdentityManagementClient iamClient) {
    this(ec2Clients,rdsClients,dynamoClients,sqsClients,elasticacheClients,iamClient,null);
}

private AmazonIdentityManagement findClient(String accessKeyId,String secretAccessKey) {
        // Todo: need to config client config parameter. ignore it for Now.
        AWSCredentials credential = new BasicAWSCredentials(accessKeyId,secretAccessKey);
        AmazonIdentityManagement iam = new AmazonIdentityManagementClient(credential);
//        iam.setEndpoint(Region.toIamEndpoint());
        return iam;
    }

/**
 * @inheritDoc
 */
@Override
public void createAgentInstanceProfile( String profileName,String controlRoleArn,Identity identity )
{
    AmazonIdentityManagement iam =
        ActivityUtils.createClient( AmazonIdentityManagementClient.class,identity );

    // Create role if necessary
    String roleName = profileName + "-role";
    Map<String,String> policyVariables = new HashMap<String,String>();
    policyVariables.put( "CONTROLLER_ROLE_ARN",controlRoleArn );
    Role role =
        ActivityUtils.createRole( roleName,iam,"datamung/agent-policy.json",policyVariables,"datamung/agent-trust.json",null );

    // Create instance profile and associate role if necessary
    boolean roleAssociationrequired = true;
    try
    {
        iam.createInstanceProfile( new CreateInstanceProfileRequest().withInstanceProfileName( profileName ).withPath( role.getPath() ) );
    }
    catch ( EntityAlreadyExistsException e )
    {
        LOG.info( "Instance profile " + profileName + " already exists!" );
        roleAssociationrequired =
            iam.getInstanceProfile( new GetInstanceProfileRequest().withInstanceProfileName( profileName ) ).getInstanceProfile().getRoles().isEmpty();
    }
    if ( roleAssociationrequired )
    {
        LOG.info( "Adding role " + roleName + " to instance profile "
            + profileName );
        iam.addRoletoInstanceProfile( new AddRoletoInstanceProfileRequest().withInstanceProfileName( profileName ).withRoleName( roleName ) );
    }
}

/**
 * @inheritDoc
 */
@Override
public void deleteInstanceProfile( String profileName,identity );

    String roleName = profileName + "-role";
    try
    {
        GetInstanceProfileResult profileResult =
            iam.getInstanceProfile( new GetInstanceProfileRequest().withInstanceProfileName( profileName ) );

        if ( !profileResult.getInstanceProfile().getRoles().isEmpty() )
        {
            iam.removeRoleFromInstanceProfile( new RemoveRoleFromInstanceProfileRequest().withInstanceProfileName( profileName ).withRoleName( roleName ) );
        }

        iam.deleteInstanceProfile( new DeleteInstanceProfileRequest().withInstanceProfileName( profileName ) );
    }
    catch ( NoSuchEntityException e )
    {
        LOG.info( "Instance profile is already gone: " + profileName );
    }
    ActivityUtils.deleteRole( roleName,iam );
}

/**
 * @inheritDoc
 */
@Override
public String createAgentControllerRole( String roleName,String workflowTaskList,Identity identity )
{
    Map<String,String>();
    policyVariables.put( "CONTROLLER_ACCOUNT_ID",accountId );
    policyVariables.put( "SWF_DOMAIN",contextProvider.getActivityExecutionContext().getDomain() );
    policyVariables.put( "TASK_LIST",workflowTaskList );

    AmazonIdentityManagement clientIam =
        ActivityUtils.createClient( AmazonIdentityManagementClient.class,identity );

    Map<String,String> trustvariables = new HashMap<String,String>();
    trustvariables.put( "CLIENT_EXTERNAL_ID",AgentConfig.ROLE_EXTERNAL_ID );
    trustvariables.put( "CLIENT_ACCOUNT_ID",ActivityUtils.getAccountId( clientIam ) );

    Role role =
        ActivityUtils.createRole( roleName,serverIam,"datamung/agent-controller-policy.json","datamung/agent-controller-trust.json",trustvariables );
    return role.getArn();
}

@BeforeMethod
public void setUp() {
    mockClient = mock(AmazonIdentityManagementClient.class);
    PrincipalAutoSuggestion principalAutoSuggestion = new PrincipalAutoSuggestion(mockClient);
    partiallyMockedPrincipalAutoSuggestion= spy(principalAutoSuggestion);
}

/**
 * Default constructor.
 */
public IamUtilsImpl() {
    this.iamClient = new AmazonIdentityManagementClient();
}

public AmazonIdentityManagementClient getIdentityManagementClient() {
  return identityManagementClient;
}

private AmazonIdentityManagementClient getIAMClient(final String accountId) {
    return clientProvider.getClient(AmazonIdentityManagementClient.class,Region.getRegion(EU_WEST_1));
}

public AmazonIdentityManagementClient getIdentityClient() {
    return identityClient;
}

public void setIdentityClient(AmazonIdentityManagementClient identityClient) {
    this.identityClient = identityClient;
}

@Override
public AmazonIdentityManagement getClient()
{
  AWSCredentials credentials = new Aws().getAwsCredentials();
  return new AmazonIdentityManagementClient( credentials );
}

@Bean
public AmazonIdentityManagement amazonIdentityManagement() {
    return new AmazonIdentityManagementClient(awsCredentials(),awsClientConfiguration.toClientConfiguration());
}

@BeforeClass
public static void setUp() {
    s3Client = new AmazonS3Client();
    client = new AWSOpsWorksClient();
    iamClient = new AmazonIdentityManagementClient();
}

public AmazonIdentityManagement createAmazonIdentityManagement(AwsCredentialView awsCredential) {
    return isRoleAssumerequired(awsCredential)
            ? new AmazonIdentityManagementClient(credentialClient.retrieveCachedSessionCredentials(awsCredential))
            : new AmazonIdentityManagementClient(createAwsCredentials(awsCredential));
}

public AWSDatabaseHolder(Config config) {
    maxAgeInMs = config.getDuration("maxAge",TimeUnit.MILLISECONDS);

    final DefaultAWSCredentialsProviderChain awsCredentialsProviderChain = new DefaultAWSCredentialsProviderChain();

    final ClientConfiguration clientConfig = new ClientConfiguration();
    clientConfig.setRetryPolicy(new RetryPolicy(null,config.getInt("maxErrorRetry"),true));

    final AmazonEC2Client bootstrapEC2Client = new AmazonEC2Client(awsCredentialsProviderChain);
    ec2Clients = Maps.newHashMap();
    rdsClients = Maps.newHashMap();
    sqsClients = Maps.newHashMap();
    dynamoDBClients = Maps.newHashMap();
    elasticacheClients = Maps.newHashMap();

    final List<Region> ec2Regions = bootstrapEC2Client.describeRegions().getRegions();
    for (Region region : ec2Regions) {
        final String regionName = region.getRegionName();
        final String endpoint = region.getEndpoint();
        log.debug("Adding ec2 region {}",region);

        final AmazonEC2Client ec2Client = new AmazonEC2Client(awsCredentialsProviderChain,clientConfig);
        ec2Client.setEndpoint(endpoint);
        ec2Clients.put(regionName,ec2Client);

        final AmazonRDSClient rdsClient = new AmazonRDSClient(awsCredentialsProviderChain,clientConfig);
        rdsClient.setEndpoint(endpoint.replaceFirst("ec2\\.","rds."));
        rdsClients.put(regionName,rdsClient);

        final AmazonDynamoDBClient dynamoDBClient =
            new AmazonDynamoDBClient(awsCredentialsProviderChain,clientConfig);
        dynamoDBClient.setEndpoint(endpoint.replaceFirst("ec2\\.","dynamodb."));
        dynamoDBClients.put(regionName,dynamoDBClient);

        final AmazonSQSClient sqsClient = new AmazonSQSClient(awsCredentialsProviderChain,clientConfig);
        sqsClient.setEndpoint(endpoint.replaceFirst("ec2\\.","sqs."));
        sqsClients.put(regionName,sqsClient);

        final AmazonElastiCacheClient elastiCacheClient = new AmazonElastiCacheClient
            (awsCredentialsProviderChain,clientConfig);
        elastiCacheClient.setEndpoint(endpoint.replaceFirst("ec2\\.","elasticache."));
        elasticacheClients.put(regionName,elastiCacheClient);
    }

    this.iamClient = new AmazonIdentityManagementClient(awsCredentialsProviderChain,clientConfig);

    if (config.hasPath("accountNumber")) {
        this.awsAccountNumber = config.getString("accountNumber");
    } else {
        this.awsAccountNumber = null;
    }

    rebuild();
}

@Before
public void setUp() throws Exception {
    clientMock = mock(AmazonIdentityManagementClient.class);

    final ClientProvider clientProviderMock = mock(ClientProvider.class);
    when(clientProviderMock.getClient(any(),any(),any())).thenReturn(clientMock);

    policyProvider = new PolicyProviderImpl(clientProviderMock);

}

/**
 * Parameterized constructor. Pass the AWS Region as parameter.
 * @param region 
 */
public IamUtilsImpl(Regions region) {
    this.iamClient = new AmazonIdentityManagementClient().withRegion(region);        
}

/**
 * Construct a service implementation that talks to the specified AWS
 * region. The low-level client will be created via the default no-arg
 * constructor,which means it will have all the default client
 * configurations and it will use the default provider chain to retrieve AWS
 * credentials. If you need more flexible control over the low-level client,* use {@link #IdentityManagementImpl(AmazonIdentityManagement)} instead.
 *
 * @param region The AWS region where the service API calls will be sent to.
 */
public IdentityManagementImpl(Regions region) {
    this(new AmazonIdentityManagementClient());
    this.client().setRegion(Region.getRegion(region));
}

private AmazonIdentityManagement client() {
    return AmazonIdentityManagementClientBuilder.standard()
            .withCredentials(new AWsstaticCredentialsProvider(new AWSCredentials() {
                @Override
                public String getAWSAccessKeyId() {
                    return bookmark.getCredentials().getUsername();
                }

                @Override
                public String getAWSSecretKey() {
                    return bookmark.getCredentials().getpassword();
                }
            }))
            .withClientConfiguration(configuration)
            .withRegion(Regions.DEFAULT_REGION).build();
}

void addRolesToIdentityPool(String unauthenticatedRoleName,String unauthenticatedRole,String authenticatedRoleName,String authenticatedRole,String identityPoolId,AmazonCognitoIdentity client,LambdaLogger logger) {
  // First update the roles to use the actual pool id in their conditions
  logger
      .log("Updating authenticated and unauthenticated roles to use the actual identity pool id: "
          + identityPoolId);
  AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard().build();
  UpdateAssumeRolePolicyRequest updateAssumeRolePolicyRequest = new UpdateAssumeRolePolicyRequest();
  updateAssumeRolePolicyRequest.setRoleName(unauthenticatedRoleName);
  updateAssumeRolePolicyRequest.setPolicyDocument(getAssumeRolePolicyDocument(false,identityPoolId,logger));
  iamClient.updateAssumeRolePolicy(updateAssumeRolePolicyRequest);
  updateAssumeRolePolicyRequest.setRoleName(authenticatedRoleName);
  updateAssumeRolePolicyRequest.setPolicyDocument(getAssumeRolePolicyDocument(true,logger));
  iamClient.updateAssumeRolePolicy(updateAssumeRolePolicyRequest);

  // And add the updated roles to the pool
  logger.log("Adding updated authenticated and unauthenticated roles to the identity pool");
  SetIdentityPoolRolesRequest setIdentityPoolRolesRequest = new SetIdentityPoolRolesRequest();
  setIdentityPoolRolesRequest.addRolesEntry("authenticated",authenticatedRole);
  setIdentityPoolRolesRequest.addRolesEntry("unauthenticated",unauthenticatedRole);
  setIdentityPoolRolesRequest.setIdentityPoolId(identityPoolId);
  client.setIdentityPoolRoles(setIdentityPoolRolesRequest);
}

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username\n" +
            "Ex: createuser <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        createuserRequest request = new createuserRequest()
            .withUserName(username);

        createuserResult response = iam.createuser(request);

        System.out.println("Successfully created user: " +
                response.getUser().getUserName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a certificate name\n" +
            "Ex: GetServerCertificate <certificate-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cert_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetServerCertificateRequest request = new GetServerCertificateRequest()
                    .withServerCertificateName(cert_name);

        GetServerCertificateResult response = iam.getServerCertificate(request);

        System.out.format("Successfully retrieved certificate with body %s",response.getServerCertificate().getCertificateBody());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a policy arn\n" +
            "Ex: GetPolicy <policy-arn>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String policy_arn = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetPolicyRequest request = new GetPolicyRequest()
            .withPolicyArn(policy_arn);

        GetPolicyResult response = iam.getPolicy(request);

        System.out.format("Successfully retrieved policy %s",response.getPolicy().getPolicyName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a certificate name\n" +
            "Ex: DeleteServerCertificate <certificate-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cert_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteServerCertificateRequest request =
            new DeleteServerCertificateRequest()
                .withServerCertificateName(cert_name);

        DeleteServerCertificateResult response =
            iam.deleteServerCertificate(request);

        System.out.println("Successfully deleted server certificate " +
                cert_name);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a role name and policy arn\n" +
            "Ex: DetachRolePolicy <role-name> <policy-arn>>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String role_name = args[0];
        String policy_arn = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DetachRolePolicyRequest request = new DetachRolePolicyRequest()
            .withRoleName(role_name)
            .withPolicyArn(policy_arn);

        DetachRolePolicyResult response = iam.detachRolePolicy(request);

        System.out.println("Successfully detached policy " + policy_arn +
                " from role " + role_name);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an account alias\n" +
            "Ex: DeleteAccountAlias <account-alias>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String alias = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
            .withAccountAlias(alias);

        DeleteAccountAliasResult response = iam.deleteAccountAlias(request);

        System.out.println("Successfully deleted account alias " + alias);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListUsersRequest request = new ListUsersRequest();

        while(!done) {
            ListUsersResult response = iam.listUsers(request);

            for(User user : response.getUsers()) {
                System.out.format("Retrieved user %s",user.getUserName());
            }

            request.setMarker(response.getMarker());

            if(!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an IAM user\n" +
            "Ex: CreateAccessKey <user>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String user = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreateAccessKeyRequest request = new CreateAccessKeyRequest()
            .withUserName(user);

        CreateAccessKeyResult response = iam.createAccessKey(request);

        System.out.println("Created access key: " + response.getAccessKey());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an access key id\n" +
            "Ex: AccessKeyLastUsed <access-key-id>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String access_id = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        GetAccessKeyLastUsedRequest request = new GetAccessKeyLastUsedRequest()
            .withAccessKeyId(access_id);

        GetAccessKeyLastUsedResult response = iam.getAccessKeyLastUsed(request);

        System.out.println("Access key was last used at: " +
                response.getAccessKeyLastUsed().getLastUsedDate());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a policy name\n" +
            "Ex: CreatePolicy <policy-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String policy_name = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreatePolicyRequest request = new CreatePolicyRequest()
            .withPolicyName(policy_name)
            .withPolicyDocument(POLICY_DOCUMENT);

        CreatePolicyResult response = iam.createPolicy(request);

        System.out.println("Successfully created policy: " +
                response.getPolicy().getPolicyName());
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username and access key id\n" +
            "Ex: DeleteAccessKey <username> <access-key-id>\n";

        if (args.length != 2) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];
        String access_key = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
            .withAccessKeyId(access_key)
            .withUserName(username);

        DeleteAccessKeyResult response = iam.deleteAccessKey(request);

        System.out.println("Successfully deleted access key " + access_key +
                " from user " + username);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an alias\n" +
            "Ex: CreateAccountAlias <alias>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String alias = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        CreateAccountAliasRequest request = new CreateAccountAliasRequest()
            .withAccountAlias(alias);

        CreateAccountAliasResult response = iam.createAccountAlias(request);

        System.out.println("Successfully created account alias: " + alias);
    }

@Override
public void execute() throws MojoExecutionException,MojoFailureException {
    Proxy proxy = new Proxy(httpsProxyHost,httpsProxyPort,httpsProxyUsername,httpsProxyPassword);
    AwsKeyPair keyPair = Util.getAwsKeyPair(serverId,awsAccessKey,awsSecretAccessKey,settings,decrypter);
    final AWSCredentialsProvider credentials = new AWsstaticCredentialsProvider(
            new BasicAWSCredentials(keyPair.key,keyPair.secret));
    ClientConfiguration cc = Util.createConfiguration(proxy);

    AmazonIdentityManagement iam = AmazonIdentityManagementClientBuilder //
            .standard() //
            .withRegion(region) //
            .withCredentials(credentials) //
            .withClientConfiguration(cc) //
            .build();
    String accountId = iam.getUser().getUser().getUserId();
    project.getProperties().setProperty("aws.account.id",accountId);
    getLog().info("The following properties have been set for the project");
    getLog().info("aws.account.id=" + accountId);
}

public void createS3BucketProfile()
{
  AmazonIdentityManagement aim = getClient();

  String profile = getUserProperty( REPO_PROFILE );
  String role = getUserProperty( REPO_ROLE );

  if ( instanceProfileExists( profile ) )
  {
    console.write( "Profile '" + profile + "' already exists" ); //$NON-NLS-1$ //$NON-NLS-2$
    return;
  }

  CreateInstanceProfileResult result = aim.createInstanceProfile( new CreateInstanceProfileRequest().withInstanceProfileName( profile ) );

  // add roles to profil
  aim.addRoletoInstanceProfile( new AddRoletoInstanceProfileRequest().withInstanceProfileName( profile )
                                                                     .withRoleName( role ) );

  console.write( "Profile '" + profile + "' created at " + result.getInstanceProfile().getCreateDate() ); //$NON-NLS-1$ //$NON-NLS-2$
}

private boolean checkIamOrS3Statement(String roleName,AmazonIdentityManagement client,String s) throws Exception {
    GetRolePolicyRequest getRolePolicyRequest = new GetRolePolicyRequest();
    getRolePolicyRequest.setRoleName(roleName);
    getRolePolicyRequest.setPolicyName(s);
    GetRolePolicyResult rolePolicy = client.getRolePolicy(getRolePolicyRequest);
    String decode = URLDecoder.decode(rolePolicy.getPolicyDocument(),"UTF-8");
    JsonNode object = JsonUtil.readTree(decode);
    JsonNode statement = object.get("Statement");
    for (int i = 0; i < statement.size(); i++) {
        JsonNode action = statement.get(i).get("Action");
        for (int j = 0; j < action.size(); j++) {
            String actionEntry = action.get(j).textValue().replaceAll(" ","").toLowerCase();
            if ("iam:createrole".equals(actionEntry) || "iam:*".equals(actionEntry)) {
                LOGGER.info("Role has able to operate on iam resources: {}.",action.get(j));
                return true;
            }
        }
    }
    return false;
}

public static void main(String... args) throws IOException {
    AWSCredentialsProvider credentials = CredentialsUtils.getAwsCredentials();

    AmazonS3 storage = new AmazonS3Client(credentials);
    storage.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonSQS queue = new AmazonSQSClient(credentials);
    queue.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonEC2 machines = new AmazonEC2Client(credentials);
    machines.setRegion(Region.getRegion(Regions.EU_WEST_1));

    AmazonIdentityManagement identityManagement = new AmazonIdentityManagementClient(credentials);
    identityManagement.setRegion(Region.getRegion(Regions.EU_WEST_1));

    if ("launch".equals(args[0])) {
        setup(storage,queue,machines,identityManagement);

        manageAnswers(queue);
    } else if ("run".equals(args[0])) {
        run(storage,queue);
    } else {
        System.out.println("Huh hoh! Don't kNow what you intended to do...");
    }
}

public static PrincipalAutoSuggestion fromCredentials(AWSCredentialsProvider awsCredentials,ClientConfiguration clientConfiguration) {

        AmazonIdentityManagement client = AmazonIdentityManagementClientBuilder.standard()
                .withCredentials(awsCredentials)
                .withClientConfiguration(transformAndVerifyOrThrow(clientConfiguration))
                .withRegion(RegionResolver.getRegion())
                .build();

        return new PrincipalAutoSuggestion(client);
    }

public static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials,ClientConfiguration clientConfiguration) {
    AmazonIdentityManagement client = AmazonIdentityManagementClientBuilder.standard()
        .withCredentials(awsCredentials)
        .withClientConfiguration(transformAndVerifyOrThrow(clientConfiguration))
        .withRegion(RegionResolver.getRegion())
        .build();
    return new IAMPolicyManager(client,awsCredentials,clientConfiguration);
}

private static void cleanUpIAM(Regions testRegion,String testResourcePrefix,Date createdBeforeThreshold,AWSCredentialsProvider awsCredentials) {
    AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard()
        .withCredentials(awsCredentials)
        .withRegion(testRegion)
        .build();
    IAMPolicyManager iamPolicyManager = IAMPolicyManager.fromCredentials(awsCredentials,new ClientConfiguration());

    LOG.info("Cleaning IAM policies...");
    ListPoliciesRequest listPoliciesRequest = new ListPoliciesRequest().withPathPrefix(IAMPolicyManager.PATH_PREFIX);
    List<Policy> policies = iamClient.listPolicies(listPoliciesRequest).getPolicies();
    for (Policy policy: policies) {
        if (policy.getPolicyName().startsWith(testResourcePrefix) &&
                policy.getCreateDate().before(createdBeforeThreshold)) {
            LOG.info("Cleaning up policy: " + policy.getPolicyName());

            IAMPolicyName iamPolicyName = IAMPolicyName.fromString(policy.getPolicyName());
            iamPolicyManager.detachAllPrincipals(iamPolicyName.group);

            DeletePolicyRequest deletePolicyRequest = new DeletePolicyRequest().withPolicyArn(policy.getArn());
            iamClient.deletePolicy(deletePolicyRequest);
        }
    }

    LOG.info("Cleaning IAM roles created for the assume role tests...");
    ListRolesRequest listRolesRequest = new ListRolesRequest().withPathPrefix(IAMHelper.PATH);
    List<Role> roles = iamClient.listRoles(listRolesRequest).getRoles();
    for (Role role: roles) {
        if (role.getRoleName().startsWith(AssumedRoleTestContext.ROLE_PREFIX) &&
                role.getCreateDate().before(createdBeforeThreshold)) {
            LOG.info("Cleaning up role: " + role.getRoleName());
            DeleteRoleRequest deleteRoleRequest = new DeleteRoleRequest().withRoleName(role.getRoleName());
            iamClient.deleteRole(deleteRoleRequest);
        }
    }

}

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply an IAM  username\n" +
            "Ex: ListAccessKeys <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListAccessKeysRequest request = new ListAccessKeysRequest()
                .withUserName(username);

        while (!done) {

            ListAccessKeysResult response = iam.listAccessKeys(request);

            for (AccessKeyMetadata Metadata :
                    response.getAccessKeyMetadata()) {
                System.out.format("Retrieved access key %s",Metadata.getAccessKeyId());
            }

            request.setMarker(response.getMarker());

            if (!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username,access key id and status\n" +
            "Ex: UpdateAccessKey <username> <access-key-id> <Activate|Inactive>\n";

        if (args.length != 3) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];
        String access_id = args[1];
        String status = args[2];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
            .withAccessKeyId(access_id)
            .withUserName(username)
            .withStatus(status);

        UpdateAccessKeyResult response = iam.updateAccessKey(request);

        System.out.printf(
                "Successfully updated status of access key %s to" +
                "status %s for user %s",access_id,status,username);
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply the current certificate name and\n" +
            "a new name. Ex:\n\n" +
            "UpdateServerCertificate <current-name> <new-name>\n";

        if (args.length != 2) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cur_name = args[0];
        String new_name = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateServerCertificateRequest request =
            new UpdateServerCertificateRequest()
                .withServerCertificateName(cur_name)
                .withNewServerCertificateName(new_name);

        UpdateServerCertificateResult response =
            iam.updateServerCertificate(request);

        System.out.printf("Successfully updated server certificate to name %s",new_name);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        boolean done = false;
        ListServerCertificatesRequest request =
                new ListServerCertificatesRequest();

        while(!done) {

            ListServerCertificatesResult response =
                iam.listServerCertificates(request);

            for(ServerCertificateMetadata Metadata :
                    response.getServerCertificateMetadataList()) {
                System.out.printf("Retrieved server certificate %s",Metadata.getServerCertificateName());
            }

            request.setMarker(response.getMarker());

            if(!response.getIsTruncated()) {
                done = true;
            }
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply the current username and a new\n" +
            "username. Ex:\n\n" +
            "UpdateUser <current-name> <new-name>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String cur_name = args[0];
        String new_name = args[1];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        UpdateUserRequest request = new UpdateUserRequest()
            .withUserName(cur_name)
            .withNewUserName(new_name);

        UpdateUserResult response = iam.updateUser(request);

        System.out.printf("Successfully updated user to username %s",new_name);
    }

public static void main(String[] args) {

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        ListAccountAliasesResult response = iam.listAccountAliases();

        for (String alias : response.getAccountAliases()) {
            System.out.printf("Retrieved account alias %s",alias);
        }
    }

public static void main(String[] args) {

        final String USAGE =
            "To run this example,supply a username\n" +
            "Ex: DeleteUser <username>\n";

        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String username = args[0];

        final AmazonIdentityManagement iam =
            AmazonIdentityManagementClientBuilder.defaultClient();

        DeleteUserRequest request = new DeleteUserRequest()
            .withUserName(username);

        try {
            iam.deleteUser(request);
        } catch (DeleteConflictException e) {
            System.out.println("Unable to delete user. Verify user is not" +
                    " associated with any resources");
            throw e;
        }

        System.out.println("Successfully deleted IAM user " + username);
    }

/**
 * Binds all the Amazon services used.
 */
@Override
protected void configure() {
    final Region region = Region.getRegion(Regions.fromName(regionName));
    bind(AmazonEC2.class).toInstance(createAmazonClientInstance(AmazonEC2Client.class,region));
    bind(AmazonCloudFormation.class).toInstance(createAmazonClientInstance(AmazonCloudFormationClient.class,region));
    bind(AmazonIdentityManagement.class).toInstance(createAmazonClientInstance(AmazonIdentityManagementClient.class,region));
    bind(AWSKMS.class).toInstance(createAmazonClientInstance(AWSKMSClient.class,region));
    bind(AmazonS3.class).toInstance(createAmazonClientInstance(AmazonS3Client.class,region));
    bind(AmazonAutoScaling.class).toInstance(createAmazonClientInstance(AmazonAutoScalingClient.class,region));
    bind(AWSSecurityTokenService.class).toInstance(createAmazonClientInstance(AWSSecurityTokenServiceClient.class,region));
    bind(AWSLambda.class).toInstance(createAmazonClientInstance(AWSLambdaClient.class,region));
    bind(AmazonSNS.class).toInstance(createAmazonClientInstance(AmazonSNSClient.class,region));
}

/**
 * Construct a service implementation using the specified client object.
 *
 * @param client The low-level client which the service implementation will
 *         use to make API calls.
 */
public IdentityManagementImpl(AmazonIdentityManagement client) {
    ServiceModel model = V1ModelLoader.load(IdentityManagement.class,IdentityManagement.class.getAnnotation(V1ServiceInterface.class).model());

    this.service = new ServiceImpl<AmazonIdentityManagement>(model,client);
}

@Test
public void getobject_instanceWithTagsConfiguredWithCustomresourceResolverAndCustomregion_mapWithTagsReturned() throws Exception {
    //Arrange
    AmazonRDS amazonRds = mock(AmazonRDS.class);
    ResourceIdResolver resourceIdResolver = mock(ResourceIdResolver.class);
    AmazonIdentityManagement amazonIdentityManagement = mock(AmazonIdentityManagement.class);
    AmazonRdsDataSourceUserTagsfactorybean factorybean = new AmazonRdsDataSourceUserTagsfactorybean(amazonRds,"test",amazonIdentityManagement);
    factorybean.setResourceIdResolver(resourceIdResolver);
    factorybean.setRegion(Region.getRegion(Regions.EU_WEST_1));

    when(resourceIdResolver.resolvetoPhysicalResourceId("test")).thenReturn("stack-test");
    when(amazonIdentityManagement.getUser()).thenReturn(new GetUserResult().withUser(new User("/","aemruli","123456789012","arn:aws:iam::1234567890:user/aemruli",new Date())));
    when(amazonRds.listTagsForResource(new ListTagsForResourceRequest().withResourceName("arn:aws:rds:eu-west-1:1234567890:db:stack-test"))).thenReturn(new ListTagsForResourceResult().withTagList(
            new Tag().withKey("key1").withValue("value1"),new Tag().withKey("key2").withValue("value2")
    ));

    //Act
    factorybean.afterPropertiesSet();
    Map<String,String> userTagMap = factorybean.getobject();

    //Assert
    assertEquals("value1",userTagMap.get("key1"));
    assertEquals("value2",userTagMap.get("key2"));
}

@Test
public void getobject_instanceWithOutTags_emptyMapReturned() throws Exception {
    //Arrange
    AmazonRDS amazonRds = mock(AmazonRDS.class);
    ResourceIdResolver resourceIdResolver = mock(ResourceIdResolver.class);
    AmazonIdentityManagement amazonIdentityManagement = mock(AmazonIdentityManagement.class);
    AmazonRdsDataSourceUserTagsfactorybean factorybean = new AmazonRdsDataSourceUserTagsfactorybean(amazonRds,amazonIdentityManagement);
    factorybean.setResourceIdResolver(resourceIdResolver);
    factorybean.setResourceIdResolver(resourceIdResolver);
    factorybean.setRegion(Region.getRegion(Regions.EU_WEST_1));

    when(resourceIdResolver.resolvetoPhysicalResourceId("test")).thenReturn("stack-test");
    when(amazonIdentityManagement.getUser()).thenReturn(new GetUserResult().withUser(new User("/",new Date())));
    when(amazonRds.listTagsForResource(new ListTagsForResourceRequest().withResourceName("arn:aws:rds:eu-west-1:1234567890:db:stack-test"))).thenReturn(new ListTagsForResourceResult());

    //Act
    factorybean.afterPropertiesSet();
    Map<String,String> userTagMap = factorybean.getobject();

    //Assert
    assertTrue(userTagMap.isEmpty());
}

@Test
public void getobject_instanceWithTagsAndnoresourceIdResolverAndDefaultRegion_mapWithTagsReturned() throws Exception {
    //Arrange
    AmazonRDS amazonRds = mock(AmazonRDS.class);
    AmazonIdentityManagement amazonIdentityManagement = mock(AmazonIdentityManagement.class);

    AmazonRdsDataSourceUserTagsfactorybean factorybean = new AmazonRdsDataSourceUserTagsfactorybean(amazonRds,amazonIdentityManagement);


    when(amazonIdentityManagement.getUser()).thenReturn(new GetUserResult().withUser(new User("/",new Date())));
    when(amazonRds.listTagsForResource(new ListTagsForResourceRequest().withResourceName("arn:aws:rds:us-west-2:1234567890:db:test"))).thenReturn(new ListTagsForResourceResult().withTagList(
            new Tag().withKey("key1").withValue("value1"),userTagMap.get("key2"));
}

@Test
public void parseInternal_userTagsDefined_createsUserTagBeanDeFinition() throws Exception {

    //Arrange
    DefaultListablebeanfactory beanfactory = new DefaultListablebeanfactory();

    BeanDeFinitionBuilder beanDeFinitionBuilder = BeanDeFinitionBuilder.rootBeanDeFinition(Mockito.class);
    beanDeFinitionBuilder.setFactoryMethod("mock");
    beanDeFinitionBuilder.addConstructorArgValue(AmazonRDS.class);
    beanfactory.registerBeanDeFinition(AmazonWebserviceClientConfigurationUtils.getBeanName(AmazonRDSClient.class.getName()),beanDeFinitionBuilder.getBeanDeFinition());

    BeanDeFinitionBuilder identityBuilder = BeanDeFinitionBuilder.rootBeanDeFinition(Mockito.class);
    identityBuilder.setFactoryMethod("mock");
    identityBuilder.addConstructorArgValue(AmazonIdentityManagement.class);
    beanfactory.registerBeanDeFinition(AmazonWebserviceClientConfigurationUtils.getBeanName(AmazonIdentityManagement.class.getName()),identityBuilder.getBeanDeFinition());

    XmlBeanDeFinitionReader xmlBeanDeFinitionReader = new XmlBeanDeFinitionReader(beanfactory);
    xmlBeanDeFinitionReader.loadBeanDeFinitions(new ClassPathResource(getClass().getSimpleName() + "-userTags.xml",getClass()));

    AmazonRDS client = beanfactory.getBean(AmazonWebserviceClientConfigurationUtils.getBeanName(AmazonRDSClient.class.getName()),AmazonRDS.class);
    AmazonIdentityManagement amazonIdentityManagement = beanfactory.getBean(AmazonWebserviceClientConfigurationUtils.getBeanName(AmazonIdentityManagement.class.getName()),AmazonIdentityManagement.class);

    when(amazonIdentityManagement.getUser()).thenReturn(new GetUserResult().withUser(new User("/",new Date())));
    when(client.listTagsForResource(new ListTagsForResourceRequest().withResourceName("arn:aws:rds:us-west-2:1234567890:db:test"))).thenReturn(new ListTagsForResourceResult().withTagList(
            new Tag().withKey("key1").withValue("value2")
    ));

    //Act
    Map<?,?> dsTags = beanfactory.getBean("dsTags",Map.class);

    //Assert
    assertEquals("value2",dsTags.get("key1"));
}

@Autowired
public Iam(AmazonIdentityManagement iam,BucketGroupPolicy bucketGroupPolicy,@Value("${GROUP_PATH:/cloud-foundry/s3/}") String groupPath,@Value("${GROUP_NAME_PREFIX:cloud-foundry-s3-}") String groupNamePrefix,@Value("${POLICY_NAME_PREFIX:cloud-foundry-s3-}") String policyNamePrefix,@Value("${USER_PATH:/cloud-foundry/s3/}") String userPath,@Value("${USER_NAME_PREFIX:cloud-foundry-s3-}") String userNamePrefix) {
    this.iam = iam;
    this.bucketGroupPolicy = bucketGroupPolicy;
    this.groupPath = groupPath;
    this.groupNamePrefix = groupNamePrefix;
    this.policyNamePrefix = policyNamePrefix;
    this.userPath = userPath;
    this.userNamePrefix = userNamePrefix;
}

@Autowired
public BasicPlanIam(AmazonIdentityManagement iam,@Value("${USER_NAME_PREFIX:cloud-foundry-s3-}") String userNamePrefix) {
    super(iam,bucketGroupPolicy,groupPath,groupNamePrefix,policyNamePrefix,userPath,userNamePrefix);
}

private boolean checkIamOrS3Access(AmazonIdentityManagement client,AttachedPolicy attachedPolicy) {
    GetPolicyRequest getRolePolicyRequest = new GetPolicyRequest();
    getRolePolicyRequest.setPolicyArn(attachedPolicy.getPolicyArn());
    GetPolicyResult policy = client.getPolicy(getRolePolicyRequest);
    if (policy.getPolicy().getArn().toLowerCase().contains("iam")) {
        LOGGER.info("Role has policy for iam resources: {}.",policy.getPolicy().getArn());
        return true;
    }
    return false;
}

@Override
public CloudAccessConfigs accessConfigs(CloudCredential cloudCredential,Region region,Map<String,String> filters) throws Exception {
    String queryFailedMessage = "Could not get instance profile roles from Amazon: ";

    CloudAccessConfigs cloudAccessConfigs = new CloudAccessConfigs(new HashSet<>());
    AwsCredentialView awsCredentialView = new AwsCredentialView(cloudCredential);
    AmazonIdentityManagement client = awsClient.createAmazonIdentityManagement(awsCredentialView);
    try {
        ListInstanceProfilesResult listRolesResult = client.listInstanceProfiles();
        for (InstanceProfile instanceProfile : listRolesResult.getInstanceProfiles()) {
            Map<String,Object> properties = new HashMap<>();
            properties.put("arn",instanceProfile.getArn());
            properties.put("creationDate",instanceProfile.getCreateDate().toString());
            if (!instanceProfile.getRoles().isEmpty()) {
                String roleName = instanceProfile.getRoles().get(0).getArn();
                properties.put("roleArn",Strings.isNullOrEmpty(roleName) ? instanceProfile.getArn() : roleName);
            }
            cloudAccessConfigs.getCloudAccessConfigs().add(
                    new CloudAccessConfig(
                            instanceProfile.getInstanceProfileName(),instanceProfile.getInstanceProfileId(),properties));
        }
    } catch (AmazonServiceException ase) {
        if (ase.getStatusCode() == UNAUTHORIZED) {
            String policyMessage = "Could not get instance profile roles because the user does not have enough permission.";
            LOGGER.info(policyMessage + ase);
            throw new CloudConnectorException(policyMessage,ase);
        } else {
            LOGGER.error(queryFailedMessage,ase);
            throw new CloudConnectorException(queryFailedMessage + ase.getMessage(),ase);
        }
    } catch (Exception e) {
        LOGGER.error(queryFailedMessage,e);
        throw new CloudConnectorException(queryFailedMessage + e.getMessage(),e);
    }
    return cloudAccessConfigs;
}

private static void setup(AmazonS3 storage,AmazonSQS queue,AmazonEC2 machines,AmazonIdentityManagement identityManagement) throws IOException {
    S3Utils.checkCreateBucket(storage,CODE_MYPROJECT_COM); // Moved in local machine running code to avoid permission denied on EC2 machines
    SQSUtils.checkCreateQueues(queue,INPUT_QUEUE,REPORT_QUEUE);

    S3Utils.upload(storage,new FileInputStream("./target/" + JAR_FILE),CODE_MYPROJECT_COM,JAR_FILE,"application/java-archive",CannedAccessControlList.Private);

    String profileArn = IamUtils.setupRunnerSecurity(identityManagement,SQSUtils.getQueueArn(queue,INPUT_QUEUE),REPORT_QUEUE));
    Ec2Utils.run(machines,"./shell/startupScript.sh",NUMBER_OF_MACHInes,profileArn);
}

private AmazonIdentityManagement findClient(String accessKeyId,String secretAccessKey) {
        // Todo: need to config client config parameter. ignore it for Now.
        AWSCredentials credential = new BasicAWSCredentials(accessKeyId,secretAccessKey);
        AmazonIdentityManagement iam = new AmazonIdentityManagementClient(credential);
//        iam.setEndpoint(Region.toIamEndpoint());
        return iam;
    }

public static String postData(String url,String postData)抛出SomeCustomException

字符串url的格式应该是什么

返回String是来自服务器的响应,作为json数据的字符串表示.

编辑

目前的连接工具

package my.package;
import my.package.exceptions.CustomException;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLDecoder;

import org.apache.http.httpentity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;


 public class ConnectionUtil {

 public static String postData(String url,String postData)
        throws CustomException {

    // Create a new HttpClient and Post Header
    InputStream is = null;
    StringBuilder sb = null;
    String result = "";
    HttpClient httpclient = new DefaultHttpClient();

HttpPost httppost = new HttpPost();
    httppost.setHeader("host",url);

    Log.v("ConnectionUtil","opening POST connection to URI = " + httppost.getURI() + " url = " + URLDecoder.decode(url));

    try {
        httppost.setEntity(new StringEntity(postData));

        // Execute HTTP Post Request
        HttpResponse response = httpclient.execute(httppost);
        httpentity entity = response.getEntity();
        is = entity.getContent();

    } catch (Exception e) {
        Log.e("log_tag","Error in http connection " + e.toString());
        e.printstacktrace();
        throw new CustomException("Could not establish network connection");
    }
    try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                is,"utf-8"),8);
        sb = new StringBuilder();
        sb.append(reader.readLine() + "\n");
        String line = "0";

        while ((line = reader.readLine()) != null) {
            sb.append(line + "\n");
        }

        is.close();
        result = sb.toString();

    } catch (Exception e) {
        Log.e("log_tag","Error converting result " + e.toString());
        throw new CustomException("Error parsing the response");
    }
    Log.v("ConnectionUtil","Sent: "+postData);
    Log.v("ConnectionUtil","Got result "+result);
    return result;

}

}

Logcat输出

10-16 11:27:27.287: E/log_tag(4935): Error in http connection java.lang.NullPointerException
10-16 11:27:27.287: W/System.err(4935): java.lang.NullPointerException
10-16 11:27:27.287: W/System.err(4935): at org.apache.http.impl.client.AbstractHttpClient.determineTarget(AbstractHttpClient.java:496)
10-16 11:27:27.307: W/System.err(4935): at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:487)
10-16 11:27:27.327: W/System.err(4935): at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:465)
10-16 11:27:27.327: W/System.err(4935): at in.gharpay.zap.integration.ConnectionUtil.postData(ConnectionUtil.java:92)
10-16 11:27:27.327: W/System.err(4935): at in.gharpay.zap.integration.ZapTransaction$1.doInBackground(ZapTransaction.java:54)
10-16 11:27:27.327: W/System.err(4935): at in.gharpay.zap.integration.ZapTransaction$1.doInBackground(ZapTransaction.java:1)
10-16 11:27:27.327: W/System.err(4935): at android.os.AsyncTask$2.call(AsyncTask.java:185)
10-16 11:27:27.327: W/System.err(4935): at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:306)
10-16 11:27:27.327: W/System.err(4935): at java.util.concurrent.FutureTask.run(FutureTask.java:138)
10-16 11:27:27.327: W/System.err(4935): at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1088)
10-16 11:27:27.327: W/System.err(4935): at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:581)
10-16 11:27:27.327: W/System.err(4935): at java.lang.Thread.run(Thread.java:1019)
10-16 11:27:27.327: V/log_tag(4935): Could not establish network connection

// Build the JSON object to pass parameters
    JSONObject jsonObj = new JSONObject();
    jsonObj.put("username",username);
    jsonObj.put("data",dataValue);

    // Create the POST object and add the parameters
    HttpPost httpPost = new HttpPost(url);
    StringEntity entity = new StringEntity(jsonObj.toString(),HTTP.UTF_8);
    entity.setContentType("application/json");
    httpPost.setEntity(entity);

    HttpClient client = new DefaultHttpClient();
    HttpResponse response = client.execute(httpPost);

希望这有助于解决您的问题.谢谢.