community.general/plugins/modules/spotinst_aws_elastigroup.py

#!/usr/bin/python
# Copyright (c) 2017 Ansible Project
# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
# SPDX-License-Identifier: GPL-3.0-or-later
from __future__ import annotations

DOCUMENTATION = r"""
module: spotinst_aws_elastigroup
short_description: Create, update or delete Spotinst AWS Elastigroups
author: Spotinst (@talzur)
description:
  - Can create, update, or delete Spotinst AWS Elastigroups Launch configuration is part of the elastigroup configuration,
    so no additional modules are necessary for handling the launch configuration. You must have a credentials file in this
    location - C($HOME/.spotinst/credentials). The credentials file must contain a row that looks like this C(token = <YOUR
    TOKEN>).
  - Full documentation available at U(https://help.spotinst.com/hc/en-us/articles/115003530285-Ansible-).
requirements:
  - spotinst_sdk >= 1.0.38
extends_documentation_fragment:
  - community.general.attributes
attributes:
  check_mode:
    support: none
  diff_mode:
    support: none
options:

  credentials_path:
    description:
      - Optional parameter that allows to set a non-default credentials path.
    default: ~/.spotinst/credentials
    type: path

  account_id:
    description:
      - Optional parameter that allows to set an account-id inside the module configuration.
      - By default this is retrieved from the credentials path.
    type: str

  token:
    description:
      - A Personal API Access Token issued by Spotinst.
      - When not specified, the module tries to obtain it, in that order, from environment variable E(SPOTINST_TOKEN), or
        from the credentials path.
    type: str

  availability_vs_cost:
    description:
      - The strategy orientation.
      - 'The choices available are: V(availabilityOriented), V(costOriented), V(balanced).'
    required: true
    type: str

  availability_zones:
    description:
      - A list of hash/dictionaries of Availability Zones that are configured in the elastigroup; '[{"key":"value", "key":"value"}]';
        keys allowed are name (String), subnet_id (String), placement_group_name (String),.
    required: true
    type: list
    elements: dict

  block_device_mappings:
    description:
      - A list of hash/dictionaries of Block Device Mappings for elastigroup instances; You can specify virtual devices and
        EBS volumes.; '[{"key":"value", "key":"value"}]'; keys allowed are device_name (List of Strings), virtual_name (String),
        no_device (String), ebs (Object, expects the following keys- delete_on_termination(Boolean), encrypted(Boolean), iops
        (Integer), snapshot_id(Integer), volume_type(String), volume_size(Integer)).
    type: list
    elements: dict

  chef:
    description:
      - The Chef integration configuration.; Expects the following keys - chef_server (String), organization (String), user
        (String), pem_key (String), chef_version (String).
    type: dict

  draining_timeout:
    description:
      - Time for instance to be drained from incoming requests and deregistered from ELB before termination.
    type: int

  ebs_optimized:
    description:
      - Enable EBS optimization for supported instances which are not enabled by default. Note - additional charges are applied.
    type: bool

  ebs_volume_pool:
    description:
      - A list of hash/dictionaries of EBS devices to reattach to the elastigroup when available; '[{"key":"value", "key":"value"}]';
        keys allowed are - volume_ids (List of Strings), device_name (String).
    type: list
    elements: dict

  ecs:
    description:
      - The ECS integration configuration.; Expects the following key - cluster_name (String).
    type: dict

  elastic_ips:
    description:
      - List of ElasticIps Allocation IDs (example V(eipalloc-9d4e16f8)) to associate to the group instances.
    type: list
    elements: str

  fallback_to_od:
    description:
      - In case of no spots available, Elastigroup launches an On-demand instance instead.
    type: bool

  health_check_grace_period:
    description:
      - The amount of time, in seconds, after the instance has launched to start and check its health.
      - If not specified, it defaults to V(300).
    type: int

  health_check_unhealthy_duration_before_replacement:
    description:
      - Minimal mount of time instance should be unhealthy for us to consider it unhealthy.
    type: int

  health_check_type:
    description:
      - The service to use for the health check.
      - 'The choices available are: V(ELB), V(HCS), V(TARGET_GROUP), V(MLB), V(EC2).'
    type: str

  iam_role_name:
    description:
      - The instance profile iamRole name.
      - Only use O(iam_role_arn) or O(iam_role_name).
    type: str

  iam_role_arn:
    description:
      - The instance profile iamRole arn.
      - Only use O(iam_role_arn) or O(iam_role_name).
    type: str

  id:
    description:
      - The group ID if it already exists and you want to update, or delete it. This does not work unless the O(uniqueness_by)
        field is set to ID. When this is set, and the O(uniqueness_by) field is set, the group is either updated or deleted,
        but not created.
    type: str

  image_id:
    description:
      - The image ID used to launch the instance.; In case of conflict between Instance type and image type, an error is be
        returned.
    required: true
    type: str

  key_pair:
    description:
      - Specify a Key Pair to attach to the instances.
    type: str

  kubernetes:
    description:
      - The Kubernetes integration configuration. Expects the following keys - api_server (String), token (String).
    type: dict

  lifetime_period:
    description:
      - Lifetime period.
    type: int

  load_balancers:
    description:
      - List of classic ELB names.
    type: list
    elements: str

  max_size:
    description:
      - The upper limit number of instances that you can scale up to.
    required: true
    type: int

  mesosphere:
    description:
      - The Mesosphere integration configuration. Expects the following key - api_server (String).
    type: dict

  min_size:
    description:
      - The lower limit number of instances that you can scale down to.
    required: true
    type: int

  monitoring:
    description:
      - Describes whether instance Enhanced Monitoring is enabled.
    type: str

  name:
    description:
      - Unique name for elastigroup to be created, updated or deleted.
    required: true
    type: str

  network_interfaces:
    description:
      - A list of hash/dictionaries of network interfaces to add to the elastigroup; '[{"key":"value", "key":"value"}]'; keys
        allowed are - description (String), device_index (Integer), secondary_private_ip_address_count (Integer), associate_public_ip_address
        (Boolean), delete_on_termination (Boolean), groups (List of Strings), network_interface_id (String), private_ip_address
        (String), subnet_id (String), associate_ipv6_address (Boolean), private_ip_addresses (List of Objects, Keys are privateIpAddress
        (String, required) and primary (Boolean)).
    type: list
    elements: dict

  on_demand_count:
    description:
      - Required if risk is not set.
      - Number of on demand instances to launch. All other instances are spot instances.; Either set this parameter or the
        O(risk) parameter.
    type: int

  on_demand_instance_type:
    description:
      - On-demand instance type that is provisioned.
    type: str

  opsworks:
    description:
      - The elastigroup OpsWorks integration configuration.; Expects the following key - layer_id (String).
    type: dict

  persistence:
    description:
      - The Stateful elastigroup configuration.; Accepts the following keys - should_persist_root_device (Boolean), should_persist_block_devices
        (Boolean), should_persist_private_ip (Boolean).
    type: dict

  product:
    description:
      - Operation system type.
      - 'Available choices are: V(Linux/UNIX), V(SUSE Linux), V(Windows), V(Linux/UNIX (Amazon VPC)), V(SUSE Linux (Amazon
        VPC)).'
    required: true
    type: str

  rancher:
    description:
      - The Rancher integration configuration.; Expects the following keys - version (String), access_key (String), secret_key
        (String), master_host (String).
    type: dict

  right_scale:
    description:
      - The Rightscale integration configuration.; Expects the following keys - account_id (String), refresh_token (String).
    type: dict

  risk:
    description:
      - Required if on demand is not set. The percentage of Spot instances to launch (0 - 100).
    type: int

  roll_config:
    description:
      - Roll configuration.
      - If you would like the group to roll after updating, please use this feature.
      - Accepts the following keys - batch_size_percentage(Integer, Required), grace_period - (Integer, Required), health_check_type(String,
        Optional).
    type: dict

  scheduled_tasks:
    description:
      - A list of hash/dictionaries of scheduled tasks to configure in the elastigroup, as in V([{"key":"value", "key":"value"}]).
      - 'Keys allowed are: adjustment (Integer), scale_target_capacity (Integer), scale_min_capacity (Integer), scale_max_capacity
        (Integer), adjustment_percentage (Integer), batch_size_percentage (Integer), cron_expression (String), frequency (String),
        grace_period (Integer), task_type (String, required), is_enabled (Boolean).'
    type: list
    elements: dict

  security_group_ids:
    description:
      - One or more security group IDs.
      - In case of update it overrides the existing Security Group with the new given array.
    required: true
    type: list
    elements: str

  shutdown_script:
    description:
      - The Base64-encoded shutdown script that executes prior to instance termination. Encode before setting.
    type: str

  signals:
    description:
      - A list of hash/dictionaries of signals to configure in the elastigroup; keys allowed are - name (String, required),
        timeout (Integer).
    type: list
    elements: dict

  spin_up_time:
    description:
      - Spin up time, in seconds, for the instance.
    type: int

  spot_instance_types:
    description:
      - Spot instance type that is provisioned.
    required: true
    type: list
    elements: str

  state:
    choices:
      - present
      - absent
    description:
      - Create or delete the elastigroup.
    default: present
    type: str

  tags:
    description:
      - A list of tags to configure in the elastigroup. Please specify list of keys and values (key colon value).
    type: list
    elements: dict

  target:
    description:
      - The number of instances to launch.
    required: true
    type: int

  target_group_arns:
    description:
      - List of target group arns instances should be registered to.
    type: list
    elements: str

  tenancy:
    description:
      - Dedicated or shared tenancy.
      - 'The available choices are: V(default), V(dedicated).'
    type: str

  terminate_at_end_of_billing_hour:
    description:
      - Terminate at the end of billing hour.
    type: bool

  unit:
    description:
      - The capacity unit to launch instances by.
      - 'The available choices are: V(instance), V(weight).'
    type: str

  up_scaling_policies:
    description:
      - A list of hash/dictionaries of scaling policies to configure in the elastigroup; '[{"key":"value", "key":"value"}]';
        keys allowed are - policy_name (String, required), namespace (String, required), metric_name (String, required), dimensions
        (List of Objects, Keys allowed are name (String, required) and value (String)), statistic (String, required) evaluation_periods
        (String, required), period (String, required), threshold (String, required), cooldown (String, required), unit (String,
        required), operator (String, required), action_type (String, required), adjustment (String), min_target_capacity (String),
        target (String), maximum (String), minimum (String).
    type: list
    elements: dict

  down_scaling_policies:
    description:
      - A list of hash/dictionaries of scaling policies to configure in the elastigroup; '[{"key":"value", "key":"value"}]';
        keys allowed are - policy_name (String, required), namespace (String, required), metric_name (String, required), dimensions
        ((List of Objects), Keys allowed are name (String, required) and value (String)), statistic (String, required), evaluation_periods
        (String, required), period (String, required), threshold (String, required), cooldown (String, required), unit (String,
        required), operator (String, required), action_type (String, required), adjustment (String), max_target_capacity (String),
        target (String), maximum (String), minimum (String).
    type: list
    elements: dict

  target_tracking_policies:
    description:
      - A list of hash/dictionaries of target tracking policies to configure in the elastigroup; '[{"key":"value", "key":"value"}]';
        keys allowed are - policy_name (String, required), namespace (String, required), source (String, required), metric_name
        (String, required), statistic (String, required), unit (String, required), cooldown (String, required), target (String,
        required).
    type: list
    elements: dict

  uniqueness_by:
    choices:
      - id
      - name
    description:
      - If your group names are not unique, you may use this feature to update or delete a specific group. Whenever this property
        is set, you must set a group_id in order to update or delete a group, otherwise a group is created.
    default: name
    type: str

  user_data:
    description:
      - Base64-encoded MIME user data. Encode before setting the value.
    type: str

  utilize_reserved_instances:
    description:
      - In case of any available Reserved Instances, Elastigroup utilizes your reservations before purchasing Spot instances.
    type: bool

  wait_for_instances:
    description:
      - Whether or not the elastigroup creation / update actions should wait for the instances to spin.
    type: bool
    default: false

  wait_timeout:
    description:
      - How long the module should wait for instances before failing the action.
      - Only works if O(wait_for_instances=true).
    type: int

  do_not_update:
    description:
      - TODO document.
    type: list
    elements: str
    default: []

  multai_token:
    description:
      - Token used for Multai configuration.
    type: str

  multai_load_balancers:
    description:
      - Configuration parameters for Multai load balancers.
    type: list
    elements: dict

  elastic_beanstalk:
    description:
      - Placeholder parameter for future implementation of Elastic Beanstalk configurations.
    type: dict
"""
EXAMPLES = r"""
# Basic configuration YAML example

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        state: present
        risk: 100
        availability_vs_cost: balanced
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-2b68a15c
        image_id: ami-f173cc91
        key_pair: spotinst-oregon
        max_size: 15
        min_size: 0
        target: 0
        unit: instance
        monitoring: true
        name: ansible-group
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        load_balancers:
          - test-lb-1
        security_group_ids:
          - sg-8f4b8fe9
        spot_instance_types:
          - c3.large
        do_not_update:
          - image_id
          - target
      register: result
    - ansible.builtin.debug: var=result

# In this example, we create an elastigroup and wait 600 seconds to retrieve the instances, and use their private ips

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        state: present
        account_id: act-1a9dd2b
        risk: 100
        availability_vs_cost: balanced
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-2b68a15c
        tags:
          - Environment: someEnvValue
          - OtherTagKey: otherValue
        image_id: ami-f173cc91
        key_pair: spotinst-oregon
        max_size: 5
        min_size: 0
        target: 0
        unit: instance
        monitoring: true
        name: ansible-group-tal
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        security_group_ids:
          - sg-8f4b8fe9
        block_device_mappings:
          - device_name: '/dev/sda1'
            ebs:
              volume_size: 100
              volume_type: gp2
        spot_instance_types:
          - c3.large
        do_not_update:
          - image_id
        wait_for_instances: true
        wait_timeout: 600
      register: result

    - name: Store private ips to file
      ansible.builtin.shell: echo {{ item.private_ip }}\\n >> list-of-private-ips
      with_items: "{{ result.instances }}"
    - ansible.builtin.debug: var=result

# In this example, we create an elastigroup with multiple block device mappings, tags, and also an account id
# In organizations with more than one account, it is required to specify an account_id

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        state: present
        account_id: act-1a9dd2b
        risk: 100
        availability_vs_cost: balanced
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-2b68a15c
        tags:
          - Environment: someEnvValue
          - OtherTagKey: otherValue
        image_id: ami-f173cc91
        key_pair: spotinst-oregon
        max_size: 5
        min_size: 0
        target: 0
        unit: instance
        monitoring: true
        name: ansible-group-tal
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        security_group_ids:
          - sg-8f4b8fe9
        block_device_mappings:
          - device_name: '/dev/xvda'
            ebs:
              volume_size: 60
              volume_type: gp2
          - device_name: '/dev/xvdb'
            ebs:
              volume_size: 120
              volume_type: gp2
        spot_instance_types:
          - c3.large
        do_not_update:
          - image_id
        wait_for_instances: true
        wait_timeout: 600
      register: result

    - name: Store private ips to file
      ansible.builtin.shell: echo {{ item.private_ip }}\\n >> list-of-private-ips
      with_items: "{{ result.instances }}"
    - ansible.builtin.debug: var=result

# In this example we have set up block device mapping with ephemeral devices

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        state: present
        risk: 100
        availability_vs_cost: balanced
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-2b68a15c
        image_id: ami-f173cc91
        key_pair: spotinst-oregon
        max_size: 15
        min_size: 0
        target: 0
        unit: instance
        block_device_mappings:
          - device_name: '/dev/xvda'
            virtual_name: ephemeral0
          - device_name: '/dev/xvdb/'
            virtual_name: ephemeral1
        monitoring: true
        name: ansible-group
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        load_balancers:
          - test-lb-1
        security_group_ids:
          - sg-8f4b8fe9
        spot_instance_types:
          - c3.large
        do_not_update:
          - image_id
          - target
      register: result
    - ansible.builtin.debug: var=result

# In this example we create a basic group configuration with a network interface defined.
# Each network interface must have a device index

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        state: present
        risk: 100
        availability_vs_cost: balanced
        network_interfaces:
          - associate_public_ip_address: true
            device_index: 0
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-2b68a15c
        image_id: ami-f173cc91
        key_pair: spotinst-oregon
        max_size: 15
        min_size: 0
        target: 0
        unit: instance
        monitoring: true
        name: ansible-group
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        load_balancers:
          - test-lb-1
        security_group_ids:
          - sg-8f4b8fe9
        spot_instance_types:
          - c3.large
        do_not_update:
          - image_id
          - target
      register: result
    - ansible.builtin.debug: var=result


# In this example we create a basic group configuration with a target tracking scaling policy defined

- hosts: localhost
  tasks:
    - name: Create elastigroup
      community.general.spotinst_aws_elastigroup:
        account_id: act-92d45673
        state: present
        risk: 100
        availability_vs_cost: balanced
        availability_zones:
          - name: us-west-2a
            subnet_id: subnet-79da021e
        image_id: ami-f173cc91
        fallback_to_od: true
        tags:
          - Creator: ValueOfCreatorTag
          - Environment: ValueOfEnvironmentTag
        key_pair: spotinst-labs-oregon
        max_size: 10
        min_size: 0
        target: 2
        unit: instance
        monitoring: true
        name: ansible-group-1
        on_demand_instance_type: c3.large
        product: Linux/UNIX
        security_group_ids:
          - sg-46cdc13d
        spot_instance_types:
          - c3.large
        target_tracking_policies:
          - policy_name: target-tracking-1
            namespace: AWS/EC2
            metric_name: CPUUtilization
            statistic: average
            unit: percent
            target: 50
            cooldown: 120
        do_not_update:
          - image_id
      register: result
    - ansible.builtin.debug: var=result
"""

