awsim-ecs 0.3.0

AWS ECS emulator for AWSim
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use awsim_core::{AccountRegionStore, AwsError, Protocol, RequestContext, ServiceHandler};
use serde_json::Value;
use tracing::debug;

use crate::operations::{clusters, container_instances, extras, services, task_definitions, tasks};
use crate::state::EcsState;

/// The ECS service handler.
pub struct EcsService {
    store: AccountRegionStore<EcsState>,
}

impl EcsService {
    pub fn new() -> Self {
        Self {
            store: AccountRegionStore::new(),
        }
    }
}

impl Default for EcsService {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait::async_trait]
impl ServiceHandler for EcsService {
    fn service_name(&self) -> &str {
        "ecs"
    }

    fn signing_name(&self) -> &str {
        "ecs"
    }

    fn protocol(&self) -> Protocol {
        Protocol::AwsJson1_1
    }

    async fn handle(
        &self,
        operation: &str,
        input: Value,
        ctx: &RequestContext,
    ) -> Result<Value, AwsError> {
        debug!(operation = %operation, "ECS operation");

        let state = self.store.get(&ctx.account_id, &ctx.region);

        match operation {
            // Clusters
            "CreateCluster" => clusters::create_cluster(&state, &input, ctx),
            "DeleteCluster" => clusters::delete_cluster(&state, &input, ctx),
            "DescribeClusters" => clusters::describe_clusters(&state, &input, ctx),
            "ListClusters" => clusters::list_clusters(&state, &input, ctx),

            // Task Definitions
            "RegisterTaskDefinition" => {
                task_definitions::register_task_definition(&state, &input, ctx)
            }
            "DeregisterTaskDefinition" => {
                task_definitions::deregister_task_definition(&state, &input, ctx)
            }
            "DescribeTaskDefinition" => {
                task_definitions::describe_task_definition(&state, &input, ctx)
            }
            "ListTaskDefinitions" => task_definitions::list_task_definitions(&state, &input, ctx),
            "ListTaskDefinitionFamilies" => {
                task_definitions::list_task_definition_families(&state, &input, ctx)
            }

            // Services
            "CreateService" => services::create_service(&state, &input, ctx),
            "DeleteService" => services::delete_service(&state, &input, ctx),
            "DescribeServices" => services::describe_services(&state, &input, ctx),
            "ListServices" => services::list_services(&state, &input, ctx),
            "UpdateService" => services::update_service(&state, &input, ctx),

            // Tasks
            "RunTask" => tasks::run_task(&state, &input, ctx),
            "StopTask" => tasks::stop_task(&state, &input, ctx),
            "DescribeTasks" => tasks::describe_tasks(&state, &input, ctx),
            "ListTasks" => tasks::list_tasks(&state, &input, ctx),

            // Tagging
            "TagResource" => extras::tag_resource(&state, &input, ctx),
            "UntagResource" => extras::untag_resource(&state, &input, ctx),
            "ListTagsForResource" => extras::list_tags_for_resource(&state, &input, ctx),

            // Capacity Providers
            "PutClusterCapacityProviders" => {
                extras::put_cluster_capacity_providers(&state, &input, ctx)
            }
            "DescribeCapacityProviders" => extras::describe_capacity_providers(&state, &input, ctx),

            // Account Settings
            "PutAccountSetting" => extras::put_account_setting(&state, &input, ctx),
            "PutAccountSettingDefault" => extras::put_account_setting(&state, &input, ctx),
            "ListAccountSettings" => extras::list_account_settings(&state, &input, ctx),

            // Container agent
            "DiscoverPollEndpoint" => extras::discover_poll_endpoint(&state, &input, ctx),
            "UpdateContainerAgent" => extras::update_container_agent(&state, &input, ctx),

            // Container Instances + Attributes
            "DescribeContainerInstances" => {
                container_instances::describe_container_instances(&state, &input, ctx)
            }
            "ListContainerInstances" => {
                container_instances::list_container_instances(&state, &input, ctx)
            }
            "ListAttributes" => container_instances::list_attributes(&state, &input, ctx),
            "PutAttributes" => container_instances::put_attributes(&state, &input, ctx),
            "DeleteAttributes" => container_instances::delete_attributes(&state, &input, ctx),
            "ListServicesByNamespace" => {
                container_instances::list_services_by_namespace(&state, &input, ctx)
            }

            _ => Err(AwsError::unknown_operation(operation)),
        }
    }
}