• Home
• io.reactiverse
• elasticsearch-client-rxjava2
• 0.8.1ec7.5.1
• source code
• SecurityClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.reactiverse.elasticsearch.client.reactivex.SecurityClient Maven / Gradle / Ivy

/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.reactiverse.elasticsearch.client.reactivex;

import java.util.Map;
import io.reactivex.Observable;
import io.reactivex.Flowable;
import io.reactivex.Single;
import io.reactivex.Completable;
import io.reactivex.Maybe;
import org.elasticsearch.client.security.DisableUserRequest;
import org.elasticsearch.client.security.EnableUserRequest;
import org.elasticsearch.client.security.InvalidateTokenResponse;
import org.elasticsearch.client.security.GetPrivilegesResponse;
import org.elasticsearch.client.security.DeleteUserResponse;
import org.elasticsearch.client.security.InvalidateApiKeyResponse;
import org.elasticsearch.client.security.DelegatePkiAuthenticationRequest;
import org.elasticsearch.client.security.PutUserRequest;
import org.elasticsearch.client.security.GetPrivilegesRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.security.PutPrivilegesResponse;
import org.elasticsearch.client.security.CreateApiKeyRequest;
import org.elasticsearch.client.security.GetSslCertificatesResponse;
import org.elasticsearch.client.security.DeleteRoleMappingRequest;
import org.elasticsearch.client.security.DeleteUserRequest;
import org.elasticsearch.client.security.DeleteRoleRequest;
import org.elasticsearch.client.security.CreateTokenResponse;
import org.elasticsearch.client.security.HasPrivilegesRequest;
import org.elasticsearch.client.security.CreateTokenRequest;
import org.elasticsearch.client.security.ChangePasswordRequest;
import org.elasticsearch.client.security.GetApiKeyResponse;
import org.elasticsearch.client.security.PutUserResponse;
import org.elasticsearch.client.security.GetApiKeyRequest;
import org.elasticsearch.client.security.DelegatePkiAuthenticationResponse;
import org.elasticsearch.client.security.GetRoleMappingsRequest;
import org.elasticsearch.client.security.GetUsersRequest;
import org.elasticsearch.client.security.ClearRealmCacheResponse;
import org.elasticsearch.client.security.GetUserPrivilegesResponse;
import org.elasticsearch.client.security.GetBuiltinPrivilegesResponse;
import org.elasticsearch.client.security.PutRoleResponse;
import org.elasticsearch.client.security.PutRoleMappingRequest;
import org.elasticsearch.client.security.DeletePrivilegesRequest;
import org.elasticsearch.client.security.GetRolesRequest;
import org.elasticsearch.client.security.PutRoleMappingResponse;
import org.elasticsearch.client.security.ClearRolesCacheResponse;
import org.elasticsearch.client.security.ClearRolesCacheRequest;
import io.vertx.core.AsyncResult;
import org.elasticsearch.client.security.GetRoleMappingsResponse;
import org.elasticsearch.client.security.PutPrivilegesRequest;
import org.elasticsearch.client.security.GetRolesResponse;
import org.elasticsearch.client.security.InvalidateTokenRequest;
import org.elasticsearch.client.security.HasPrivilegesResponse;
import org.elasticsearch.client.security.GetUsersResponse;
import org.elasticsearch.client.security.ClearRealmCacheRequest;
import org.elasticsearch.client.security.DeleteRoleResponse;
import org.elasticsearch.client.security.PutRoleRequest;
import org.elasticsearch.client.security.DeletePrivilegesResponse;
import org.elasticsearch.client.security.CreateApiKeyResponse;
import org.elasticsearch.client.security.InvalidateApiKeyRequest;
import io.vertx.core.Handler;
import org.elasticsearch.client.security.DeleteRoleMappingResponse;
import org.elasticsearch.client.security.AuthenticateResponse;


@io.vertx.lang.rx.RxGen(io.reactiverse.elasticsearch.client.SecurityClient.class)
public class SecurityClient {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    SecurityClient that = (SecurityClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.rx.TypeArg __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new SecurityClient((io.reactiverse.elasticsearch.client.SecurityClient) obj),
    SecurityClient::getDelegate
  );

  private final io.reactiverse.elasticsearch.client.SecurityClient delegate;
  
  public SecurityClient(io.reactiverse.elasticsearch.client.SecurityClient delegate) {
    this.delegate = delegate;
  }