RETURN = r"""
instances:
  description: List of active elastigroup instances and their details.
  returned: success
  type: dict
  sample:
    - "spotInstanceRequestId": "sir-regs25zp"
      "instanceId": "i-09640ad8678234c"
      "instanceType": "m4.large"
      "product": "Linux/UNIX"
      "availabilityZone": "us-west-2b"
      "privateIp": "180.0.2.244"
      "createdAt": "2017-07-17T12:46:18.000Z"
      "status": "fulfilled"
group_id:
  description: Created / Updated group's ID.
  returned: success
  type: str
  sample: "sig-12345"
"""

HAS_SPOTINST_SDK = False

import os
import time
from ansible.module_utils.basic import AnsibleModule

try:
    import spotinst_sdk as spotinst
    from spotinst_sdk import SpotinstClientException

    HAS_SPOTINST_SDK = True

except ImportError:
    pass

eni_fields = (
    "description",
    "device_index",
    "secondary_private_ip_address_count",
    "associate_public_ip_address",
    "delete_on_termination",
    "groups",
    "network_interface_id",
    "private_ip_address",
    "subnet_id",
    "associate_ipv6_address",
)

private_ip_fields = ("private_ip_address", "primary")

capacity_fields = (
    dict(ansible_field_name="min_size", spotinst_field_name="minimum"),
    dict(ansible_field_name="max_size", spotinst_field_name="maximum"),
    "target",
    "unit",
)

