Add support to roll back an In_Progress ECS Service Deployment

Add support for custom instance type for reserved capacity fleets
Documentation-only update for CreateView option correction

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.552
+1.11.553

generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/model/ComputeConfiguration.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/codebuild/CodeBuild_EXPORTS.h>
 #include <aws/codebuild/model/MachineType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
 #include <utility>
 
 namespace Aws
@@ -26,7 +27,8 @@ namespace Model
   /**
    * <p>Contains compute attributes. These attributes only need be specified when
    * your project's or fleet's <code>computeType</code> is set to
-   * <code>ATTRIBUTE_BASED_COMPUTE</code>.</p><p><h3>See Also:</h3>   <a
+   * <code>ATTRIBUTE_BASED_COMPUTE</code> or
+   * <code>CUSTOM_INSTANCE_TYPE</code>.</p><p><h3>See Also:</h3>   <a
    * href="http://docs.aws.amazon.com/goto/WebAPI/codebuild-2016-10-06/ComputeConfiguration">AWS
    * API Reference</a></p>
    */
@@ -78,6 +80,18 @@ namespace Model
     inline void SetMachineType(MachineType value) { m_machineTypeHasBeenSet = true; m_machineType = value; }
     inline ComputeConfiguration& WithMachineType(MachineType value) { SetMachineType(value); return *this;}
     ///@}
+
+    ///@{
+    /**
+     * <p>The EC2 instance type to be launched in your fleet.</p>
+     */
+    inline const Aws::String& GetInstanceType() const { return m_instanceType; }
+    inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
+    template<typename InstanceTypeT = Aws::String>
+    void SetInstanceType(InstanceTypeT&& value) { m_instanceTypeHasBeenSet = true; m_instanceType = std::forward<InstanceTypeT>(value); }
+    template<typename InstanceTypeT = Aws::String>
+    ComputeConfiguration& WithInstanceType(InstanceTypeT&& value) { SetInstanceType(std::forward<InstanceTypeT>(value)); return *this;}
+    ///@}
   private:
 
     long long m_vCpu{0};
@@ -91,6 +105,9 @@ namespace Model
 
     MachineType m_machineType{MachineType::NOT_SET};
     bool m_machineTypeHasBeenSet = false;
+
+    Aws::String m_instanceType;
+    bool m_instanceTypeHasBeenSet = false;
   };
 
 } // namespace Model

generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/model/ComputeType.h

@@ -26,7 +26,8 @@ namespace Model
     BUILD_LAMBDA_4GB,
     BUILD_LAMBDA_8GB,
     BUILD_LAMBDA_10GB,
-    ATTRIBUTE_BASED_COMPUTE
+    ATTRIBUTE_BASED_COMPUTE,
+    CUSTOM_INSTANCE_TYPE
   };
 
 namespace ComputeTypeMapper

generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/model/Fleet.h

@@ -138,11 +138,11 @@ namespace Model
      * type <code>ARM_CONTAINER</code> is available only in regions US East (N.
      * Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific
      * (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney),
-     * EU (Frankfurt), and South America (S��o Paulo).</p> </li> <li> <p>The
-     * environment type <code>ARM_EC2</code> is available only in regions US East (N.
-     * Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia
-     * Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America
-     * (São Paulo), and Asia Pacific (Mumbai).</p> </li> <li> <p>The environment type
+     * EU (Frankfurt), and South America (São Paulo).</p> </li> <li> <p>The environment
+     * type <code>ARM_EC2</code> is available only in regions US East (N. Virginia), US
+     * East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
+     * (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São
+     * Paulo), and Asia Pacific (Mumbai).</p> </li> <li> <p>The environment type
      * <code>LINUX_CONTAINER</code> is available only in regions US East (N. Virginia),
      * US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
      * (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São

generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/model/ScopeConfiguration.h

@@ -68,7 +68,8 @@ namespace Model
 
     ///@{
     /**
-     * <p>The type of scope for a GitHub or GitLab webhook.</p>
+     * <p>The type of scope for a GitHub or GitLab webhook. The scope default is
+     * GITHUB_ORGANIZATION.</p>
      */
     inline WebhookScopeType GetScope() const { return m_scope; }
     inline bool ScopeHasBeenSet() const { return m_scopeHasBeenSet; }

generated/src/aws-cpp-sdk-codebuild/source/model/ComputeConfiguration.cpp

@@ -45,6 +45,11 @@ ComputeConfiguration& ComputeConfiguration::operator =(JsonView jsonValue)
     m_machineType = MachineTypeMapper::GetMachineTypeForName(jsonValue.GetString("machineType"));
     m_machineTypeHasBeenSet = true;
   }
+  if(jsonValue.ValueExists("instanceType"))
+  {
+    m_instanceType = jsonValue.GetString("instanceType");
+    m_instanceTypeHasBeenSet = true;
+  }
   return *this;
 }
 
@@ -75,6 +80,12 @@ JsonValue ComputeConfiguration::Jsonize() const
    payload.WithString("machineType", MachineTypeMapper::GetNameForMachineType(m_machineType));
   }
 
