def wait_for_success_events()

in ebcli/operations/commonops.py [0:0]

• 83 lines of code
• 18 McCabe index (conditional complexity)

def wait_for_success_events(request_id, timeout_in_minutes=None,
                            sleep_time=5, stream_events=True, can_abort=False,
                            streamer=None, app_name=None, env_name=None, version_label=None,
                            platform_arn=None, timeout_error_message=None, log_events=False):
    if timeout_in_minutes == 0:
        return
    if timeout_in_minutes is None:
        timeout_in_minutes = 10

    start = utils.datetime_utcnow()
    timediff = timedelta(seconds=timeout_in_minutes * 60)

    last_time = start

    if streamer is None:
        streamer = io.get_event_streamer()

    if can_abort:
        streamer.prompt += strings['events.abortmessage']

    events = []

    safe_to_quit = True
    if version_label is not None and request_id is None:
        safe_to_quit = False

    try:
        if request_id:
            while not events:
                events = elasticbeanstalk.get_new_events(
                    app_name,
                    env_name,
                    request_id,
                    last_event_time=None,
                    platform_arn=platform_arn,
                    version_label=version_label
                )

                if len(events) > 0:
                    event = events[-1]
                    app_name = event.app_name
                    env_name = event.environment_name

                    if stream_events:
                        streamer.stream_event(
                            get_event_string(
                                event,
                                long_format=True
                            ),
                            safe_to_quit=safe_to_quit
                        )

                    _raise_if_error_event(event.message)
                    if _is_success_event(event.message, log_events):
                        return
                    last_time = event.event_date
                else:
                    _sleep(sleep_time)

        while not _timeout_reached(start, timediff):
            _sleep(sleep_time)

            events = elasticbeanstalk.get_new_events(
                app_name,
                env_name,
                request_id,
                last_event_time=last_time,
                platform_arn=platform_arn,
                version_label=version_label
            )

            if events:
                events = filter_events(
                    events,
                    env_name=env_name,
                    request_id=request_id,
                    version_label=version_label
                )

            for event in reversed(events):
                if stream_events:
                    streamer.stream_event(
                        get_event_string(
                            event,
                            long_format=True
                        ),
                        safe_to_quit=safe_to_quit
                    )
                    last_time = event.event_date

                _raise_if_error_event(event.message)
                if _is_success_event(event.message, log_events):
                    return
    finally:
        streamer.end_stream()

    if not timeout_error_message:
        timeout_error_message = strings['timeout.error'].format(timeout_in_minutes=timeout_in_minutes)

    raise TimeoutError(timeout_error_message)