lspec_fields = (
    "user_data",
    "key_pair",
    "tenancy",
    "shutdown_script",
    "monitoring",
    "ebs_optimized",
    "image_id",
    "health_check_type",
    "health_check_grace_period",
    "health_check_unhealthy_duration_before_replacement",
    "security_group_ids",
)

iam_fields = (
    dict(ansible_field_name="iam_role_name", spotinst_field_name="name"),
    dict(ansible_field_name="iam_role_arn", spotinst_field_name="arn"),
)

scheduled_task_fields = (
    "adjustment",
    "adjustment_percentage",
    "batch_size_percentage",
    "cron_expression",
    "frequency",
    "grace_period",
    "task_type",
    "is_enabled",
    "scale_target_capacity",
    "scale_min_capacity",
    "scale_max_capacity",
)

scaling_policy_fields = (
    "policy_name",
    "namespace",
    "metric_name",
    "dimensions",
    "statistic",
    "evaluation_periods",
    "period",
    "threshold",
    "cooldown",
    "unit",
    "operator",
)

tracking_policy_fields = (
    "policy_name",
    "namespace",
    "source",
    "metric_name",
    "statistic",
    "unit",
    "cooldown",
    "target",
    "threshold",
)

action_fields = (
    dict(ansible_field_name="action_type", spotinst_field_name="type"),
    "adjustment",
    "min_target_capacity",
    "max_target_capacity",
    "target",
    "minimum",
    "maximum",
)

