internal GetCallerIdentityResponse GetCallerIdentity(GetCallerIdentityRequest request)
{
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return(Invoke <GetCallerIdentityRequest, GetCallerIdentityResponse>(request, marshaller, unmarshaller));
}
public async Task GetCallerIdentityAsyncTest()
{
var mockClient = new Mock <AmazonSecurityTokenServiceClient>(REGION);
mockClient.Setup(client => client.GetCallerIdentityAsync(
It.IsAny <GetCallerIdentityRequest>(),
It.IsAny <CancellationToken>()))
.Returns((GetCallerIdentityRequest r,
CancellationToken token) =>
{
return(Task.FromResult(new GetCallerIdentityResponse()
{
Arn = roleArnToAssume,
HttpStatusCode = HttpStatusCode.OK,
}));
});
var client = mockClient.Object;
var callerIdRequest = new GetCallerIdentityRequest();
var response = await client.GetCallerIdentityAsync(callerIdRequest);
bool ok = response.HttpStatusCode == HttpStatusCode.OK;
Assert.True(ok, $"Successfully retrieved caller Identity.");
}
static void Main(string[] args)
{
var roleArnToAssume = "arn:aws:iam::123456789012:role/testAssumeRole";
var principalArn = "arn:aws:iam::123456789012:saml-provider/testSamlProvider";
string base64SamlFile = "saml.xml.b64";
if (File.Exists(base64SamlFile))
{
string samlAssertion = File.ReadAllText(base64SamlFile);
var stsClient1 = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient(new AnonymousAWSCredentials());
var assumeRoleReq = new AssumeRoleWithSAMLRequest();
assumeRoleReq.DurationSeconds = 3600;
assumeRoleReq.RoleArn = roleArnToAssume;
assumeRoleReq.PrincipalArn = principalArn;
assumeRoleReq.SAMLAssertion = samlAssertion;
var assumeRoleRes = GetAssumeRoleWithSAMLResponseAsync(client: stsClient1, request: assumeRoleReq);
var stsClient2 = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient(credentials: assumeRoleRes.Result.Credentials);
var getCallerIdReq = new GetCallerIdentityRequest();
var assumedRoleIdentity = GetCallerIdentityResponseAsync(client: stsClient2, request: getCallerIdReq);
Console.WriteLine("AssumedRole Caller: " + assumedRoleIdentity.Result.Arn.ToString());
}
else
{
Console.WriteLine("Base64 Encoded SAML File: " + base64SamlFile + " does not exist in this directory.");
}
}
static async Task Main()
{
// Create the SecurityToken client and then display the identity of the
// default user.
var roleArnToAssume = "arn:aws:iam::123456789012:role/testAssumeRole";
var client = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient(REGION);
// Get and display the information about the identity of the default user.
var callerIdRequest = new GetCallerIdentityRequest();
var caller = await client.GetCallerIdentityAsync(callerIdRequest);
Console.WriteLine($"Original Caller: {caller.Arn}");
// Create the request to use with the AssumeRoleAsync call.
var assumeRoleReq = new AssumeRoleRequest()
{
DurationSeconds = 1600,
RoleSessionName = "Session1",
RoleArn = roleArnToAssume
};
var assumeRoleRes = await client.AssumeRoleAsync(assumeRoleReq);
// Now create a new client based on the credentials of the caller assuming the role.
var client2 = new AmazonSecurityTokenServiceClient(credentials: assumeRoleRes.Credentials);
// Get and display information about the caller that has assumed the defined role.
var caller2 = await client2.GetCallerIdentityAsync(callerIdRequest);
Console.WriteLine($"AssumedRole Caller: {caller2.Arn}");
}
static async Task RunExample()
{
// Identity
var client = new AmazonSecurityTokenServiceClient();
var getCallerIdReq = new GetCallerIdentityRequest();
var caller = await GetCallerIdentityResponseAsync(client, getCallerIdReq);
Console.WriteLine($"Caller identity: {caller.Arn} | {caller.Account} | {caller.UserId}");
// S3
RegionEndpoint region = RegionEndpoint.EUCentral1;
string bucketName = "dfds.static.content";
var s3Client = new AmazonS3Client(region);
var s3NewBucket = new PutBucketRequest
{
BucketName = bucketName,
BucketRegion = S3Region.EUC1,
CannedACL = S3CannedACL.Private
};
var s3BucketResponse = await s3Client.PutBucketAsync(s3NewBucket);
var s3PutObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "hello",
ContentBody = "Hi Pelle!",
ContentType = "text/plain"
};
var s3PutObjectResponse = await s3Client.PutObjectAsync(s3PutObjectRequest);
}
internal GetCallerIdentityResponse GetCallerIdentity(GetCallerIdentityRequest request)
{
GetCallerIdentityRequestMarshaller getCallerIdentityRequestMarshaller = new GetCallerIdentityRequestMarshaller();
GetCallerIdentityResponseUnmarshaller instance = GetCallerIdentityResponseUnmarshaller.Instance;
return(this.Invoke <GetCallerIdentityRequest, GetCallerIdentityResponse>(request, getCallerIdentityRequestMarshaller, instance));
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity">REST API Reference for GetCallerIdentity Operation</seealso>
public Task <GetCallerIdentityResponse> GetCallerIdentityAsync(GetCallerIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return(InvokeAsync <GetCallerIdentityRequest, GetCallerIdentityResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
static void Main(string[] args)
{
var client = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient();
var getCallerIdReq = new GetCallerIdentityRequest();
var caller = GetCallerIdentityResponseAsync(client: client, request: getCallerIdReq);
Console.WriteLine("Caller Identity ARN: " + caller.Result.Arn.ToString());
}
internal virtual GetCallerIdentityResponse GetCallerIdentity(GetCallerIdentityRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetCallerIdentityRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return(Invoke <GetCallerIdentityResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity">REST API Reference for GetCallerIdentity Operation</seealso>
public virtual Task <GetCallerIdentityResponse> GetCallerIdentityAsync(GetCallerIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetCallerIdentityRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return(InvokeAsync <GetCallerIdentityResponse>(request, options, cancellationToken));
}
/// <summary>
/// 获取当前调用者的身份信息。
/// 接口支持主账号，子账号长期密钥以及AssumeRole，GetFederationToken生成的临时凭据的身份获取。
/// </summary>
/// <param name="req"><see cref="GetCallerIdentityRequest"/></param>
/// <returns><see cref="GetCallerIdentityResponse"/></returns>
public GetCallerIdentityResponse GetCallerIdentitySync(GetCallerIdentityRequest req)
{
JsonResponseModel <GetCallerIdentityResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "GetCallerIdentity");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <GetCallerIdentityResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void GetCallerIdentityAsync(GetCallerIdentityRequest request, AmazonServiceCallback <GetCallerIdentityRequest, GetCallerIdentityResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <GetCallerIdentityRequest, GetCallerIdentityResponse> responseObject
= new AmazonServiceResult <GetCallerIdentityRequest, GetCallerIdentityResponse>((GetCallerIdentityRequest)req, (GetCallerIdentityResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <GetCallerIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
public void GetCallerIdentityAsync(GetCallerIdentityRequest request, AmazonServiceCallback <GetCallerIdentityRequest, GetCallerIdentityResponse> callback, AsyncOptions options = null)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options));
GetCallerIdentityRequestMarshaller getCallerIdentityRequestMarshaller = new GetCallerIdentityRequestMarshaller();
GetCallerIdentityResponseUnmarshaller instance = GetCallerIdentityResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null;
if (callback != null)
{
action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao)
{
AmazonServiceResult <GetCallerIdentityRequest, GetCallerIdentityResponse> val = new AmazonServiceResult <GetCallerIdentityRequest, GetCallerIdentityResponse>((GetCallerIdentityRequest)req, (GetCallerIdentityResponse)res, ex, ao.get_State());
callback.Invoke(val);
};
}
this.BeginInvoke <GetCallerIdentityRequest>(request, getCallerIdentityRequestMarshaller, instance, options, action);
}
static void Main(string[] args)
{
var roleArnToAssume = "arn:aws:iam::123456789012:role/testAssumeRole";
var client = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient();
var getCallerIdReq = new GetCallerIdentityRequest();
var caller = GetCallerIdentityResponseAsync(client: client, request: getCallerIdReq);
Console.WriteLine("Original Caller: " + caller.Result.Arn.ToString());
var assumeRoleReq = new AssumeRoleRequest();
assumeRoleReq.DurationSeconds = 1600;
assumeRoleReq.RoleSessionName = "Session1";
assumeRoleReq.RoleArn = roleArnToAssume;
var assumeRoleRes = GetAssumeRoleResponseAsync(client: client, request: assumeRoleReq);
var client2 = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient(credentials: assumeRoleRes.Result.Credentials);
var caller2 = GetCallerIdentityResponseAsync(client: client2, request: getCallerIdReq);
Console.WriteLine("AssumedRole Caller: " + caller2.Result.Arn.ToString());
}
static async Task <GetCallerIdentityResponse> GetCallerIdentityResponseAsync(AmazonSecurityTokenServiceClient client, GetCallerIdentityRequest request)
{
var caller = await client.GetCallerIdentityAsync(request);
return(caller);
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<GetCallerIdentityResponse> GetCallerIdentityAsync(GetCallerIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return InvokeAsync<GetCallerIdentityRequest,GetCallerIdentityResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Returns details about the IAM identity whose credentials are used to call the API.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity service method.</param>
///
/// <returns>The response from the GetCallerIdentity service method, as returned by SecurityTokenService.</returns>
public GetCallerIdentityResponse GetCallerIdentity(GetCallerIdentityRequest request)
{
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return Invoke<GetCallerIdentityRequest,GetCallerIdentityResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void GetCallerIdentityAsync(GetCallerIdentityRequest request, AmazonServiceCallback<GetCallerIdentityRequest, GetCallerIdentityResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<GetCallerIdentityRequest,GetCallerIdentityResponse> responseObject
= new AmazonServiceResult<GetCallerIdentityRequest,GetCallerIdentityResponse>((GetCallerIdentityRequest)req, (GetCallerIdentityResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<GetCallerIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
public Task <GetCallerIdentityResponse> GetCallerIdentityAsync(GetCallerIdentityRequest request,
CancellationToken cancellationToken = new CancellationToken())
{
return(Task.FromResult(GetCallerIdentityResponse));
}
/// <summary>
/// Initiates the asynchronous execution of the GetCallerIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetCallerIdentity operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCallerIdentity
/// operation.</returns>
public IAsyncResult BeginGetCallerIdentity(GetCallerIdentityRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetCallerIdentityRequestMarshaller();
var unmarshaller = GetCallerIdentityResponseUnmarshaller.Instance;
return BeginInvoke<GetCallerIdentityRequest>(request, marshaller, unmarshaller,
callback, state);
}
