def execute()

in source/code/actions/ec2_create_snapshot_action.py [0:0]
57 lines of code
21 McCabe index (conditional complexity)

    def execute(self):

        def volume_has_active_snapshots(ec2_service, vol_id):

            # test if the snapshot with the ids that were returned from the CreateSnapshot API call exists and are completed
            volume_snapshots = list(
                ec2_service.describe(services.ec2_service.SNAPSHOTS,
                                     OwnerIds=["self"],
                                     region=self.instance["Region"],
                                     Filters=[
                                         {
                                             "Name": "volume-id", "Values": [vol_id]
                                         }
                                     ]))

            active = [s["SnapshotId"] for s in volume_snapshots if s.get("State", "") == "pending"]

            if len(active) > 0:
                self._logger_.info(INFO_PENDING_SNAPSHOTS, vol_id, ",".join(active))
                return True

            return False

        self._logger_.info("{}, version {}", self.properties[ACTION_TITLE], self.properties[ACTION_VERSION])

        self._logger_.info(INFO_START_SNAPSHOT_ACTION, self.instance_id, self._account_, self._region_, self._task_)
        self._logger_.debug("Instance block device mappings are {}", self.instance["BlockDeviceMappings"])

        ec2 = services.create_service("ec2", session=self._session_,
                                      service_retry_strategy=get_default_retry_strategy("ec2", context=self._context_))

        if self.volume_tag_filter is not None:
            volume_data = ec2.describe(services.ec2_service.VOLUMES,
                                       VolumeIds=list(self.volumes.keys()),
                                       tags=True,
                                       region=self._region_)
            volume_tags = {k["VolumeId"]: k.get("Tags", {}) for k in list(volume_data)}
        else:
            volume_tags = {}

        if self.backup_root_device:
            if self.root_volume is None:
                self._logger_.warning(WARN_ROOT_NOT_FOUND, self.instance_id, ",".join(self.volumes))
            else:
                if self.volume_tag_filter is None or self.volume_tag_filter.is_match(volume_tags.get(self.root_volume, {})):
                    if volume_has_active_snapshots(ec2, self.root_volume):
                        self._logger_.error(ERR_SNAPSHOT_PENDING, self.root_volume)
                    else:
                        self.create_volume_snapshot(self.root_volume)
                else:
                    self._logger_.info(INF_SKIP_VOLUME_TAG_FILTER, self.root_volume, volume_tags.get(self.root_volume, {}))

        if self.backup_data_devices:
            for volume in [v for v in self.volumes if v != self.root_volume]:
                if self.volume_tag_filter is None or self.volume_tag_filter.is_match(volume_tags.get(volume, {})):
                    if volume_has_active_snapshots(ec2, volume):
                        self._logger_.error(ERR_SNAPSHOT_PENDING, volume)
                    else:
                        self.create_volume_snapshot(volume)
                else:
                    self._logger_.info(INF_SKIP_VOLUME_TAG_FILTER, volume, volume_tags.get(volume, {}))

        self.result["start-time"] = self._datetime_.now().isoformat()

        self.result[METRICS_DATA] = build_action_metrics(
            action=self,
            CreatedSnapshots=len(list(self.result.get("volumes", {}).values())),
            SnapshotsSizeTotal=sum(
                [volume.get("create_snapshot", {}).get("VolumeSize") for volume in
                 list(self.result.get("volumes", {}).values())]))

        return self.result