signal_fields = ("name", "timeout")

multai_lb_fields = ("balancer_id", "project_id", "target_set_id", "az_awareness", "auto_weight")

persistence_fields = ("should_persist_root_device", "should_persist_block_devices", "should_persist_private_ip")

strategy_fields = (
    "risk",
    "utilize_reserved_instances",
    "fallback_to_od",
    "on_demand_count",
    "availability_vs_cost",
    "draining_timeout",
    "spin_up_time",
    "lifetime_period",
)

ebs_fields = ("delete_on_termination", "encrypted", "iops", "snapshot_id", "volume_type", "volume_size")

bdm_fields = ("device_name", "virtual_name", "no_device")

kubernetes_fields = ("api_server", "token")

right_scale_fields = ("account_id", "refresh_token")

rancher_fields = ("access_key", "secret_key", "master_host", "version")

chef_fields = ("chef_server", "organization", "user", "pem_key", "chef_version")

az_fields = ("name", "subnet_id", "placement_group_name")

opsworks_fields = ("layer_id",)

scaling_strategy_fields = ("terminate_at_end_of_billing_hour",)

mesosphere_fields = ("api_server",)

ecs_fields = ("cluster_name",)

multai_fields = ("multai_token",)


def handle_elastigroup(client, module):
    has_changed = False
    group_id = None
    message = "None"

    name = module.params.get("name")
    state = module.params.get("state")
    uniqueness_by = module.params.get("uniqueness_by")
    external_group_id = module.params.get("id")

    if uniqueness_by == "id":
        if external_group_id is None:
            should_create = True
        else:
            should_create = False
            group_id = external_group_id
    else:
        groups = client.get_elastigroups()
        should_create, group_id = find_group_with_same_name(groups, name)

    if should_create is True:
        if state == "present":
            eg = expand_elastigroup(module, is_update=False)
            module.debug(f" [INFO] {message}\n")
            group = client.create_elastigroup(group=eg)
            group_id = group["id"]
            message = "Created group Successfully."
            has_changed = True

        elif state == "absent":
            message = "Cannot delete non-existent group."
            has_changed = False
    else:
        eg = expand_elastigroup(module, is_update=True)

        if state == "present":
            group = client.update_elastigroup(group_update=eg, group_id=group_id)
            message = "Updated group successfully."

            try:
                roll_config = module.params.get("roll_config")
                if roll_config:
                    eg_roll = spotinst.aws_elastigroup.Roll(
                        batch_size_percentage=roll_config.get("batch_size_percentage"),
                        grace_period=roll_config.get("grace_period"),
                        health_check_type=roll_config.get("health_check_type"),
                    )
                    client.roll_group(group_roll=eg_roll, group_id=group_id)
                    message = "Updated and started rolling the group successfully."

            except SpotinstClientException as exc:
                message = f"Updated group successfully, but failed to perform roll. Error:{exc}"
            has_changed = True

        elif state == "absent":
            try:
                client.delete_elastigroup(group_id=group_id)
            except SpotinstClientException as exc:
                if "GROUP_DOESNT_EXIST" in exc.message:
                    pass
                else:
                    module.fail_json(msg=f"Error while attempting to delete group : {exc.message}")

            message = "Deleted group successfully."
            has_changed = True

    return group_id, message, has_changed


