public override void CreateDomain(string Domain) { Domain = SetDomain(Domain); CreateDomainRequest request = new CreateDomainRequest().WithDomainName(Domain); client.CreateDomain(request); }
/// <summary> /// Initiates the asynchronous execution of the CreateDomain operation. /// <seealso cref="M:Amazon.SimpleDB.AmazonSimpleDB.CreateDomain"/> /// </summary> /// <param name="request">The CreateDomainRequest that defines the parameters of /// the operation.</param> public void BeginCreateDomain(CreateDomainRequest request) { IDictionary <string, string> parameters = ConvertCreateDomain(request); SDBAsyncResult result = new SDBAsyncResult(parameters, null); invoke <CreateDomainResponse>(result); }
/// <summary> /// The <code>CreateDomain</code> operation creates a new domain. The domain name should /// be unique among the domains associated with the Access Key ID provided in the request. /// The <code>CreateDomain</code> operation may take 10 or more seconds to complete. /// /// /// <para> /// The client can create up to 100 domains per account. /// </para> /// /// <para> /// If the client requires additional domains, go to <a href="http://aws.amazon.com/contact-us/simpledb-limit-request/"> /// http://aws.amazon.com/contact-us/simpledb-limit-request/</a>. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the CreateDomain service method.</param> /// /// <returns>The response from the CreateDomain service method, as returned by SimpleDB.</returns> /// <exception cref="Amazon.SimpleDB.Model.InvalidParameterValueException"> /// The value for a parameter is invalid. /// </exception> /// <exception cref="Amazon.SimpleDB.Model.MissingParameterException"> /// The request must contain the specified missing parameter. /// </exception> /// <exception cref="Amazon.SimpleDB.Model.NumberDomainsExceededException"> /// Too many domains exist per this account. /// </exception> public virtual CreateDomainResponse CreateDomain(CreateDomainRequest request) { var marshaller = CreateDomainRequestMarshaller.Instance; var unmarshaller = CreateDomainResponseUnmarshaller.Instance; return(Invoke <CreateDomainRequest, CreateDomainResponse>(request, marshaller, unmarshaller)); }
public void sendAmazonSimpleDbIndex(String XML) { AmazonSimpleDB sdb = AWSClientFactory.CreateAmazonSimpleDBClient(RegionEndpoint.USWest2); try { String domainName = ""; CreateDomainRequest createDomain2 = (new CreateDomainRequest()).WithDomainName("index"); sdb.CreateDomain(createDomain2); domainName = "index"; String itemNameTwo = "1"; PutAttributesRequest putAttributesActionTwo = new PutAttributesRequest().WithDomainName(domainName).WithItemName(itemNameTwo); List <ReplaceableAttribute> attributesTwo = putAttributesActionTwo.Attribute; attributesTwo.Add(new ReplaceableAttribute().WithName("indexID").WithValue(indexID)); attributesTwo.Add(new ReplaceableAttribute().WithName("compID").WithValue(machineName)); attributesTwo.Add(new ReplaceableAttribute().WithName("XML_Profile").WithValue(XML)); sdb.PutAttributes(putAttributesActionTwo); } catch (AmazonSimpleDBException ex) { failCount++; log("Caught Exception: " + ex.Message); log("Response Status Code: " + ex.StatusCode); log("Error Code: " + ex.ErrorCode); log("Error Type: " + ex.ErrorType); log("Request ID: " + ex.RequestId); log("XML: " + ex.XML); } //Console.WriteLine("Press Enter to continue..."); //Console.Read(); }
public async Task <Domain> CreateDomainAsync(CreateDomainRequest createDomainRequest) { var request = mapper.Map <Data.CreateDomainRequest>(createDomainRequest); var domain = await domainDataProvider.CreateDomainAsync(request); return(mapper.Map <Domain>(domain)); }
public override void Initialize(string name, NameValueCollection config) { base.Initialize(name, config); accessKey = config["accessKey"]; secretKey = config["secretKey"]; if (string.IsNullOrEmpty(accessKey)) { throw new ConfigurationErrorsException("AWS Access Key is required."); } if (string.IsNullOrEmpty(secretKey)) { throw new ConfigurationErrorsException("AWS Secret Key is required."); } // Set any domain prefix if (!string.IsNullOrEmpty(config["domainPrefix"])) { domainPrefix = config["domainPrefix"]; } client = new AmazonSimpleDBClient(accessKey, secretKey); if (config["domains"] != null) { // Make sure domains exist string[] domains = config["domains"].ToString().Split(new char[] { ',' }); foreach (string domain in domains) { string _domain = SetDomain(domain); CreateDomainRequest request = new CreateDomainRequest().WithDomainName(_domain); client.CreateDomain(request); } } }
//Amazon public void sendAmazonSimpleMachineName() { AmazonSimpleDB sdb = AWSClientFactory.CreateAmazonSimpleDBClient(RegionEndpoint.USWest2); try { String domainName = ""; CreateDomainRequest createDomain = (new CreateDomainRequest()).WithDomainName("Computer"); sdb.CreateDomain(createDomain); // Putting data into a domain domainName = "Computer"; String itemNameOne = "1"; PutAttributesRequest putAttributesActionOne = new PutAttributesRequest().WithDomainName(domainName).WithItemName(itemNameOne); List <ReplaceableAttribute> attributesOne = putAttributesActionOne.Attribute; attributesOne.Add(new ReplaceableAttribute().WithName("compID").WithValue(machineName)); attributesOne.Add(new ReplaceableAttribute().WithName("compName").WithValue(machineName)); sdb.PutAttributes(putAttributesActionOne); } catch (AmazonSimpleDBException ex) { log(".........AmazonSimpleDBException........."); log("Caught Exception: " + ex.Message); log("Response Status Code: " + ex.StatusCode); log("Error Code: " + ex.ErrorCode); log("Error Type: " + ex.ErrorType); log("Request ID: " + ex.RequestId); log("XML: " + ex.XML); } }
public void AddDomain(string domainName) { CreateDomainRequest myCreateDomainRequest = new CreateDomainRequest { DomainName = domainName }; CreateDomainResponse response = Service.CreateDomain(myCreateDomainRequest); }
/// <summary> /// <para>Creates a new search domain.</para> /// </summary> /// /// <param name="createDomainRequest">Container for the necessary parameters to execute the CreateDomain service method on /// AmazonCloudSearch.</param> /// /// <returns>The response from the CreateDomain service method, as returned by AmazonCloudSearch.</returns> /// /// <exception cref="T:Amazon.CloudSearch.Model.BaseException" /> /// <exception cref="T:Amazon.CloudSearch.Model.LimitExceededException" /> /// <exception cref="T:Amazon.CloudSearch.Model.InternalException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task <CreateDomainResponse> CreateDomainAsync(CreateDomainRequest createDomainRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateDomainRequestMarshaller(); var unmarshaller = CreateDomainResponseUnmarshaller.GetInstance(); return(Invoke <IRequest, CreateDomainRequest, CreateDomainResponse>(createDomainRequest, marshaller, unmarshaller, signer, cancellationToken)); }
public override void Initialize(string name, NameValueCollection config) { if (config == null) { throw new ArgumentNullException("config"); } if (name == null || name.Length == 0) { name = "SDBProfileProvider"; } // Initialize the abstract base class. base.Initialize(name, config); accessKey = GetConfigValue(config["accessKey"], ""); secretKey = GetConfigValue(config["secretKey"], ""); domain = GetConfigValue(config["domain"], "Profiles"); client = new AmazonSimpleDBClient(accessKey, secretKey); // Make sure the domain for user profiles exists CreateDomainRequest cdRequest = new CreateDomainRequest(); cdRequest.DomainName = domain; client.CreateDomain(cdRequest); }
internal CreateDomainResponse CreateDomain(CreateDomainRequest request) { var marshaller = new CreateDomainRequestMarshaller(); var unmarshaller = CreateDomainResponseUnmarshaller.Instance; return(Invoke <CreateDomainRequest, CreateDomainResponse>(request, marshaller, unmarshaller)); }
/// <summary> /// Begins the registration process for claiming a domain. /// </summary> /// <param name="request">The request object containing the details to send. Required.</param> /// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param> /// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param> /// <returns>A response object containing details about the completed operation</returns> /// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/tenantmanagercontrolplane/CreateDomain.cs.html">here</a> to see an example of how to use CreateDomain API.</example> public async Task <CreateDomainResponse> CreateDomain(CreateDomainRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { logger.Trace("Called createDomain"); Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/domains".Trim('/'))); HttpMethod method = new HttpMethod("POST"); HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request); requestMessage.Headers.Add("Accept", "application/json"); GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration); HttpResponseMessage responseMessage; try { if (retryingClient != null) { responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false); } else { responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false); } this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage); return(Converter.FromHttpResponseMessage <CreateDomainResponse>(responseMessage)); } catch (Exception e) { logger.Error($"CreateDomain failed with error: {e.Message}"); throw; } }
public async Task <IActionResult> CreateDomain( [FromServices] ICommandHandlerResolver bus, [FromCommandId] Guid commandId, [FromBody] CreateDomainRequest request, CancellationToken cancellationToken = default) { // TODO: Get this validator from DI await new CreateDomainRequestValidator() .ValidateAndThrowAsync(request, cancellationToken: cancellationToken); var command = CreateDomainRequestMapping.Map(request); // TODO: Sending null for top level domain should give a decent error, not 500 // TODO: Apikey description in documentation should be translatable // TODO: Add bad format response code if it is not json return(Accepted( $"/v1/domains/{command.DomainName}", new LastObservedPositionResponse( await bus.Dispatch( commandId, command, GetMetadata(), cancellationToken)))); }
/// <summary> /// Creates the SimpleDB Domain /// </summary> /// <param name="domainName"></param> public void CreateDomain(string domainName) { var request = new CreateDomainRequest { DomainName = domainName }; Client.CreateDomain(request); }
/// <summary> /// Initiates the asynchronous execution of the CreateDomain operation. /// <seealso cref="Amazon.CloudSearch_2011_02_01.IAmazonCloudSearch"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateDomain 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 <CreateDomainResponse> CreateDomainAsync(CreateDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateDomainRequestMarshaller(); var unmarshaller = CreateDomainResponseUnmarshaller.Instance; return(InvokeAsync <CreateDomainRequest, CreateDomainResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// The <code>CreateDomain</code> operation creates a new domain. The domain name should /// be unique among the domains associated with the Access Key ID provided in the request. /// The <code>CreateDomain</code> operation may take 10 or more seconds to complete. /// /// /// <para> /// The client can create up to 100 domains per account. /// </para> /// /// <para> /// If the client requires additional domains, go to <a href="http://aws.amazon.com/contact-us/simpledb-limit-request/"> /// http://aws.amazon.com/contact-us/simpledb-limit-request/</a>. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the CreateDomain service method.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// /// <returns>The response from the CreateDomain service method, as returned by SimpleDB.</returns> /// <exception cref="Amazon.SimpleDB.Model.InvalidParameterValueException"> /// The value for a parameter is invalid. /// </exception> /// <exception cref="Amazon.SimpleDB.Model.MissingParameterException"> /// The request must contain the specified missing parameter. /// </exception> /// <exception cref="Amazon.SimpleDB.Model.NumberDomainsExceededException"> /// Too many domains exist per this account. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/CreateDomain">REST API Reference for CreateDomain Operation</seealso> public virtual Task <CreateDomainResponse> CreateDomainAsync(CreateDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainResponseUnmarshaller.Instance; return(InvokeAsync <CreateDomainResponse>(request, options, cancellationToken)); }
internal virtual CreateDomainResponse CreateDomain(CreateDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainResponseUnmarshaller.Instance; return(Invoke <CreateDomainResponse>(request, options)); }
void CreateDomain(String domainName) { CreateDomainRequest request = new CreateDomainRequest() { DomainName = domainName }; Client.CreateDomain(request); }
void Init() { client = new AmazonSimpleDBClient(accessKey, secretKey); foreach (string domain in domains) { string _domain = SetDomain(domain); CreateDomainRequest request = new CreateDomainRequest().WithDomainName(_domain); client.CreateDomain(request); } }
public virtual void CreateDomain(string domainName) { var client = this.GetClient(); var request = new CreateDomainRequest { DomainName = domainName }; var response = client.CreateDomain(request); }
private static IDictionary <string, string> ConvertCreateDomain(CreateDomainRequest request) { IDictionary <string, string> dictionary = new Dictionary <string, string>(); dictionary["Action"] = "CreateDomain"; if (request.IsSetDomainName()) { dictionary["DomainName"] = request.DomainName; } return(dictionary); }
public async Task should_fail_on_invalid_data() { var request = new CreateDomainRequest { SecondLevelDomain = "ex ira", TopLevelDomain = "com-gibberish" }; var commands = await Post("/v1/domains", request); Assert.True(commands.Count == 0); }
/** * Convert CreateDomainRequest to name value pairs */ private static IDictionary <string, string> ConvertCreateDomain(CreateDomainRequest request) { IDictionary <string, string> parameters = new Dictionary <string, string>(); parameters["Action"] = "CreateDomain"; if (request.IsSetDomainName()) { parameters["DomainName"] = request.DomainName; } return(parameters); }
/** * Convert CreateDomainRequest to name value pairs */ private IDictionary <String, String> ConvertCreateDomain(CreateDomainRequest request) { IDictionary <String, String> parameters = new Dictionary <String, String>(); parameters.Add("Action", "CreateDomain"); if (request.IsSetDomainName()) { parameters.Add("DomainName", request.DomainName); } return(parameters); }
public async Task CreateDomainAsync_ExpectedResult() { var req = new CreateDomainRequest() { Name = "test-domain.co.uk" }; var ops = new DomainOperations <Domain>(_client); await ops.CreateDomainAsync(req); await _client.Received().PostAsync("/ddosx/v1/domains", req); }
internal CreateDomainResponse CreateDomain(CreateDomainRequest request) { var task = CreateDomainAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
private async Task createDomain(string domainName) { _logger.LogDebug($"Creating domain {domainName}"); var client = GetClient(); CreateDomainRequest request = new CreateDomainRequest(domainName); CreateDomainResponse response = await client.CreateDomainAsync(request); _logger.LogDebug("createDomain returned"); _logger.LogDebug(response.ToString()); }
public override void Initialize(string name, NameValueCollection config) { // // Initialize values from web.config. // if (config == null) { throw new ArgumentNullException("config"); } if (name == null || name.Length == 0) { name = "SDBRoleProvider"; } if (String.IsNullOrEmpty(config["description"])) { config.Remove("description"); config.Add("description", "Amazon Simple DB Role provider"); } // Initialize the abstract base class. base.Initialize(name, config); accessKey = GetConfigValue(config["accessKey"], ""); secretKey = GetConfigValue(config["secretKey"], ""); domain = GetConfigValue(config["domain"], "Roles"); if (config["writeExceptionsToEventLog"] != null) { if (config["writeExceptionsToEventLog"].ToUpper() == "TRUE") { pWriteExceptionsToEventLog = true; } } // // Initialize the SimpleDB Client. // client = new AmazonSimpleDBClient(accessKey, secretKey); // Make sure the domain for users exists CreateDomainRequest cdRequest = new CreateDomainRequest(); cdRequest.DomainName = domain; client.CreateDomain(cdRequest); }
/// <summary> /// 通过域名端口添加监控 /// </summary> /// <param name="req"><see cref="CreateDomainRequest"/></param> /// <returns><see cref="CreateDomainResponse"/></returns> public CreateDomainResponse CreateDomainSync(CreateDomainRequest req) { JsonResponseModel <CreateDomainResponse> rsp = null; try { var strResp = this.InternalRequestSync(req, "CreateDomain"); rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateDomainResponse> >(strResp); } catch (JsonSerializationException e) { throw new TencentCloudSDKException(e.Message); } return(rsp.Response); }
static void WriteToSimpleDb(AWSCredentials credentials) { var client = new AmazonSimpleDBClient(credentials, RegionEndpoint.USEast1); var request = new CreateDomainRequest("aws-talk"); var response = client.CreateDomain(request); var putData = new PutAttributesRequest("aws-talk", "products/" + Guid.NewGuid().ToString(), new List <ReplaceableAttribute>() { new ReplaceableAttribute("Name", "Couch", true), new ReplaceableAttribute("Price", "20", true) }); client.PutAttributes(putData); }
/// <remarks/> public void CreateDomainAsync(CreateDomainRequest CreateDomainRequest) { this.CreateDomainAsync(CreateDomainRequest, null); }
/// <remarks/> public void CreateDomainAsync(CreateDomainRequest CreateDomainRequest, object userState) { if ((this.CreateDomainOperationCompleted == null)) { this.CreateDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateDomainOperationCompleted); } this.InvokeAsync("CreateDomain", new object[] { CreateDomainRequest}, this.CreateDomainOperationCompleted, userState); }