+  if(m_instanceTypeHasBeenSet)
+  {
+   payload.WithString("instanceType", m_instanceType);
+
+  }
+
   return payload;
 }
 

generated/src/aws-cpp-sdk-codebuild/source/model/ComputeType.cpp

@@ -31,6 +31,7 @@ namespace Aws
         static const int BUILD_LAMBDA_8GB_HASH = HashingUtils::HashString("BUILD_LAMBDA_8GB");
         static const int BUILD_LAMBDA_10GB_HASH = HashingUtils::HashString("BUILD_LAMBDA_10GB");
         static const int ATTRIBUTE_BASED_COMPUTE_HASH = HashingUtils::HashString("ATTRIBUTE_BASED_COMPUTE");
+        static const int CUSTOM_INSTANCE_TYPE_HASH = HashingUtils::HashString("CUSTOM_INSTANCE_TYPE");
 
 
         ComputeType GetComputeTypeForName(const Aws::String& name)
@@ -80,6 +81,10 @@ namespace Aws
           {
             return ComputeType::ATTRIBUTE_BASED_COMPUTE;
           }
+          else if (hashCode == CUSTOM_INSTANCE_TYPE_HASH)
+          {
+            return ComputeType::CUSTOM_INSTANCE_TYPE;
+          }
           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
           if(overflowContainer)
           {
@@ -118,6 +123,8 @@ namespace Aws
             return "BUILD_LAMBDA_10GB";
           case ComputeType::ATTRIBUTE_BASED_COMPUTE:
             return "ATTRIBUTE_BASED_COMPUTE";
+          case ComputeType::CUSTOM_INSTANCE_TYPE:
+            return "CUSTOM_INSTANCE_TYPE";
           default:
             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
             if(overflowContainer)

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSClient.h

@@ -1604,6 +1604,38 @@ namespace ECS
             return SubmitAsync(&ECSClient::StartTask, request, handler, context);
         }
 