def retrieve_group_instances(client, module, group_id):
    wait_timeout = module.params.get("wait_timeout")
    wait_for_instances = module.params.get("wait_for_instances")

    health_check_type = module.params.get("health_check_type")

    if wait_timeout is None:
        wait_timeout = 300

    wait_timeout = time.time() + wait_timeout
    target = module.params.get("target")
    state = module.params.get("state")
    instances = list()

    if state == "present" and group_id is not None and wait_for_instances is True:
        is_amount_fulfilled = False
        while is_amount_fulfilled is False and wait_timeout > time.time():
            instances = list()
            amount_of_fulfilled_instances = 0

            if health_check_type is not None:
                healthy_instances = client.get_instance_healthiness(group_id=group_id)

                for healthy_instance in healthy_instances:
                    if healthy_instance.get("healthStatus") == "HEALTHY":
                        amount_of_fulfilled_instances += 1
                        instances.append(healthy_instance)

            else:
                active_instances = client.get_elastigroup_active_instances(group_id=group_id)

                for active_instance in active_instances:
                    if active_instance.get("private_ip") is not None:
                        amount_of_fulfilled_instances += 1
                        instances.append(active_instance)

            if amount_of_fulfilled_instances >= target:
                is_amount_fulfilled = True

            time.sleep(10)

    return instances


def find_group_with_same_name(groups, name):
    for group in groups:
        if group["name"] == name:
            return False, group.get("id")

    return True, None


def expand_elastigroup(module, is_update):
    do_not_update = module.params["do_not_update"]
    name = module.params.get("name")

    eg = spotinst.aws_elastigroup.Elastigroup()
    description = module.params.get("description")

    if name is not None:
        eg.name = name
    if description is not None:
        eg.description = description

    # Capacity
    expand_capacity(eg, module, is_update, do_not_update)
    # Strategy
    expand_strategy(eg, module)
    # Scaling
    expand_scaling(eg, module)
    # Third party integrations
    expand_integrations(eg, module)
    # Compute
    expand_compute(eg, module, is_update, do_not_update)
    # Multai
    expand_multai(eg, module)
    # Scheduling
    expand_scheduled_tasks(eg, module)

    return eg


