`MINIO_IDENTITY_OPENID_DISPLAY_NAME` value is shown here). The user is then redirected to the OpenID provider's login page and performs necessary login actions (e.g. entering credentials, responding to MFA authentication challenges, etc). After successful login, the user is redirected back to the MinIO console. This redirect URL is specified as a parameter by MinIO when the user is redirected to the OpenID Provider in the beginning. For some setups, extra configuration may be required for this step...

2018/12/26 17:49:36 listening on http://localhost:8888/
```

This will open the login page of keycloak, upon successful login, STS credentials along with any buckets discovered using the credentials will be printed on the screen, for example:

```
{
  "buckets": [
    "bucket-x"
  ],
  "credentials": {

	return time.Duration(atomic.LoadInt64(&dt.timeout))
}

func (dt *dynamicTimeout) RetryInterval() time.Duration {
	return dt.retryInterval
}

// LogSuccess logs the duration of a successful action that
// did not hit the timeout
func (dt *dynamicTimeout) LogSuccess(duration time.Duration) {
	dt.logEntry(duration)
}

// LogFailure logs an action that hit the timeout

func reliableRename(srcFilePath, dstFilePath, baseDir string) (err error) {
	if err = reliableMkdirAll(path.Dir(dstFilePath), 0o777, baseDir); err != nil {
		return err
	}

	i := 0
	for {
		// After a successful parent directory create attempt a renameAll.
		if err = Rename(srcFilePath, dstFilePath); err != nil {
			// Retry only for the first retryable error.
			if osIsNotExist(err) && i == 0 {
				i++
				continue
			}

                                 * SmbFile.resolveDfs can re-insert the dr list with
                                 * the dr that was successful so that subsequent
                                 * attempts to resolve DFS use the last successful
                                 * referral first.
                                 */
                                tmp.map = links.map;

   * href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * @param expect the expected value
   * @param update the new value
   * @return {@code true} if successful. False return indicates that the actual value was not
   *     bitwise equal to the expected value.
   */
  public final boolean compareAndSet(double expect, double update) {

                // Another thread changed the state, re-evaluate
                return state.get();
            }
        }

        return current;
    }

    /**
     * Handle successful call
     */
    private void onSuccess() {
        totalSuccesses.incrementAndGet();
        consecutiveFailures.set(0);

        State current = state.get();

        if (current == State.HALF_OPEN) {

            }
        };
        ComponentUtil.register(mockLanguageHelper, "languageHelper");
    }

    // Test execute() method with successful processing
    public void test_execute_success() {
        String result = updateLabelJob.execute();
        assertNotNull(result);
        assertTrue(result.contains("3 docs")); // 3 documents processed

        }
    }

    /**
     * Simulate heartbeat processing
     *
     * @param registrationId the registration ID
     * @param sequenceNumber the sequence number
     * @return true if heartbeat was successful
     */
    public boolean processHeartbeat(String registrationId, long sequenceNumber) {
        MockRegistration registration = registrations.get(registrationId);
        if (registration != null) {

		case err == io.EOF:
			wg.Wait()
			return asyncErr

		// return any other error
		case err != nil:
			wg.Wait()
			extra := ""
			if n > 0 {
				extra = fmt.Sprintf(" after %d successful object(s)", n)
			}
			return fmt.Errorf("tar file error: %w%s", err, extra)

		// if the header is nil, just skip it (not sure how this happens)
		case header == nil:
			continue
		}