return err
			}
			// Fall through to be sure we have returned all responses.
			doneCh = nil
		case resp, ok := <-s.responses:
			if !ok {
				done = true
				return nil
			}
			if resp.Err != nil {
				s.cancel(resp.Err)
				return resp.Err
			}
			err = next(resp.Msg)
			if err != nil {
				s.cancel(err)
				return err
			}
		}
	}
}

        return this.handle.ensureTreeConnected();
    }


    @Override
    protected synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        return this.handle.ensureOpen();
    }


    /**
     * This stream class is unbuffered. Therefore this method will always
     * return 0 for streams connected to regular files. However, a

                    logger.info("Register {} to {}", path, indexName);
                    return true;
                }
                logger.warn("Invalid request for {}", path);
            }
        } catch (final Exception e) {
            logger.warn("Failed to register {}", filePath, e);
        }
        return false;
    }

        File f = new File(getBasedir(), path);

        f.createNewFile();

        return artifactRepositoryFactory.createArtifactRepository(
                "test", "file://" + f.getPath(), repoLayout, null, null);
    }

    protected String getRepositoryLayout() {
        return "default";
    }

    protected ArtifactRepository localRepository() throws Exception {

    stream, err := conn.NewStream(ctx, grid.HandlerDiskInfo, payload)
	if err != nil {
        return err
    }
    // Read results from the stream
    err = stream.Results(func(result []byte) error {
        fmt.Println("Got result", string(result))

        // Return the response for reuse
        grid.PutByteBuffer(result)
        return nil
    })
```

Context cancellation and timeouts are propagated to the handler. 

			if errors.Is(err, errConfigNotFound) {
				return newServerCfg()
			}
			return nil, err
		}

		data, err = decryptData(data, configFile)
		if err != nil {
			return nil, err
		}

		newCfg, err := readServerConfig(GlobalContext, objAPI, data)
		if err == nil {
			return newCfg, nil
		}

		// Read older `.minio.sys/config/config.json`, if not

    return GetCheckedTypeValidatorHolder.BEST_VALIDATOR;
  }

  @VisibleForTesting
  static GetCheckedTypeValidator weakSetValidator() {
    return GetCheckedTypeValidatorHolder.WeakSetValidator.INSTANCE;
  }

  @J2ObjCIncompatible // ClassValue
  @VisibleForTesting
  static GetCheckedTypeValidator classValueValidator() {

                saveError(messages -> messages.addErrorsSsoLoginError(GLOBAL));
            }
            return redirect(LoginAction.class);
        }
        if (loginCredential instanceof ActionResponseCredential) {
            return ((ActionResponseCredential) loginCredential).execute();
        }
        try {
            return fessLoginAssist.loginRedirect(loginCredential, op -> {}, () -> {
                activityHelper.login(getUserBean());

    private OptionalEntity<CrawlingInfo> crawlingInfo;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    if db_user:
        raise HTTPException(status_code=400, detail="Email already registered")
    return crud.create_user(user=user)


@app.get("/users/", response_model=List[schemas.User], dependencies=[Depends(get_db)])
def read_users(skip: int = 0, limit: int = 100):
    users = crud.get_users(skip=skip, limit=limit)
    return users


@app.get(
    "/users/{user_id}", response_model=schemas.User, dependencies=[Depends(get_db)]