+        /**
+         * <p>Stops an ongoing service deployment.</p> <p>The following stop types are
+         * avaiable:</p> <ul> <li> <p>ROLLBACK - This option rolls back the service
+         * deployment to the previous service revision. </p> <p>You can use this option
+         * even if you didn't configure the service deployment for the rollback option.
+         * </p> </li> </ul> <p>For more information, see <a
+         * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/stop-service-deployment.html">Stopping
+         * Amazon ECS service deployments</a> in the <i>Amazon Elastic Container Service
+         * Developer Guide</i>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StopServiceDeployment">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::StopServiceDeploymentOutcome StopServiceDeployment(const Model::StopServiceDeploymentRequest& request) const;
+
+        /**
+         * A Callable wrapper for StopServiceDeployment that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename StopServiceDeploymentRequestT = Model::StopServiceDeploymentRequest>
+        Model::StopServiceDeploymentOutcomeCallable StopServiceDeploymentCallable(const StopServiceDeploymentRequestT& request) const
+        {
+            return SubmitCallable(&ECSClient::StopServiceDeployment, request);
+        }
+
+        /**
+         * An Async wrapper for StopServiceDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename StopServiceDeploymentRequestT = Model::StopServiceDeploymentRequest>
+        void StopServiceDeploymentAsync(const StopServiceDeploymentRequestT& request, const StopServiceDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&ECSClient::StopServiceDeployment, request, handler, context);
+        }
+
         /**
          * <p>Stops a running task. Any tags associated with the task will be deleted.</p>
          * <p>When you call <code>StopTask</code> on a task, the equivalent of <code>docker

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSErrors.h

@@ -64,6 +64,7 @@ enum class ECSErrors
   PLATFORM_UNKNOWN,
   RESOURCE_IN_USE,
   SERVER,
+  SERVICE_DEPLOYMENT_NOT_FOUND,
   SERVICE_NOT_ACTIVE,
   SERVICE_NOT_FOUND,
   TARGET_NOT_CONNECTED,

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSServiceClientModel.h

@@ -62,6 +62,7 @@
 #include <aws/ecs/model/RegisterTaskDefinitionResult.h>
 #include <aws/ecs/model/RunTaskResult.h>
 #include <aws/ecs/model/StartTaskResult.h>
+#include <aws/ecs/model/StopServiceDeploymentResult.h>
 #include <aws/ecs/model/StopTaskResult.h>
 #include <aws/ecs/model/SubmitAttachmentStateChangesResult.h>
 #include <aws/ecs/model/SubmitContainerStateChangeResult.h>
@@ -175,6 +176,7 @@ namespace Aws
       class RegisterTaskDefinitionRequest;
       class RunTaskRequest;
       class StartTaskRequest;
+      class StopServiceDeploymentRequest;
       class StopTaskRequest;
       class SubmitAttachmentStateChangesRequest;
       class SubmitContainerStateChangeRequest;
@@ -237,6 +239,7 @@ namespace Aws
       typedef Aws::Utils::Outcome<RegisterTaskDefinitionResult, ECSError> RegisterTaskDefinitionOutcome;
       typedef Aws::Utils::Outcome<RunTaskResult, ECSError> RunTaskOutcome;
       typedef Aws::Utils::Outcome<StartTaskResult, ECSError> StartTaskOutcome;
+      typedef Aws::Utils::Outcome<StopServiceDeploymentResult, ECSError> StopServiceDeploymentOutcome;
       typedef Aws::Utils::Outcome<StopTaskResult, ECSError> StopTaskOutcome;
       typedef Aws::Utils::Outcome<SubmitAttachmentStateChangesResult, ECSError> SubmitAttachmentStateChangesOutcome;
       typedef Aws::Utils::Outcome<SubmitContainerStateChangeResult, ECSError> SubmitContainerStateChangeOutcome;
@@ -299,6 +302,7 @@ namespace Aws
       typedef std::future<RegisterTaskDefinitionOutcome> RegisterTaskDefinitionOutcomeCallable;
       typedef std::future<RunTaskOutcome> RunTaskOutcomeCallable;
       typedef std::future<StartTaskOutcome> StartTaskOutcomeCallable;
+      typedef std::future<StopServiceDeploymentOutcome> StopServiceDeploymentOutcomeCallable;
       typedef std::future<StopTaskOutcome> StopTaskOutcomeCallable;
       typedef std::future<SubmitAttachmentStateChangesOutcome> SubmitAttachmentStateChangesOutcomeCallable;
       typedef std::future<SubmitContainerStateChangeOutcome> SubmitContainerStateChangeOutcomeCallable;
@@ -364,6 +368,7 @@ namespace Aws
     typedef std::function<void(const ECSClient*, const Model::RegisterTaskDefinitionRequest&, const Model::RegisterTaskDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterTaskDefinitionResponseReceivedHandler;
     typedef std::function<void(const ECSClient*, const Model::RunTaskRequest&, const Model::RunTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RunTaskResponseReceivedHandler;
     typedef std::function<void(const ECSClient*, const Model::StartTaskRequest&, const Model::StartTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartTaskResponseReceivedHandler;
+    typedef std::function<void(const ECSClient*, const Model::StopServiceDeploymentRequest&, const Model::StopServiceDeploymentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopServiceDeploymentResponseReceivedHandler;
     typedef std::function<void(const ECSClient*, const Model::StopTaskRequest&, const Model::StopTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopTaskResponseReceivedHandler;
     typedef std::function<void(const ECSClient*, const Model::SubmitAttachmentStateChangesRequest&, const Model::SubmitAttachmentStateChangesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubmitAttachmentStateChangesResponseReceivedHandler;
     typedef std::function<void(const ECSClient*, const Model::SubmitContainerStateChangeRequest&, const Model::SubmitContainerStateChangeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubmitContainerStateChangeResponseReceivedHandler;

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/model/RunTaskRequest.h

@@ -70,6 +70,8 @@ namespace Model
     /**
      * <p>The short name or full Amazon Resource Name (ARN) of the cluster to run your
      * task on. If you do not specify a cluster, the default cluster is assumed.</p>
+     * <p>Each account receives a default cluster the first time you use the service,
+     * but you may also create other clusters.</p>
      */
     inline const Aws::String& GetCluster() const { return m_cluster; }
     inline bool ClusterHasBeenSet() const { return m_clusterHasBeenSet; }

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/model/ServiceDeploymentStatus.h