  public io.reactiverse.elasticsearch.client.SecurityClient getDelegate() {
    return delegate;
  }

  public void getUsersAsync(GetUsersRequest request, RequestOptions options, Handler> handler) { 
    delegate.getUsersAsync(request, options, handler);
  }

  public Single rxGetUsersAsync(GetUsersRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getUsersAsync(request, options, handler);
    });
  }

  public void putUserAsync(PutUserRequest request, RequestOptions options, Handler> handler) { 
    delegate.putUserAsync(request, options, handler);
  }

  public Single rxPutUserAsync(PutUserRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      putUserAsync(request, options, handler);
    });
  }

  public void deleteUserAsync(DeleteUserRequest request, RequestOptions options, Handler> handler) { 
    delegate.deleteUserAsync(request, options, handler);
  }

  public Single rxDeleteUserAsync(DeleteUserRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteUserAsync(request, options, handler);
    });
  }

  public void putRoleMappingAsync(PutRoleMappingRequest request, RequestOptions options, Handler> handler) { 
    delegate.putRoleMappingAsync(request, options, handler);
  }

  public Single rxPutRoleMappingAsync(PutRoleMappingRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      putRoleMappingAsync(request, options, handler);
    });
  }

  public void getRoleMappingsAsync(GetRoleMappingsRequest request, RequestOptions options, Handler> handler) { 
    delegate.getRoleMappingsAsync(request, options, handler);
  }

  public Single rxGetRoleMappingsAsync(GetRoleMappingsRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getRoleMappingsAsync(request, options, handler);
    });
  }

  public void enableUserAsync(EnableUserRequest request, RequestOptions options, Handler> handler) { 
    delegate.enableUserAsync(request, options, handler);
  }

  public Single rxEnableUserAsync(EnableUserRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      enableUserAsync(request, options, handler);
    });
  }

  public void disableUserAsync(DisableUserRequest request, RequestOptions options, Handler> handler) { 
    delegate.disableUserAsync(request, options, handler);
  }

  public Single rxDisableUserAsync(DisableUserRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      disableUserAsync(request, options, handler);
    });
  }

  public void authenticateAsync(RequestOptions options, Handler> handler) { 
    delegate.authenticateAsync(options, handler);
  }

  public Single rxAuthenticateAsync(RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      authenticateAsync(options, handler);
    });
  }

  public void hasPrivilegesAsync(HasPrivilegesRequest request, RequestOptions options, Handler> handler) { 
    delegate.hasPrivilegesAsync(request, options, handler);
  }

  public Single rxHasPrivilegesAsync(HasPrivilegesRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      hasPrivilegesAsync(request, options, handler);
    });
  }

  public void getUserPrivilegesAsync(RequestOptions options, Handler> handler) { 
    delegate.getUserPrivilegesAsync(options, handler);
  }

  public Single rxGetUserPrivilegesAsync(RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getUserPrivilegesAsync(options, handler);
    });
  }

  public void clearRealmCacheAsync(ClearRealmCacheRequest request, RequestOptions options, Handler> handler) { 
    delegate.clearRealmCacheAsync(request, options, handler);
  }

  public Single rxClearRealmCacheAsync(ClearRealmCacheRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      clearRealmCacheAsync(request, options, handler);
    });
  }

  public void clearRolesCacheAsync(ClearRolesCacheRequest request, RequestOptions options, Handler> handler) { 
    delegate.clearRolesCacheAsync(request, options, handler);
  }

  public Single rxClearRolesCacheAsync(ClearRolesCacheRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      clearRolesCacheAsync(request, options, handler);
    });
  }

  public void getSslCertificatesAsync(RequestOptions options, Handler> handler) { 
    delegate.getSslCertificatesAsync(options, handler);
  }

  public Single rxGetSslCertificatesAsync(RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getSslCertificatesAsync(options, handler);
    });
  }

  public void changePasswordAsync(ChangePasswordRequest request, RequestOptions options, Handler> handler) { 
    delegate.changePasswordAsync(request, options, handler);
  }

  public Single rxChangePasswordAsync(ChangePasswordRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      changePasswordAsync(request, options, handler);
    });
  }

  public void getRolesAsync(GetRolesRequest request, RequestOptions options, Handler> handler) { 
    delegate.getRolesAsync(request, options, handler);
  }

  public Single rxGetRolesAsync(GetRolesRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getRolesAsync(request, options, handler);
    });
  }

  public void putRoleAsync(PutRoleRequest request, RequestOptions options, Handler> handler) { 
    delegate.putRoleAsync(request, options, handler);
  }

  public Single rxPutRoleAsync(PutRoleRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      putRoleAsync(request, options, handler);
    });
  }

  public void deleteRoleMappingAsync(DeleteRoleMappingRequest request, RequestOptions options, Handler> handler) { 
    delegate.deleteRoleMappingAsync(request, options, handler);
  }

  public Single rxDeleteRoleMappingAsync(DeleteRoleMappingRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteRoleMappingAsync(request, options, handler);
    });
  }

  public void deleteRoleAsync(DeleteRoleRequest request, RequestOptions options, Handler> handler) { 
    delegate.deleteRoleAsync(request, options, handler);
  }

  public Single rxDeleteRoleAsync(DeleteRoleRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteRoleAsync(request, options, handler);
    });
  }

  public void createTokenAsync(CreateTokenRequest request, RequestOptions options, Handler> handler) { 
    delegate.createTokenAsync(request, options, handler);
  }

  public Single rxCreateTokenAsync(CreateTokenRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      createTokenAsync(request, options, handler);
    });
  }

  public void invalidateTokenAsync(InvalidateTokenRequest request, RequestOptions options, Handler> handler) { 
    delegate.invalidateTokenAsync(request, options, handler);
  }

  public Single rxInvalidateTokenAsync(InvalidateTokenRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      invalidateTokenAsync(request, options, handler);
    });
  }

  public void getBuiltinPrivilegesAsync(RequestOptions options, Handler> handler) { 
    delegate.getBuiltinPrivilegesAsync(options, handler);
  }

  public Single rxGetBuiltinPrivilegesAsync(RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getBuiltinPrivilegesAsync(options, handler);
    });
  }

  public void getPrivilegesAsync(GetPrivilegesRequest request, RequestOptions options, Handler> handler) { 
    delegate.getPrivilegesAsync(request, options, handler);
  }

  public Single rxGetPrivilegesAsync(GetPrivilegesRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getPrivilegesAsync(request, options, handler);
    });
  }

  public void putPrivilegesAsync(PutPrivilegesRequest request, RequestOptions options, Handler> handler) { 
    delegate.putPrivilegesAsync(request, options, handler);
  }

  public Single rxPutPrivilegesAsync(PutPrivilegesRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      putPrivilegesAsync(request, options, handler);
    });
  }

  public void deletePrivilegesAsync(DeletePrivilegesRequest request, RequestOptions options, Handler> handler) { 
    delegate.deletePrivilegesAsync(request, options, handler);
  }

  public Single rxDeletePrivilegesAsync(DeletePrivilegesRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deletePrivilegesAsync(request, options, handler);
    });
  }

  public void createApiKeyAsync(CreateApiKeyRequest request, RequestOptions options, Handler> handler) { 
    delegate.createApiKeyAsync(request, options, handler);
  }

  public Single rxCreateApiKeyAsync(CreateApiKeyRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      createApiKeyAsync(request, options, handler);
    });
  }

  public void getApiKeyAsync(GetApiKeyRequest request, RequestOptions options, Handler> handler) { 
    delegate.getApiKeyAsync(request, options, handler);
  }

  public Single rxGetApiKeyAsync(GetApiKeyRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getApiKeyAsync(request, options, handler);
    });
  }

  public void invalidateApiKeyAsync(InvalidateApiKeyRequest request, RequestOptions options, Handler> handler) { 
    delegate.invalidateApiKeyAsync(request, options, handler);
  }

  public Single rxInvalidateApiKeyAsync(InvalidateApiKeyRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      invalidateApiKeyAsync(request, options, handler);
    });
  }

  public void delegatePkiAuthenticationAsync(DelegatePkiAuthenticationRequest request, RequestOptions options, Handler> handler) { 
    delegate.delegatePkiAuthenticationAsync(request, options, handler);
  }

  public Single rxDelegatePkiAuthenticationAsync(DelegatePkiAuthenticationRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      delegatePkiAuthenticationAsync(request, options, handler);
    });
  }


  public static  SecurityClient newInstance(io.reactiverse.elasticsearch.client.SecurityClient arg) {
    return arg != null ? new SecurityClient(arg) : null;
  }
}