def expand_compute(eg, module, is_update, do_not_update):
    elastic_ips = module.params["elastic_ips"]
    on_demand_instance_type = module.params.get("on_demand_instance_type")
    spot_instance_types = module.params["spot_instance_types"]
    ebs_volume_pool = module.params["ebs_volume_pool"]
    availability_zones_list = module.params["availability_zones"]
    product = module.params.get("product")

    eg_compute = spotinst.aws_elastigroup.Compute()

    if product is not None:
        # Only put product on group creation
        if is_update is not True:
            eg_compute.product = product

    if elastic_ips is not None:
        eg_compute.elastic_ips = elastic_ips

    if on_demand_instance_type or spot_instance_types is not None:
        eg_instance_types = spotinst.aws_elastigroup.InstanceTypes()

        if on_demand_instance_type is not None:
            eg_instance_types.spot = spot_instance_types
        if spot_instance_types is not None:
            eg_instance_types.ondemand = on_demand_instance_type

        if eg_instance_types.spot is not None or eg_instance_types.ondemand is not None:
            eg_compute.instance_types = eg_instance_types

    expand_ebs_volume_pool(eg_compute, ebs_volume_pool)

    eg_compute.availability_zones = expand_list(availability_zones_list, az_fields, "AvailabilityZone")

    expand_launch_spec(eg_compute, module, is_update, do_not_update)

    eg.compute = eg_compute


def expand_ebs_volume_pool(eg_compute, ebs_volumes_list):
    if ebs_volumes_list is not None:
        eg_volumes = []

        for volume in ebs_volumes_list:
            eg_volume = spotinst.aws_elastigroup.EbsVolume()

            if volume.get("device_name") is not None:
                eg_volume.device_name = volume.get("device_name")
            if volume.get("volume_ids") is not None:
                eg_volume.volume_ids = volume.get("volume_ids")

            if eg_volume.device_name is not None:
                eg_volumes.append(eg_volume)

        if len(eg_volumes) > 0:
            eg_compute.ebs_volume_pool = eg_volumes


def expand_launch_spec(eg_compute, module, is_update, do_not_update):
    eg_launch_spec = expand_fields(lspec_fields, module.params, "LaunchSpecification")

    if module.params["iam_role_arn"] is not None or module.params["iam_role_name"] is not None:
        eg_launch_spec.iam_role = expand_fields(iam_fields, module.params, "IamRole")

    tags = module.params["tags"]
    load_balancers = module.params["load_balancers"]
    target_group_arns = module.params["target_group_arns"]
    block_device_mappings = module.params["block_device_mappings"]
    network_interfaces = module.params["network_interfaces"]

    if is_update is True:
        if "image_id" in do_not_update:
            delattr(eg_launch_spec, "image_id")

    expand_tags(eg_launch_spec, tags)

    expand_load_balancers(eg_launch_spec, load_balancers, target_group_arns)

    expand_block_device_mappings(eg_launch_spec, block_device_mappings)

    expand_network_interfaces(eg_launch_spec, network_interfaces)

    eg_compute.launch_specification = eg_launch_spec


def expand_integrations(eg, module):
    rancher = module.params.get("rancher")
    mesosphere = module.params.get("mesosphere")
    ecs = module.params.get("ecs")
    kubernetes = module.params.get("kubernetes")
    right_scale = module.params.get("right_scale")
    opsworks = module.params.get("opsworks")
    chef = module.params.get("chef")

    integration_exists = False

    eg_integrations = spotinst.aws_elastigroup.ThirdPartyIntegrations()

    if mesosphere is not None:
        eg_integrations.mesosphere = expand_fields(mesosphere_fields, mesosphere, "Mesosphere")
        integration_exists = True

    if ecs is not None:
        eg_integrations.ecs = expand_fields(ecs_fields, ecs, "EcsConfiguration")
        integration_exists = True

    if kubernetes is not None:
        eg_integrations.kubernetes = expand_fields(kubernetes_fields, kubernetes, "KubernetesConfiguration")
        integration_exists = True

    if right_scale is not None:
        eg_integrations.right_scale = expand_fields(right_scale_fields, right_scale, "RightScaleConfiguration")
        integration_exists = True

    if opsworks is not None:
        eg_integrations.opsworks = expand_fields(opsworks_fields, opsworks, "OpsWorksConfiguration")
        integration_exists = True

    if rancher is not None:
        eg_integrations.rancher = expand_fields(rancher_fields, rancher, "Rancher")
        integration_exists = True

    if chef is not None:
        eg_integrations.chef = expand_fields(chef_fields, chef, "ChefConfiguration")
        integration_exists = True

    if integration_exists:
        eg.third_parties_integration = eg_integrations


def expand_capacity(eg, module, is_update, do_not_update):
    eg_capacity = expand_fields(capacity_fields, module.params, "Capacity")

    if is_update is True:
        delattr(eg_capacity, "unit")

        if "target" in do_not_update:
            delattr(eg_capacity, "target")

    eg.capacity = eg_capacity


def expand_strategy(eg, module):
    persistence = module.params.get("persistence")
    signals = module.params.get("signals")

    eg_strategy = expand_fields(strategy_fields, module.params, "Strategy")

    terminate_at_end_of_billing_hour = module.params.get("terminate_at_end_of_billing_hour")

    if terminate_at_end_of_billing_hour is not None:
        eg_strategy.eg_scaling_strategy = expand_fields(scaling_strategy_fields, module.params, "ScalingStrategy")

    if persistence is not None:
        eg_strategy.persistence = expand_fields(persistence_fields, persistence, "Persistence")

    if signals is not None:
        eg_signals = expand_list(signals, signal_fields, "Signal")

        if len(eg_signals) > 0:
            eg_strategy.signals = eg_signals

    eg.strategy = eg_strategy


