def _validate_schedule()

in source/lambda/configuration/config_admin.py [0:0]
83 lines of code
31 McCabe index (conditional complexity)

    def _validate_schedule(self, **schedule):

        result = {}

        # allowed parameters
        valid_parameters = [configuration.TIMEZONE,
                            configuration.PERIODS,
                            configuration.NAME,
                            configuration.DESCRIPTION,
                            configuration.OVERWRITE,
                            configuration.METRICS,
                            configuration.STOP_NEW_INSTANCES,
                            configuration.USE_MAINTENANCE_WINDOW,
                            configuration.SSM_MAINTENANCE_WINDOW,
                            configuration.RETAINED_RUNNING,
                            configuration.ENFORCED,
                            configuration.HIBERNATE,
                            configuration.OVERRIDE_STATUS,
                            configuration.SCHEDULE_CONFIG_STACK]

        for attr in schedule:

            if attr == ConfigAdmin.TYPE_ATTR:
                continue

            if attr not in valid_parameters:
                raise ValueError(ERR_SCHEDULE_UNKNOWN_PARAMETER.format(attr, valid_parameters))

            # skip None values
            if schedule[attr] is None or len(str(schedule[attr])) == 0:
                continue

            # check periods set
            if attr == configuration.PERIODS:
                temp = self._ensure_set(schedule[attr])
                if len(temp) > 0:
                    result[attr] = temp
                continue

            if attr in [configuration.NAME, configuration.SSM_MAINTENANCE_WINDOW]:
                result[attr] = schedule[attr]
                continue

            # make sure these fields are valid booleans
            if attr in [configuration.METRICS,
                        configuration.STOP_NEW_INSTANCES,
                        configuration.USE_MAINTENANCE_WINDOW,
                        configuration.RETAINED_RUNNING,
                        configuration.HIBERNATE,
                        configuration.ENFORCED]:
                bool_value = self._ensure_bool(schedule[attr])
                if bool_value is None:
                    raise ValueError(ERR_SCHEDULE_INVALID_BOOLEAN.format(schedule[attr], attr))
                result[attr] = bool_value
                continue

            # overwrite status, now deprecated, use PROP_OVERRIDE_STATUS instead
            if attr == configuration.OVERWRITE:

                if configuration.OVERRIDE_STATUS in schedule:
                    raise ValueError(
                        ERR_SCHEDULE_OVERWRITE_OVERRIDE_EXCLUSIVE.format(configuration.OVERWRITE, configuration.OVERRIDE_STATUS))

                bool_value = self._ensure_bool(schedule[attr])
                if bool_value is None:
                    raise ValueError(ERR_SCHEDULE_INVALID_BOOLEAN.format(schedule[attr], attr))
                result[
                    configuration.OVERRIDE_STATUS] = configuration.OVERRIDE_STATUS_RUNNING if bool_value \
                    else configuration.OVERRIDE_STATUS_STOPPED
                continue

            if attr == configuration.OVERRIDE_STATUS:

                if configuration.OVERWRITE in schedule:
                    raise ValueError(
                        ERR_SCHEDULE_OVERWRITE_OVERRIDE_EXCLUSIVE.format(configuration.OVERWRITE, configuration.OVERRIDE_STATUS))
                if schedule[attr] not in configuration.OVERRIDE_STATUS_VALUES:
                    raise ValueError(
                        ERR_SCHEDULE_INVALID_OVERRIDE.format(schedule[attr], attr, ",".join(configuration.OVERRIDE_STATUS_VALUES)))
                result[attr] = schedule[attr]
                continue

            # description
            if attr in [configuration.DESCRIPTION, configuration.SCHEDULE_CONFIG_STACK]:
                result[attr] = schedule[attr]
                continue

            # validate timezone
            if attr == configuration.TIMEZONE:
                timezone = schedule[configuration.TIMEZONE]
                if not SchedulerConfigBuilder.is_valid_timezone(timezone):
                    raise ValueError(
                        ERR_SCHEDULE_INVALID_TIMEZONE.format(timezone, configuration.TIMEZONE))
                result[attr] = timezone

        # name is mandatory
        if configuration.NAME not in result:
            raise ValueError(ERR_SCHEDULE_NAME_MISSING)

        # if there is no overwrite there must be at least one period
        if configuration.OVERRIDE_STATUS not in schedule:
            if configuration.PERIODS not in schedule or len(schedule[configuration.PERIODS]) == 0:
                raise ValueError(ERR_SCHEDULE_NO_PERIOD)

        # validate if periods are in configuration
        if configuration.PERIODS in result:
            # get list of all configured periods
            periods = [p[configuration.NAME] for p in self._list_periods()]
            for period in result[configuration.PERIODS]:
                if period.split(configuration.INSTANCE_TYPE_SEP)[0] not in periods:
                    raise ValueError(ERR_SCHEDULE_PERIOD_DOES_NOT_EXISTS.format(period))

        # indicates this s a schedule
        result[ConfigAdmin.TYPE_ATTR] = "schedule"

        return result