@@ -21,6 +21,7 @@ namespace Model
     STOPPED,
     STOP_REQUESTED,
     IN_PROGRESS,
+    ROLLBACK_REQUESTED,
     ROLLBACK_IN_PROGRESS,
     ROLLBACK_SUCCESSFUL,
     ROLLBACK_FAILED

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/model/StopServiceDeploymentRequest.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ecs/ECS_EXPORTS.h>
+#include <aws/ecs/ECSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ecs/model/StopServiceDeploymentStopType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace ECS
+{
+namespace Model
+{
+
+  /**
+   */
+  class StopServiceDeploymentRequest : public ECSRequest
+  {
+  public:
+    AWS_ECS_API StopServiceDeploymentRequest() = default;
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "StopServiceDeployment"; }
+
+    AWS_ECS_API Aws::String SerializePayload() const override;
+
+    AWS_ECS_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    ///@{
+    /**
+     * <p>The ARN of the service deployment that you want to stop.</p>
+     */
+    inline const Aws::String& GetServiceDeploymentArn() const { return m_serviceDeploymentArn; }
+    inline bool ServiceDeploymentArnHasBeenSet() const { return m_serviceDeploymentArnHasBeenSet; }
+    template<typename ServiceDeploymentArnT = Aws::String>
+    void SetServiceDeploymentArn(ServiceDeploymentArnT&& value) { m_serviceDeploymentArnHasBeenSet = true; m_serviceDeploymentArn = std::forward<ServiceDeploymentArnT>(value); }
+    template<typename ServiceDeploymentArnT = Aws::String>
+    StopServiceDeploymentRequest& WithServiceDeploymentArn(ServiceDeploymentArnT&& value) { SetServiceDeploymentArn(std::forward<ServiceDeploymentArnT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>How you want Amazon ECS to stop the task. </p> <p>The valid values are
+     * <code>ROLLBACK</code>.</p>
+     */
+    inline StopServiceDeploymentStopType GetStopType() const { return m_stopType; }
+    inline bool StopTypeHasBeenSet() const { return m_stopTypeHasBeenSet; }
+    inline void SetStopType(StopServiceDeploymentStopType value) { m_stopTypeHasBeenSet = true; m_stopType = value; }
+    inline StopServiceDeploymentRequest& WithStopType(StopServiceDeploymentStopType value) { SetStopType(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_serviceDeploymentArn;
+    bool m_serviceDeploymentArnHasBeenSet = false;
+
+    StopServiceDeploymentStopType m_stopType{StopServiceDeploymentStopType::NOT_SET};
+    bool m_stopTypeHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace ECS
+} // namespace Aws

generated/src/aws-cpp-sdk-ecs/include/aws/ecs/model/StopServiceDeploymentResult.h

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ecs/ECS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ECS
+{
+namespace Model
+{
+  class StopServiceDeploymentResult
+  {
+  public:
+    AWS_ECS_API StopServiceDeploymentResult() = default;
+    AWS_ECS_API StopServiceDeploymentResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    AWS_ECS_API StopServiceDeploymentResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    ///@{
+    /**
+     * <p>The ARN of the stopped service deployment.</p>
+     */
+    inline const Aws::String& GetServiceDeploymentArn() const { return m_serviceDeploymentArn; }
+    template<typename ServiceDeploymentArnT = Aws::String>
+    void SetServiceDeploymentArn(ServiceDeploymentArnT&& value) { m_serviceDeploymentArnHasBeenSet = true; m_serviceDeploymentArn = std::forward<ServiceDeploymentArnT>(value); }
+    template<typename ServiceDeploymentArnT = Aws::String>
+    StopServiceDeploymentResult& WithServiceDeploymentArn(ServiceDeploymentArnT&& value) { SetServiceDeploymentArn(std::forward<ServiceDeploymentArnT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const { return m_requestId; }
+    template<typename RequestIdT = Aws::String>
+    void SetRequestId(RequestIdT&& value) { m_requestIdHasBeenSet = true; m_requestId = std::forward<RequestIdT>(value); }
+    template<typename RequestIdT = Aws::String>
+    StopServiceDeploymentResult& WithRequestId(RequestIdT&& value) { SetRequestId(std::forward<RequestIdT>(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_serviceDeploymentArn;
+    bool m_serviceDeploymentArnHasBeenSet = false;
+
+    Aws::String m_requestId;
+    bool m_requestIdHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace ECS
+} // namespace Aws