def expand_multai(eg, module):
    multai_load_balancers = module.params.get("multai_load_balancers")

    eg_multai = expand_fields(multai_fields, module.params, "Multai")

    if multai_load_balancers is not None:
        eg_multai_load_balancers = expand_list(multai_load_balancers, multai_lb_fields, "MultaiLoadBalancer")

        if len(eg_multai_load_balancers) > 0:
            eg_multai.balancers = eg_multai_load_balancers
            eg.multai = eg_multai


def expand_scheduled_tasks(eg, module):
    scheduled_tasks = module.params.get("scheduled_tasks")

    if scheduled_tasks is not None:
        eg_scheduling = spotinst.aws_elastigroup.Scheduling()

        eg_tasks = expand_list(scheduled_tasks, scheduled_task_fields, "ScheduledTask")

        if len(eg_tasks) > 0:
            eg_scheduling.tasks = eg_tasks
            eg.scheduling = eg_scheduling


def expand_load_balancers(eg_launchspec, load_balancers, target_group_arns):
    if load_balancers is not None or target_group_arns is not None:
        eg_load_balancers_config = spotinst.aws_elastigroup.LoadBalancersConfig()
        eg_total_lbs = []

        if load_balancers is not None:
            for elb_name in load_balancers:
                eg_elb = spotinst.aws_elastigroup.LoadBalancer()
                if elb_name is not None:
                    eg_elb.name = elb_name
                    eg_elb.type = "CLASSIC"
                    eg_total_lbs.append(eg_elb)

        if target_group_arns is not None:
            for target_arn in target_group_arns:
                eg_elb = spotinst.aws_elastigroup.LoadBalancer()
                if target_arn is not None:
                    eg_elb.arn = target_arn
                    eg_elb.type = "TARGET_GROUP"
                    eg_total_lbs.append(eg_elb)

        if len(eg_total_lbs) > 0:
            eg_load_balancers_config.load_balancers = eg_total_lbs
            eg_launchspec.load_balancers_config = eg_load_balancers_config


def expand_tags(eg_launchspec, tags):
    if tags is not None:
        eg_tags = []

        for tag in tags:
            eg_tag = spotinst.aws_elastigroup.Tag()
            if tag:
                eg_tag.tag_key, eg_tag.tag_value = list(tag.items())[0]

            eg_tags.append(eg_tag)

        if len(eg_tags) > 0:
            eg_launchspec.tags = eg_tags


def expand_block_device_mappings(eg_launchspec, bdms):
    if bdms is not None:
        eg_bdms = []

        for bdm in bdms:
            eg_bdm = expand_fields(bdm_fields, bdm, "BlockDeviceMapping")

            if bdm.get("ebs") is not None:
                eg_bdm.ebs = expand_fields(ebs_fields, bdm.get("ebs"), "EBS")

            eg_bdms.append(eg_bdm)

        if len(eg_bdms) > 0:
            eg_launchspec.block_device_mappings = eg_bdms


def expand_network_interfaces(eg_launchspec, enis):
    if enis is not None:
        eg_enis = []

        for eni in enis:
            eg_eni = expand_fields(eni_fields, eni, "NetworkInterface")

            eg_pias = expand_list(eni.get("private_ip_addresses"), private_ip_fields, "PrivateIpAddress")

            if eg_pias is not None:
                eg_eni.private_ip_addresses = eg_pias

            eg_enis.append(eg_eni)

        if len(eg_enis) > 0:
            eg_launchspec.network_interfaces = eg_enis


def expand_scaling(eg, module):
    up_scaling_policies = module.params["up_scaling_policies"]
    down_scaling_policies = module.params["down_scaling_policies"]
    target_tracking_policies = module.params["target_tracking_policies"]

    eg_scaling = spotinst.aws_elastigroup.Scaling()

    if up_scaling_policies is not None:
        eg_up_scaling_policies = expand_scaling_policies(up_scaling_policies)
        if len(eg_up_scaling_policies) > 0:
            eg_scaling.up = eg_up_scaling_policies

    if down_scaling_policies is not None:
        eg_down_scaling_policies = expand_scaling_policies(down_scaling_policies)
        if len(eg_down_scaling_policies) > 0:
            eg_scaling.down = eg_down_scaling_policies

    if target_tracking_policies is not None:
        eg_target_tracking_policies = expand_target_tracking_policies(target_tracking_policies)
        if len(eg_target_tracking_policies) > 0:
            eg_scaling.target = eg_target_tracking_policies

    if eg_scaling.down is not None or eg_scaling.up is not None or eg_scaling.target is not None:
        eg.scaling = eg_scaling


def expand_list(items, fields, class_name):
    if items is not None:
        new_objects_list = []
        for item in items:
            new_obj = expand_fields(fields, item, class_name)
            new_objects_list.append(new_obj)

        return new_objects_list


def expand_fields(fields, item, class_name):
    class_ = getattr(spotinst.aws_elastigroup, class_name)
    new_obj = class_()

    # Handle primitive fields
    if item is not None:
        for field in fields:
            if isinstance(field, dict):
                ansible_field_name = field["ansible_field_name"]
                spotinst_field_name = field["spotinst_field_name"]
            else:
                ansible_field_name = field
                spotinst_field_name = field
            if item.get(ansible_field_name) is not None:
                setattr(new_obj, spotinst_field_name, item.get(ansible_field_name))

    return new_obj


