client.h

Go to the documentation of this file.

#pragma once


 
#include "fwd.h"
 
#include "client_method_options.h"
#include "constants.h"
#include "batch_request.h"
#include "cypress.h"
#include "distributed_session.h"
#include "init.h"
#include "io.h"
#include "node.h"
#include "operation.h"
 
#include <library/cpp/threading/future/future.h>
 
#include <util/datetime/base.h>
#include <util/generic/maybe.h>
#include <util/system/compiler.h>

namespace NYT {


struct TAuthorizationInfo
{
    TString Login;

    TString Realm;
};


struct TCheckPermissionResult
{
    ESecurityAction Action;

    TMaybe<TGUID> ObjectId;

    TMaybe<TString> ObjectName;

    TMaybe<TGUID> SubjectId;

    TMaybe<TString> SubjectName;
};

struct TCheckPermissionResponse
    : public TCheckPermissionResult
{
    TVector<TCheckPermissionResult> Columns;
};


class ILock
    : public TThrRefBase
{
public:
    virtual ~ILock() = default;

    virtual const TLockId& GetId() const = 0;

    virtual TNodeId GetLockedNodeId() const = 0;

    virtual const ::NThreading::TFuture<void>& GetAcquiredFuture() const = 0;

    void Wait(TDuration timeout = TDuration::Max());
};


class IClientBase
    : public TThrRefBase
    , public ICypressClient
    , public IIOClient
    , public IOperationClient
{
public:
    [[nodiscard]] virtual ITransactionPtr StartTransaction(
        const TStartTransactionOptions& options = TStartTransactionOptions()) = 0;

    virtual TDistributedWriteFileSessionWithCookies StartDistributedWriteFileSession(
        const TRichYPath& richPath,
        i64 cookieCount,
        const TStartDistributedWriteFileOptions& options = {}) = 0;

    virtual TDistributedWriteTableSessionWithCookies StartDistributedWriteTableSession(
        const TRichYPath& richPath,
        i64 cookieCount,
        const TStartDistributedWriteTableOptions& options = {}) = 0;

    virtual void AlterTable(
        const TYPath& path,
        const TAlterTableOptions& options = TAlterTableOptions()) = 0;

    virtual TBatchRequestPtr CreateBatchRequest() = 0;

    virtual IClientPtr GetParentClient(bool ignoreGlobalTx = false) = 0;
};

 

class ITransaction
    : virtual public IClientBase
{
public:
    virtual const TTransactionId& GetId() const = 0;

    virtual ILockPtr Lock(
        const TYPath& path,
        ELockMode mode,
        const TLockOptions& options = TLockOptions()) = 0;

    virtual void Unlock(
        const TYPath& path,
        const TUnlockOptions& options = TUnlockOptions()) = 0;

    virtual void Commit(const TCommitTransactionOptions& options = {}) = 0;

    virtual void Abort() = 0;

    virtual void Ping() = 0;

    virtual void Detach();
};


class IClient
    : virtual public IClientBase
{
public:
    [[nodiscard]] virtual ITransactionPtr AttachTransaction(
        const TTransactionId& transactionId,
        const TAttachTransactionOptions& options = TAttachTransactionOptions()) = 0;

    virtual void MountTable(
        const TYPath& path,
        const TMountTableOptions& options = TMountTableOptions()) = 0;

    virtual void UnmountTable(
        const TYPath& path,
        const TUnmountTableOptions& options = TUnmountTableOptions()) = 0;

    virtual void RemountTable(
        const TYPath& path,
        const TRemountTableOptions& options = TRemountTableOptions()) = 0;

    virtual void FreezeTable(
        const TYPath& path,
        const TFreezeTableOptions& options = TFreezeTableOptions()) = 0;

    virtual void UnfreezeTable(
        const TYPath& path,
        const TUnfreezeTableOptions& options = TUnfreezeTableOptions()) = 0;

    virtual void ReshardTable(
        const TYPath& path,
        const TVector<TKey>& pivotKeys,
        const TReshardTableOptions& options = TReshardTableOptions()) = 0;

    virtual void ReshardTable(
        const TYPath& path,
        i64 tabletCount,
        const TReshardTableOptions& options = TReshardTableOptions()) = 0;

    virtual void InsertRows(
        const TYPath& path,
        const TNode::TListType& rows,
        const TInsertRowsOptions& options = TInsertRowsOptions()) = 0;

    virtual void DeleteRows(
        const TYPath& path,
        const TNode::TListType& keys,
        const TDeleteRowsOptions& options = TDeleteRowsOptions()) = 0;

    virtual void TrimRows(
        const TYPath& path,
        i64 tabletIndex,
        i64 rowCount,
        const TTrimRowsOptions& options = TTrimRowsOptions()) = 0;

    virtual TNode::TListType LookupRows(
        const TYPath& path,
        const TNode::TListType& keys,
        const TLookupRowsOptions& options = TLookupRowsOptions()) = 0;

    virtual TNode::TListType SelectRows(
        const TString& query,
        const TSelectRowsOptions& options = TSelectRowsOptions()) = 0;

    virtual void AlterTableReplica(
        const TReplicaId& replicaId,
        const TAlterTableReplicaOptions& alterTableReplicaOptions) = 0;

    virtual ui64 GenerateTimestamp() = 0;

    virtual TAuthorizationInfo WhoAmI() = 0;

    virtual TOperationAttributes GetOperation(
        const TOperationId& operationId,
        const TGetOperationOptions& options = TGetOperationOptions()) = 0;

    virtual TOperationAttributes GetOperation(
        const TString& alias,
        const TGetOperationOptions& options = TGetOperationOptions()) = 0;

    virtual TListOperationsResult ListOperations(
        const TListOperationsOptions& options = TListOperationsOptions()) = 0;

    virtual void UpdateOperationParameters(
        const TOperationId& operationId,
        const TUpdateOperationParametersOptions& options) = 0;

    virtual TJobAttributes GetJob(
        const TOperationId& operationId,
        const TJobId& jobId,
        const TGetJobOptions& options = TGetJobOptions()) = 0;

    virtual TListJobsResult ListJobs(
        const TOperationId& operationId,
        const TListJobsOptions& options = TListJobsOptions()) = 0;

    virtual IFileReaderPtr GetJobInput(
        const TJobId& jobId,
        const TGetJobInputOptions& options = TGetJobInputOptions()) = 0;

    virtual IFileReaderPtr GetJobFailContext(
        const TOperationId& operationId,
        const TJobId& jobId,
        const TGetJobFailContextOptions& options = TGetJobFailContextOptions()) = 0;

    virtual IFileReaderPtr GetJobStderr(
        const TOperationId& operationId,
        const TJobId& jobId,
        const TGetJobStderrOptions& options = TGetJobStderrOptions()) = 0;

    virtual IFileReaderPtr GetJobTrace(
        const TOperationId& operationId,
        const TJobId& jobId,
        const TGetJobTraceOptions& options = TGetJobTraceOptions()) = 0;

    virtual TNode::TListType SkyShareTable(
        const std::vector<TYPath>& tablePaths,
        const TSkyShareTableOptions& options) = 0;

    virtual TCheckPermissionResponse CheckPermission(
        const TString& user,
        EPermission permission,
        const TYPath& path,
        const TCheckPermissionOptions& options = TCheckPermissionOptions()) = 0;

    virtual TVector<TTabletInfo> GetTabletInfos(
        const TYPath& path,
        const TVector<int>& tabletIndexes,
        const TGetTabletInfosOptions& options = TGetTabletInfosOptions()) = 0;

    virtual const TNode::TMapType& GetDynamicConfiguration(const TString& configProfile);

    virtual void CheckClusterLiveness(
        const TCheckClusterLivenessOptions& options = TCheckClusterLivenessOptions()) = 0;

    virtual void SuspendOperation(
        const TOperationId& operationId,
        const TSuspendOperationOptions& options = TSuspendOperationOptions()) = 0;

    virtual void ResumeOperation(
        const TOperationId& operationId,
        const TResumeOperationOptions& options = TResumeOperationOptions()) = 0;


    virtual void PingDistributedWriteTableSession(
        const TDistributedWriteTableSession& session,
        const TPingDistributedWriteTableOptions& options = {}) = 0;

    virtual void FinishDistributedWriteTableSession(
        const TDistributedWriteTableSession& session,
        const TVector<TWriteTableFragmentResult>& results,
        const TFinishDistributedWriteTableOptions& options = {}) = 0;



    virtual void PingDistributedWriteFileSession(
        const TDistributedWriteFileSession& session,
        const TPingDistributedWriteFileOptions& options = {}) = 0;

    virtual void FinishDistributedWriteFileSession(
        const TDistributedWriteFileSession& session,
        const TVector<TWriteFileFragmentResult>& results,
        const TFinishDistributedWriteFileOptions& options = {}) = 0;


    virtual void Shutdown() = 0;
};

IClientPtr CreateRpcClient(
    const TString& serverName,
    const TCreateClientOptions& options = {});

IClientPtr CreateClient(
    const TString& serverName,
    const TCreateClientOptions& options = {});

IClientPtr CreateClientFromEnv(
    const TCreateClientOptions& options = {});

 
} // namespace NYT