def expand_scaling_policies(scaling_policies):
    eg_scaling_policies = []

    for policy in scaling_policies:
        eg_policy = expand_fields(scaling_policy_fields, policy, "ScalingPolicy")
        eg_policy.action = expand_fields(action_fields, policy, "ScalingPolicyAction")
        eg_scaling_policies.append(eg_policy)

    return eg_scaling_policies


def expand_target_tracking_policies(tracking_policies):
    eg_tracking_policies = []

    for policy in tracking_policies:
        eg_policy = expand_fields(tracking_policy_fields, policy, "TargetTrackingPolicy")
        eg_tracking_policies.append(eg_policy)

    return eg_tracking_policies


def main():
    fields = dict(
        account_id=dict(type="str"),
        availability_vs_cost=dict(type="str", required=True),
        availability_zones=dict(type="list", elements="dict", required=True),
        block_device_mappings=dict(type="list", elements="dict"),
        chef=dict(type="dict"),
        credentials_path=dict(type="path", default="~/.spotinst/credentials"),
        do_not_update=dict(default=[], type="list", elements="str"),
        down_scaling_policies=dict(type="list", elements="dict"),
        draining_timeout=dict(type="int"),
        ebs_optimized=dict(type="bool"),
        ebs_volume_pool=dict(type="list", elements="dict"),
        ecs=dict(type="dict"),
        elastic_beanstalk=dict(type="dict"),
        elastic_ips=dict(type="list", elements="str"),
        fallback_to_od=dict(type="bool"),
        id=dict(type="str"),
        health_check_grace_period=dict(type="int"),
        health_check_type=dict(type="str"),
        health_check_unhealthy_duration_before_replacement=dict(type="int"),
        iam_role_arn=dict(type="str"),
        iam_role_name=dict(type="str"),
        image_id=dict(type="str", required=True),
        key_pair=dict(type="str", no_log=False),
        kubernetes=dict(type="dict"),
        lifetime_period=dict(type="int"),
        load_balancers=dict(type="list", elements="str"),
        max_size=dict(type="int", required=True),
        mesosphere=dict(type="dict"),
        min_size=dict(type="int", required=True),
        monitoring=dict(type="str"),
        multai_load_balancers=dict(type="list", elements="dict"),
        multai_token=dict(type="str", no_log=True),
        name=dict(type="str", required=True),
        network_interfaces=dict(type="list", elements="dict"),
        on_demand_count=dict(type="int"),
        on_demand_instance_type=dict(type="str"),
        opsworks=dict(type="dict"),
        persistence=dict(type="dict"),
        product=dict(type="str", required=True),
        rancher=dict(type="dict"),
        right_scale=dict(type="dict"),
        risk=dict(type="int"),
        roll_config=dict(type="dict"),
        scheduled_tasks=dict(type="list", elements="dict"),
        security_group_ids=dict(type="list", elements="str", required=True),
        shutdown_script=dict(type="str"),
        signals=dict(type="list", elements="dict"),
        spin_up_time=dict(type="int"),
        spot_instance_types=dict(type="list", elements="str", required=True),
        state=dict(default="present", choices=["present", "absent"]),
        tags=dict(type="list", elements="dict"),
        target=dict(type="int", required=True),
        target_group_arns=dict(type="list", elements="str"),
        tenancy=dict(type="str"),
        terminate_at_end_of_billing_hour=dict(type="bool"),
        token=dict(type="str", no_log=True),
        unit=dict(type="str"),
        user_data=dict(type="str"),
        utilize_reserved_instances=dict(type="bool"),
        uniqueness_by=dict(default="name", choices=["name", "id"]),
        up_scaling_policies=dict(type="list", elements="dict"),
        target_tracking_policies=dict(type="list", elements="dict"),
        wait_for_instances=dict(type="bool", default=False),
        wait_timeout=dict(type="int"),
    )

    module = AnsibleModule(argument_spec=fields)

    if not HAS_SPOTINST_SDK:
        module.fail_json(msg="the Spotinst SDK library is required. (pip install spotinst_sdk)")

    # Retrieve creds file variables
    creds_file_loaded_vars = dict()

    credentials_path = module.params.get("credentials_path")

    try:
        with open(credentials_path, "r") as creds:
            for line in creds:
                eq_index = line.find("=")
                var_name = line[:eq_index].strip()
                string_value = line[eq_index + 1 :].strip()
                creds_file_loaded_vars[var_name] = string_value
    except IOError:
        pass
    # End of creds file retrieval

    token = module.params.get("token")
    if not token:
        token = os.environ.get("SPOTINST_TOKEN")
    if not token:
        token = creds_file_loaded_vars.get("token")

    account = module.params.get("account_id")
    if not account:
        account = os.environ.get("SPOTINST_ACCOUNT_ID") or os.environ.get("ACCOUNT")
    if not account:
        account = creds_file_loaded_vars.get("account")

    client = spotinst.SpotinstClient(auth_token=token, print_output=False)

    if account is not None:
        client = spotinst.SpotinstClient(auth_token=token, print_output=False, account_id=account)

    group_id, message, has_changed = handle_elastigroup(client=client, module=module)

    instances = retrieve_group_instances(client=client, module=module, group_id=group_id)

    module.exit_json(changed=has_changed, group_id=group_id, message=message, instances=instances)


if __name__ == "__main__":
    main()