From 9926863b5e06131e2f3742863c14c8fb8c5c7339 Mon Sep 17 00:00:00 2001 From: carolinchen Date: Mon, 11 Aug 2025 14:33:29 +0800 Subject: [PATCH 1/2] feat(ccr): add cluster-level task creation support --- pkg/ccr/base/spec.go | 50 +++++++ pkg/ccr/job.go | 7 +- pkg/ccr/specer_mock.go | 15 +++ pkg/service/http_service.go | 259 +++++++++++++++++++++++++++++++++++- 4 files changed, 324 insertions(+), 7 deletions(-) diff --git a/pkg/ccr/base/spec.go b/pkg/ccr/base/spec.go index 0eb5f895..29bb1997 100644 --- a/pkg/ccr/base/spec.go +++ b/pkg/ccr/base/spec.go @@ -83,6 +83,22 @@ func ParseBackupState(state string) BackupState { } } +// isSystemDatabase 判断是否为系统数据库，需要跳过 +func isSystemDatabase(dbName string) bool { + systemDatabases := []string{ + "information_schema", + "mysql", + "__internal_schema", + } + + for _, sysDb := range systemDatabases { + if dbName == sysDb { + return true + } + } + return false +} + type RestoreState int const ( @@ -464,6 +480,40 @@ func (s *Spec) GetAllTables() ([]string, error) { return tables, nil } +func (s *Spec) GetAllDatabases() ([]string, error) { + log.Tracef("get all databases from cluster") + + db, err := s.Connect() + if err != nil { + return nil, err + } + + sql := "SHOW DATABASES" + rows, err := db.Query(sql) + if err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "query %s failed", sql) + } + defer rows.Close() + + var databases []string + for rows.Next() { + var database string + if err := rows.Scan(&database); err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "scan database failed") + } + // 过滤系统数据库 + if !isSystemDatabase(database) { + databases = append(databases, database) + } + } + + if err := rows.Err(); err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "rows error") + } + + return databases, nil +} + func (s *Spec) queryResult(querySQL string, queryColumn string, errMsg string) ([]string, error) { db, err := s.Connect() if err != nil { diff --git a/pkg/ccr/job.go b/pkg/ccr/job.go index 41312f2e..277d4ce8 100644 --- a/pkg/ccr/job.go +++ b/pkg/ccr/job.go @@ -127,8 +127,9 @@ func init() { type SyncType int const ( - DBSync SyncType = 0 - TableSync SyncType = 1 + DBSync SyncType = 0 + TableSync SyncType = 1 + ClusterSync SyncType = 2 ) func (s SyncType) String() string { @@ -137,6 +138,8 @@ func (s SyncType) String() string { return "db_sync" case TableSync: return "table_sync" + case ClusterSync: + return "cluster_sync" default: return "unknown_sync" } diff --git a/pkg/ccr/specer_mock.go b/pkg/ccr/specer_mock.go index cbf278b7..4b6b51fa 100644 --- a/pkg/ccr/specer_mock.go +++ b/pkg/ccr/specer_mock.go @@ -216,6 +216,21 @@ func (mr *MockSpecerMockRecorder) Exec(sql any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockSpecer)(nil).Exec), sql) } +// GetAllTables mocks base method. +func (m *MockSpecer) GetAllDatabases() ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllDatabases") + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAllDatabases indicates an expected call of GetAllDatabases. +func (mr *MockSpecerMockRecorder) GetAllDatabases() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllDatabases", reflect.TypeOf((*MockSpecer)(nil).GetAllDatabases)) +} + // GetAllTables mocks base method. func (m *MockSpecer) GetAllTables() ([]string, error) { m.ctrl.T.Helper() diff --git a/pkg/service/http_service.go b/pkg/service/http_service.go index 58c65314..3429c441 100644 --- a/pkg/service/http_service.go +++ b/pkg/service/http_service.go @@ -103,6 +103,8 @@ type CreateCcrRequest struct { // For table sync, allow to create ccr job even if the target table already exists. AllowTableExists bool `json:"allow_table_exists"` ReuseBinlogLabel bool `json:"reuse_binlog_label"` + // 是否为集群级同步，如果为true，将获取源集群所有数据库并为每个数据库创建同步任务 + ClusterSync bool `json:"cluster_sync"` } // Stringer @@ -156,6 +158,245 @@ func createCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobMana return nil } +// createClusterCcr 创建集群级别的CCR同步任务 +// 获取源集群的所有数据库，为每个数据库创建一个同步任务 +func createClusterCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager) error { + log.Infof("create cluster ccr %s", request) + + // 获取源集群的所有数据库列表 + databases, err := getDatabaseList(&request.Src) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to get database list from source cluster") + } + + if len(databases) == 0 { + return xerror.Errorf(xerror.Normal, "No databases found in source cluster") + } + + log.Infof("Found %d databases, starting to create cluster-level sync tasks: %v", len(databases), databases) + + var errors []string + successCount := 0 + + for _, dbName := range databases { + // 为每个数据库创建一个新的请求 + dbRequest := &CreateCcrRequest{ + Name: fmt.Sprintf("%s_%s", request.Name, dbName), // 任务名称加上数据库名称 + Src: request.Src, + Dest: request.Dest, + SkipError: request.SkipError, + AllowTableExists: request.AllowTableExists, + ReuseBinlogLabel: request.ReuseBinlogLabel, + ClusterSync: false, // 设置为false，避免递归调用 + } + + dbRequest.Src.Database = dbName + dbRequest.Dest.Database = dbName + + if err := createCcr(dbRequest, db, jobManager); err != nil { + errMsg := fmt.Sprintf("Failed to create sync task for database %s: %v", dbName, err) + log.Warnf(errMsg) + errors = append(errors, errMsg) + } else { + successCount++ + log.Infof("Successfully created sync task for database %s", dbName) + } + } + + if len(errors) > 0 { + if successCount == 0 { + return xerror.Errorf(xerror.Normal, "All database sync tasks creation failed: %s", strings.Join(errors, "; ")) + } else { + log.Warnf("Partial cluster sync tasks creation failed, success: %d, failed: %d, errors: %s", + successCount, len(errors), strings.Join(errors, "; ")) + } + } + + log.Infof("Cluster-level sync tasks creation completed, success: %d, failed: %d", successCount, len(errors)) + + // 启动守护任务，周期性检测源集群新增数据库，传入已有的数据库列表 + go startDatabaseMonitor(request, db, jobManager, databases) + + return nil +} + +// startDatabaseMonitor 启动一个守护任务，周期性检测源集群新增和删除的数据库，并创建或删除对应的同步任务 +func startDatabaseMonitor(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, initialDatabases []string) { + log.Infof("Starting database monitor daemon, task name prefix: %s", request.Name) + + existingDatabases := initializeDatabaseTracking(initialDatabases) + log.Infof("Initialized database monitoring, currently have %d databases", len(existingDatabases)) + + checkInterval := 2 * time.Minute + ticker := time.NewTicker(checkInterval) + defer ticker.Stop() + + for range ticker.C { + monitorDatabaseChanges(request, db, jobManager, existingDatabases) + } +} + +func initializeDatabaseTracking(initialDatabases []string) map[string]bool { + existingDatabases := make(map[string]bool) + for _, dbName := range initialDatabases { + existingDatabases[dbName] = true + } + return existingDatabases +} + +// monitorDatabaseChanges 检测数据库变化并处理 +func monitorDatabaseChanges(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, existingDatabases map[string]bool) { + currentDatabases, err := request.Src.GetAllDatabases() + if err != nil { + log.Errorf("Failed to get database list: %v", err) + return + } + + currentDatabaseMap := make(map[string]bool) + for _, dbName := range currentDatabases { + if dbName == "" { + continue + } + currentDatabaseMap[dbName] = true + } + + newDatabases := identifyNewDatabases(currentDatabases, existingDatabases) + deletedDatabases := identifyDeletedDatabases(existingDatabases, currentDatabaseMap) + + handleNewDatabases(newDatabases, request, db, jobManager) + handleDeletedDatabases(deletedDatabases, request, jobManager) + logMonitoringStatus(newDatabases, deletedDatabases, existingDatabases) +} + +func identifyNewDatabases(currentDatabases []string, existingDatabases map[string]bool) []string { + var newDatabases []string + for _, dbName := range currentDatabases { + if !existingDatabases[dbName] { + newDatabases = append(newDatabases, dbName) + existingDatabases[dbName] = true + } + } + return newDatabases +} + +func identifyDeletedDatabases(existingDatabases map[string]bool, currentDatabaseMap map[string]bool) []string { + var deletedDatabases []string + for dbName := range existingDatabases { + if !currentDatabaseMap[dbName] { + deletedDatabases = append(deletedDatabases, dbName) + delete(existingDatabases, dbName) + } + } + return deletedDatabases +} + +func handleNewDatabases(newDatabases []string, request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager) { + if len(newDatabases) == 0 { + return + } + + log.Infof("Found %d new databases: %v", len(newDatabases), newDatabases) + + for _, dbName := range newDatabases { + if dbName == "" { + log.Warnf("Skipping empty database name") + continue + } + + jobName := fmt.Sprintf("%s_%s", request.Name, dbName) + jobExists, err := db.IsJobExist(jobName) + if err != nil { + log.Warnf("Error checking if job %s exists: %v", jobName, err) + continue + } + + if jobExists { + log.Warnf("Job %s already exists, skipping sync task creation for database %s", jobName, dbName) + continue + } + + dbRequest := &CreateCcrRequest{ + Name: jobName, + Src: request.Src, + Dest: request.Dest, + SkipError: request.SkipError, + AllowTableExists: request.AllowTableExists, + ReuseBinlogLabel: request.ReuseBinlogLabel, + ClusterSync: false, // 设置为false，避免递归调用 + } + + dbRequest.Src.Database = dbName + dbRequest.Dest.Database = dbName + + maxRetries := 3 + for i := 0; i < maxRetries; i++ { + if err := createCcr(dbRequest, db, jobManager); err != nil { + if i == maxRetries-1 { + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v", dbName, i+1, maxRetries, err) + } else { + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v, will retry", dbName, i+1, maxRetries, err) + time.Sleep(time.Second * time.Duration(i+1)) // 指数退避 + } + } else { + log.Infof("Successfully created sync task for new database %s", dbName) + break + } + } + } +} + +func handleDeletedDatabases(deletedDatabases []string, request *CreateCcrRequest, jobManager *ccr.JobManager) { + if len(deletedDatabases) == 0 { + return + } + + log.Infof("Found %d deleted databases: %v", len(deletedDatabases), deletedDatabases) + + for _, dbName := range deletedDatabases { + if dbName == "" { + log.Warnf("Skipping empty database name") + continue + } + + jobName := fmt.Sprintf("%s_%s", request.Name, dbName) + + maxRetries := 3 + for i := 0; i < maxRetries; i++ { + if err := jobManager.RemoveJob(jobName); err != nil { + if i == maxRetries-1 { + log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v", dbName, i+1, maxRetries, err) + } else { + log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v, will retry", dbName, i+1, maxRetries, err) + time.Sleep(time.Second * time.Duration(i+1)) // 指数退避 + } + } else { + log.Infof("Successfully removed sync task for deleted database %s", dbName) + break + } + } + } +} + +// logMonitoringStatus 记录监控状态 +func logMonitoringStatus(newDatabases []string, deletedDatabases []string, existingDatabases map[string]bool) { + if len(newDatabases) == 0 && len(deletedDatabases) == 0 { + log.Infof("No database changes detected, currently have %d databases", len(existingDatabases)) + } +} + +func getDatabaseList(spec *base.Spec) ([]string, error) { + log.Infof("Getting database list for cluster %s", spec.Host) + + // 使用Specer接口的GetAllDatabases方法 + databases, err := spec.GetAllDatabases() + if err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "Failed to get database list") + } + + log.Infof("Got %d user databases: %v", len(databases), databases) + return databases, nil +} + // return exit(bool) func (s *HttpService) redirect(jobName string, w http.ResponseWriter, r *http.Request) bool { if jobExist, err := s.db.IsJobExist(jobName); err != nil { @@ -205,12 +446,20 @@ func (s *HttpService) createHandler(w http.ResponseWriter, r *http.Request) { return } - // Call the createCcr function to create the CCR - if err = createCcr(&request, s.db, s.jobManager); err != nil { - log.Warnf("create ccr failed: %+v", err) - createResult = newErrorResult(err.Error()) + if request.ClusterSync { + if err = createClusterCcr(&request, s.db, s.jobManager); err != nil { + log.Warnf("create cluster ccr failed: %+v", err) + createResult = newErrorResult(err.Error()) + } else { + createResult = newSuccessResult() + } } else { - createResult = newSuccessResult() + if err = createCcr(&request, s.db, s.jobManager); err != nil { + log.Warnf("create ccr failed: %+v", err) + createResult = newErrorResult(err.Error()) + } else { + createResult = newSuccessResult() + } } } From 3b19b7129438d63507e33c05619b907283d84055 Mon Sep 17 00:00:00 2001 From: carolinchen Date: Wed, 27 Aug 2025 17:56:48 +0800 Subject: [PATCH 2/2] feat: add global sync functionality for cross-cluster synchronization This commit introduces a comprehensive global synchronization feature that enables synchronization of global objects between Doris clusters. Features: - Support for global snapshot creation with configurable options - Flexible sync options: all, backup_privilege, backup_catalog, backup_workload_group - Automatic backup completion monitoring with timeout handling - Global snapshot information retrieval and processing - SQL statement execution on destination cluster - Comprehensive error handling and logging throughout the process API Endpoint: - POST /sync_global - Handles global synchronization requests Request Structure: - name: Unique identifier for the sync operation - src: Source cluster specification - dest: Destination cluster specification - Sync options (at least one required if 'all' is not set): - all: Sync all global objects - backup_privilege: Sync user privileges - backup_catalog: Sync catalog information - backup_workload_group: Sync workload group settings Workflow: 1. Create global snapshot on source cluster 2. Wait for backup completion with polling mechanism 3. Retrieve global snapshot details via RPC 4. Convert snapshot data to SQL statements 5. Execute SQL statements on destination cluster Additional improvements: - Internationalize all Chinese logs and comments to English - Refactor validation logic for flexible option combinations - Decompose syncGlobal function into smaller, focused functions This feature enables seamless migration and synchronization of global configurations between Doris clusters, supporting various deployment scenarios including disaster recovery and cluster migration. --- pkg/ccr/base/spec.go | 124 +- pkg/ccr/base/specer.go | 3 + pkg/ccr/utils.go | 4 + pkg/rpc/fe.go | 44 + .../frontendservice/FrontendService.go | 3096 ++++++++++++----- .../frontendservice/frontendservice/client.go | 6 + .../frontendservice/frontendservice.go | 29 + .../frontendservice/k-FrontendService.go | 1041 ++++++ pkg/rpc/thrift/FrontendService.thrift | 19 + pkg/service/http_service.go | 228 +- 10 files changed, 3771 insertions(+), 823 deletions(-) diff --git a/pkg/ccr/base/spec.go b/pkg/ccr/base/spec.go index 29bb1997..4d63683b 100644 --- a/pkg/ccr/base/spec.go +++ b/pkg/ccr/base/spec.go @@ -83,7 +83,7 @@ func ParseBackupState(state string) BackupState { } } -// isSystemDatabase 判断是否为系统数据库，需要跳过 +// isSystemDatabase determines if it's a system database that should be skipped func isSystemDatabase(dbName string) bool { systemDatabases := []string{ "information_schema", @@ -501,7 +501,7 @@ func (s *Spec) GetAllDatabases() ([]string, error) { if err := rows.Scan(&database); err != nil { return nil, xerror.Wrapf(err, xerror.Normal, "scan database failed") } - // 过滤系统数据库 + // Filter system databases if !isSystemDatabase(database) { databases = append(databases, database) } @@ -823,6 +823,45 @@ func (s *Spec) CreateSnapshot(snapshotName string, tables []string) error { return nil } +// CreateGlobalSnapshot creates a global snapshot for synchronizing global objects +// Sets different properties based on different options +func (s *Spec) CreateGlobalSnapshot(snapshotName string, backupPrivilege, backupCatalog, backupWorkloadGroup bool) error { + log.Infof("Creating global snapshot %s", snapshotName) + + db, err := s.Connect() + if err != nil { + return err + } + + // Build SQL statement + sql := fmt.Sprintf("BACKUP GLOBAL SNAPSHOT %s TO `__keep_on_local__`", utils.FormatKeywordName(snapshotName)) + + // Add properties based on different options + properties := make([]string, 0) + if backupPrivilege { + properties = append(properties, "\"backup_privilege\" = \"true\"") + } + if backupCatalog { + properties = append(properties, "\"backup_catalog\" = \"true\"") + } + if backupWorkloadGroup { + properties = append(properties, "\"backup_workload_group\" = \"true\"") + } + + // If there are properties, add PROPERTIES clause + if len(properties) > 0 { + sql += fmt.Sprintf(" PROPERTIES (%s)", strings.Join(properties, ", ")) + } + + log.Infof("Creating global snapshot SQL: %s", sql) + _, err = db.Exec(sql) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to create global snapshot %s, SQL: %s", snapshotName, sql) + } + + return nil +} + // mysql> BACKUP SNAPSHOT ccr.snapshot_20230605 TO `__keep_on_local__` ON (src_1 PARTITION (`p1`)) PROPERTIES ("type" = "full"); func (s *Spec) CreatePartialSnapshot(snapshotName, table string, partitions []string) error { if len(table) == 0 { @@ -897,6 +936,87 @@ func (s *Spec) checkBackupFinished(snapshotName string) (BackupState, string, er return BackupStateUnknown, "", xerror.Errorf(xerror.Normal, "no backup state found, sql: %s", sql) } +// checkGlobalBackupFinished checks global backup status +func (s *Spec) checkGlobalBackupFinished(snapshotName string) (BackupState, string, error) { + log.Tracef("Checking global backup status %s", snapshotName) + + db, err := s.Connect() + if err != nil { + return BackupStateUnknown, "", err + } + + sql := fmt.Sprintf("SHOW GLOBAL BACKUP WHERE SnapshotName = \"%s\"", snapshotName) + log.Infof("Checking global backup status SQL: %s", sql) + rows, err := db.Query(sql) + if err != nil { + return BackupStateUnknown, "", xerror.Wrapf(err, xerror.Normal, "Failed to query global backup status, SQL: %s", sql) + } + defer rows.Close() + + if rows.Next() { + rowParser := utils.NewRowParser() + if err := rowParser.Parse(rows); err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, sql) + } + + stateStr, err := rowParser.GetString("State") + if err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, "Failed to parse global backup State") + } + + status, err := rowParser.GetString("Status") + if err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, "Failed to parse global backup Status") + } + + log.Infof("Checking global snapshot %s backup status: [%v]", snapshotName, stateStr) + return ParseBackupState(stateStr), status, nil + } + + if err := rows.Err(); err != nil { + return BackupStateUnknown, "", xerror.Wrapf(err, xerror.Normal, "Check global backup status, SQL: %s", sql) + } + + return BackupStateUnknown, "", xerror.Errorf(xerror.Normal, "Global backup status not found, SQL: %s", sql) +} + +// CheckGlobalBackupFinished checks if global backup is finished +func (s *Spec) CheckGlobalBackupFinished(snapshotName string) (bool, error) { + log.Tracef("Checking if global backup is finished, spec: %s, snapshot: %s", s.String(), snapshotName) + + // Retry network related errors to avoid full sync when target network is interrupted or process is restarted + if backupState, status, err := s.checkGlobalBackupFinished(snapshotName); err != nil && !isNetworkRelated(err) { + return false, err + } else if err == nil && backupState == BackupStateFinished { + return true, nil + } else if err == nil && backupState == BackupStateCancelled { + return false, xerror.Errorf(xerror.Normal, "Global backup failed or cancelled, backup status: %s", status) + } else { + // BackupStatePending, BackupStateUnknown or network related errors + if err != nil { + log.Warnf("Failed to check global backup status, spec: %s, snapshot: %s, err: %v", s.String(), snapshotName, err) + } + return false, nil + } +} + +func (s *Spec) RestoreGlobalInfo(sqls string) error { + log.Infof("Restoring global information") + + db, err := s.Connect() + if err != nil { + return err + } + + log.Infof("Executing global restore SQL: %s", sqls) + _, err = db.Exec(sqls) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to restore global information, SQL: %s", sqls) + } + + return nil +} + func (s *Spec) CheckBackupFinished(snapshotName string) (bool, error) { log.Tracef("check backup state, spec: %s, snapshot: %s", s.String(), snapshotName) diff --git a/pkg/ccr/base/specer.go b/pkg/ccr/base/specer.go index a64c7e5c..d3b9c3e4 100644 --- a/pkg/ccr/base/specer.go +++ b/pkg/ccr/base/specer.go @@ -47,7 +47,10 @@ type Specer interface { CancelRestoreIfExists(snapshotName string) error CreatePartialSnapshot(snapshotName, table string, partitions []string) error CreateSnapshot(snapshotName string, tables []string) error + CreateGlobalSnapshot(snapshotName string, backupPrivilege, backupCatalog, backupWorkloadGroup bool) error + RestoreGlobalInfo(sqls string) error CheckBackupFinished(snapshotName string) (bool, error) + CheckGlobalBackupFinished(snapshotName string) (bool, error) CheckRestoreFinished(snapshotName string) (bool, error) GetRestoreSignatureNotMatchedTableOrView(snapshotName string) (string, bool, error) WaitTransactionDone(txnId int64) // busy wait diff --git a/pkg/ccr/utils.go b/pkg/ccr/utils.go index 1c6a0480..a7f55457 100644 --- a/pkg/ccr/utils.go +++ b/pkg/ccr/utils.go @@ -55,6 +55,10 @@ func NewBackupJobInfoFromJson(data []byte) (*BackupJobInfo, error) { return jobInfo, nil } +func NewBackupSqlsFromBytes(backupSqls []byte) (string, error) { + return string(backupSqls), nil +} + func (i *BackupJobInfo) TableNameMapping() map[int64]string { tableMapping := make(map[int64]string) for tableName, tableInfo := range i.BackupObjects { diff --git a/pkg/rpc/fe.go b/pkg/rpc/fe.go index 4f85b00d..5c057ebf 100644 --- a/pkg/rpc/fe.go +++ b/pkg/rpc/fe.go @@ -108,6 +108,7 @@ type IFeRpc interface { GetBinlog(*base.Spec, int64, int64) (*festruct.TGetBinlogResult_, error) GetBinlogLag(*base.Spec, int64) (*festruct.TGetBinlogLagResult_, error) GetSnapshot(*base.Spec, string, bool) (*festruct.TGetSnapshotResult_, error) + GetGlobalSnapshot(*base.Spec, string) (*festruct.TGetGlobalSnapshotResult_, error) RestoreSnapshot(*base.Spec, *RestoreSnapshotRequest) (*festruct.TRestoreSnapshotResult_, error) GetMasterToken(*base.Spec) (*festruct.TGetMasterTokenResult_, error) GetDbMeta(spec *base.Spec) (*festruct.TGetMetaResult_, error) @@ -471,6 +472,14 @@ func (rpc *FeRpc) GetSnapshot(spec *base.Spec, labelName string, compress bool) return convertResult[festruct.TGetSnapshotResult_](result, err) } +func (rpc *FeRpc) GetGlobalSnapshot(spec *base.Spec, labelName string) (*festruct.TGetGlobalSnapshotResult_, error) { + caller := func(client IFeRpc) (resultType, error) { + return client.GetGlobalSnapshot(spec, labelName) + } + result, err := rpc.callWithMasterRedirect(caller) + return convertResult[festruct.TGetGlobalSnapshotResult_](result, err) +} + func (rpc *FeRpc) RestoreSnapshot(spec *base.Spec, req *RestoreSnapshotRequest) (*festruct.TRestoreSnapshotResult_, error) { caller := func(client IFeRpc) (resultType, error) { return client.RestoreSnapshot(spec, req) @@ -801,6 +810,41 @@ func (rpc *singleFeClient) GetSnapshot(spec *base.Spec, labelName string, compre } } +// struct TGetGlobalSnapshotRequest { +// 1: optional string cluster +// 2: optional string user +// 3: optional string passwd +// 4: optional string token +// 5: optional string label_name +// 6: optional string snapshot_name +// 7: optional TSnapshotType snapshot_type +// } +// +// Get Global Snapshot rpc +func (rpc *singleFeClient) GetGlobalSnapshot(spec *base.Spec, labelName string) (*festruct.TGetGlobalSnapshotResult_, error) { + log.Tracef("Call GetGlobalSnapshot, addr: %s, spec: %s, label: %s", rpc.Address(), spec, labelName) + + defer xmetrics.RecordFeRpc("GetGlobalSnapshot", rpc.addr)() + + client := rpc.client + snapshotType := festruct.TSnapshotType_LOCAL + req := &festruct.TGetGlobalSnapshotRequest{ + Cluster: &spec.Cluster, + User: &spec.User, + Passwd: &spec.Password, + SnapshotName: &labelName, + SnapshotType: &snapshotType, + } + + log.Tracef("GetGlobalSnapshotRequest user %s, cluster %s, snapshot name %s, snapshot type %d", + req.GetUser(), req.GetCluster(), req.GetSnapshotName(), req.GetSnapshotType()) + if resp, err := client.GetGlobalSnapshot(context.Background(), req); err != nil { + return nil, xerror.Wrapf(err, xerror.RPC, "GetGlobalSnapshot error: %v, req: %+v", err, req) + } else { + return resp, nil + } +} + // struct TRestoreSnapshotRequest { // 1: optional string cluster // 2: optional string user diff --git a/pkg/rpc/kitex_gen/frontendservice/FrontendService.go b/pkg/rpc/kitex_gen/frontendservice/FrontendService.go index 4829e665..61b76306 100644 --- a/pkg/rpc/kitex_gen/frontendservice/FrontendService.go +++ b/pkg/rpc/kitex_gen/frontendservice/FrontendService.go @@ -53734,6 +53734,1094 @@ func (p *TGetSnapshotResult_) Field7DeepEqual(src *int64) bool { return true } +type TGetGlobalSnapshotRequest struct { + Cluster *string `thrift:"cluster,1,optional" frugal:"1,optional,string" json:"cluster,omitempty"` + User *string `thrift:"user,2,optional" frugal:"2,optional,string" json:"user,omitempty"` + Passwd *string `thrift:"passwd,3,optional" frugal:"3,optional,string" json:"passwd,omitempty"` + Token *string `thrift:"token,4,optional" frugal:"4,optional,string" json:"token,omitempty"` + LabelName *string `thrift:"label_name,5,optional" frugal:"5,optional,string" json:"label_name,omitempty"` + SnapshotName *string `thrift:"snapshot_name,6,optional" frugal:"6,optional,string" json:"snapshot_name,omitempty"` + SnapshotType *TSnapshotType `thrift:"snapshot_type,7,optional" frugal:"7,optional,TSnapshotType" json:"snapshot_type,omitempty"` +} + +func NewTGetGlobalSnapshotRequest() *TGetGlobalSnapshotRequest { + return &TGetGlobalSnapshotRequest{} +} + +func (p *TGetGlobalSnapshotRequest) InitDefault() { +} + +var TGetGlobalSnapshotRequest_Cluster_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetCluster() (v string) { + if !p.IsSetCluster() { + return TGetGlobalSnapshotRequest_Cluster_DEFAULT + } + return *p.Cluster +} + +var TGetGlobalSnapshotRequest_User_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetUser() (v string) { + if !p.IsSetUser() { + return TGetGlobalSnapshotRequest_User_DEFAULT + } + return *p.User +} + +var TGetGlobalSnapshotRequest_Passwd_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetPasswd() (v string) { + if !p.IsSetPasswd() { + return TGetGlobalSnapshotRequest_Passwd_DEFAULT + } + return *p.Passwd +} + +var TGetGlobalSnapshotRequest_Token_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetToken() (v string) { + if !p.IsSetToken() { + return TGetGlobalSnapshotRequest_Token_DEFAULT + } + return *p.Token +} + +var TGetGlobalSnapshotRequest_LabelName_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetLabelName() (v string) { + if !p.IsSetLabelName() { + return TGetGlobalSnapshotRequest_LabelName_DEFAULT + } + return *p.LabelName +} + +var TGetGlobalSnapshotRequest_SnapshotName_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetSnapshotName() (v string) { + if !p.IsSetSnapshotName() { + return TGetGlobalSnapshotRequest_SnapshotName_DEFAULT + } + return *p.SnapshotName +} + +var TGetGlobalSnapshotRequest_SnapshotType_DEFAULT TSnapshotType + +func (p *TGetGlobalSnapshotRequest) GetSnapshotType() (v TSnapshotType) { + if !p.IsSetSnapshotType() { + return TGetGlobalSnapshotRequest_SnapshotType_DEFAULT + } + return *p.SnapshotType +} +func (p *TGetGlobalSnapshotRequest) SetCluster(val *string) { + p.Cluster = val +} +func (p *TGetGlobalSnapshotRequest) SetUser(val *string) { + p.User = val +} +func (p *TGetGlobalSnapshotRequest) SetPasswd(val *string) { + p.Passwd = val +} +func (p *TGetGlobalSnapshotRequest) SetToken(val *string) { + p.Token = val +} +func (p *TGetGlobalSnapshotRequest) SetLabelName(val *string) { + p.LabelName = val +} +func (p *TGetGlobalSnapshotRequest) SetSnapshotName(val *string) { + p.SnapshotName = val +} +func (p *TGetGlobalSnapshotRequest) SetSnapshotType(val *TSnapshotType) { + p.SnapshotType = val +} + +var fieldIDToName_TGetGlobalSnapshotRequest = map[int16]string{ + 1: "cluster", + 2: "user", + 3: "passwd", + 4: "token", + 5: "label_name", + 6: "snapshot_name", + 7: "snapshot_type", +} + +func (p *TGetGlobalSnapshotRequest) IsSetCluster() bool { + return p.Cluster != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetUser() bool { + return p.User != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetPasswd() bool { + return p.Passwd != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetToken() bool { + return p.Token != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetLabelName() bool { + return p.LabelName != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetSnapshotName() bool { + return p.SnapshotName != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetSnapshotType() bool { + return p.SnapshotType != nil +} + +func (p *TGetGlobalSnapshotRequest) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRING { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRING { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.STRING { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 6: + if fieldTypeId == thrift.STRING { + if err = p.ReadField6(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 7: + if fieldTypeId == thrift.I32 { + if err = p.ReadField7(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Cluster = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.User = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField3(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Passwd = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField4(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Token = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField5(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.LabelName = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField6(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.SnapshotName = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField7(iprot thrift.TProtocol) error { + + var _field *TSnapshotType + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + tmp := TSnapshotType(v) + _field = &tmp + } + p.SnapshotType = _field + return nil +} + +func (p *TGetGlobalSnapshotRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("TGetGlobalSnapshotRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + if err = p.writeField6(oprot); err != nil { + fieldId = 6 + goto WriteFieldError + } + if err = p.writeField7(oprot); err != nil { + fieldId = 7 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetCluster() { + if err = oprot.WriteFieldBegin("cluster", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Cluster); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetUser() { + if err = oprot.WriteFieldBegin("user", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.User); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetPasswd() { + if err = oprot.WriteFieldBegin("passwd", thrift.STRING, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Passwd); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetToken() { + if err = oprot.WriteFieldBegin("token", thrift.STRING, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Token); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetLabelName() { + if err = oprot.WriteFieldBegin("label_name", thrift.STRING, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.LabelName); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField6(oprot thrift.TProtocol) (err error) { + if p.IsSetSnapshotName() { + if err = oprot.WriteFieldBegin("snapshot_name", thrift.STRING, 6); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.SnapshotName); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField7(oprot thrift.TProtocol) (err error) { + if p.IsSetSnapshotType() { + if err = oprot.WriteFieldBegin("snapshot_type", thrift.I32, 7); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(int32(*p.SnapshotType)); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("TGetGlobalSnapshotRequest(%+v)", *p) + +} + +func (p *TGetGlobalSnapshotRequest) DeepEqual(ano *TGetGlobalSnapshotRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Cluster) { + return false + } + if !p.Field2DeepEqual(ano.User) { + return false + } + if !p.Field3DeepEqual(ano.Passwd) { + return false + } + if !p.Field4DeepEqual(ano.Token) { + return false + } + if !p.Field5DeepEqual(ano.LabelName) { + return false + } + if !p.Field6DeepEqual(ano.SnapshotName) { + return false + } + if !p.Field7DeepEqual(ano.SnapshotType) { + return false + } + return true +} + +func (p *TGetGlobalSnapshotRequest) Field1DeepEqual(src *string) bool { + + if p.Cluster == src { + return true + } else if p.Cluster == nil || src == nil { + return false + } + if strings.Compare(*p.Cluster, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field2DeepEqual(src *string) bool { + + if p.User == src { + return true + } else if p.User == nil || src == nil { + return false + } + if strings.Compare(*p.User, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field3DeepEqual(src *string) bool { + + if p.Passwd == src { + return true + } else if p.Passwd == nil || src == nil { + return false + } + if strings.Compare(*p.Passwd, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field4DeepEqual(src *string) bool { + + if p.Token == src { + return true + } else if p.Token == nil || src == nil { + return false + } + if strings.Compare(*p.Token, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field5DeepEqual(src *string) bool { + + if p.LabelName == src { + return true + } else if p.LabelName == nil || src == nil { + return false + } + if strings.Compare(*p.LabelName, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field6DeepEqual(src *string) bool { + + if p.SnapshotName == src { + return true + } else if p.SnapshotName == nil || src == nil { + return false + } + if strings.Compare(*p.SnapshotName, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field7DeepEqual(src *TSnapshotType) bool { + + if p.SnapshotType == src { + return true + } else if p.SnapshotType == nil || src == nil { + return false + } + if *p.SnapshotType != *src { + return false + } + return true +} + +type TGetGlobalSnapshotResult_ struct { + Status *status.TStatus `thrift:"status,1,optional" frugal:"1,optional,status.TStatus" json:"status,omitempty"` + GlobalInfo []byte `thrift:"global_info,2,optional" frugal:"2,optional,binary" json:"global_info,omitempty"` + MasterAddress *types.TNetworkAddress `thrift:"master_address,3,optional" frugal:"3,optional,types.TNetworkAddress" json:"master_address,omitempty"` + ExpiredAt *int64 `thrift:"expiredAt,4,optional" frugal:"4,optional,i64" json:"expiredAt,omitempty"` + CommitSeq *int64 `thrift:"commit_seq,5,optional" frugal:"5,optional,i64" json:"commit_seq,omitempty"` +} + +func NewTGetGlobalSnapshotResult_() *TGetGlobalSnapshotResult_ { + return &TGetGlobalSnapshotResult_{} +} + +func (p *TGetGlobalSnapshotResult_) InitDefault() { +} + +var TGetGlobalSnapshotResult__Status_DEFAULT *status.TStatus + +func (p *TGetGlobalSnapshotResult_) GetStatus() (v *status.TStatus) { + if !p.IsSetStatus() { + return TGetGlobalSnapshotResult__Status_DEFAULT + } + return p.Status +} + +var TGetGlobalSnapshotResult__GlobalInfo_DEFAULT []byte + +func (p *TGetGlobalSnapshotResult_) GetGlobalInfo() (v []byte) { + if !p.IsSetGlobalInfo() { + return TGetGlobalSnapshotResult__GlobalInfo_DEFAULT + } + return p.GlobalInfo +} + +var TGetGlobalSnapshotResult__MasterAddress_DEFAULT *types.TNetworkAddress + +func (p *TGetGlobalSnapshotResult_) GetMasterAddress() (v *types.TNetworkAddress) { + if !p.IsSetMasterAddress() { + return TGetGlobalSnapshotResult__MasterAddress_DEFAULT + } + return p.MasterAddress +} + +var TGetGlobalSnapshotResult__ExpiredAt_DEFAULT int64 + +func (p *TGetGlobalSnapshotResult_) GetExpiredAt() (v int64) { + if !p.IsSetExpiredAt() { + return TGetGlobalSnapshotResult__ExpiredAt_DEFAULT + } + return *p.ExpiredAt +} + +var TGetGlobalSnapshotResult__CommitSeq_DEFAULT int64 + +func (p *TGetGlobalSnapshotResult_) GetCommitSeq() (v int64) { + if !p.IsSetCommitSeq() { + return TGetGlobalSnapshotResult__CommitSeq_DEFAULT + } + return *p.CommitSeq +} +func (p *TGetGlobalSnapshotResult_) SetStatus(val *status.TStatus) { + p.Status = val +} +func (p *TGetGlobalSnapshotResult_) SetGlobalInfo(val []byte) { + p.GlobalInfo = val +} +func (p *TGetGlobalSnapshotResult_) SetMasterAddress(val *types.TNetworkAddress) { + p.MasterAddress = val +} +func (p *TGetGlobalSnapshotResult_) SetExpiredAt(val *int64) { + p.ExpiredAt = val +} +func (p *TGetGlobalSnapshotResult_) SetCommitSeq(val *int64) { + p.CommitSeq = val +} + +var fieldIDToName_TGetGlobalSnapshotResult_ = map[int16]string{ + 1: "status", + 2: "global_info", + 3: "master_address", + 4: "expiredAt", + 5: "commit_seq", +} + +func (p *TGetGlobalSnapshotResult_) IsSetStatus() bool { + return p.Status != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetGlobalInfo() bool { + return p.GlobalInfo != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetMasterAddress() bool { + return p.MasterAddress != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetExpiredAt() bool { + return p.ExpiredAt != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetCommitSeq() bool { + return p.CommitSeq != nil +} + +func (p *TGetGlobalSnapshotResult_) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.I64 { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.I64 { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotResult_[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) ReadField1(iprot thrift.TProtocol) error { + _field := status.NewTStatus() + if err := _field.Read(iprot); err != nil { + return err + } + p.Status = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField2(iprot thrift.TProtocol) error { + + var _field []byte + if v, err := iprot.ReadBinary(); err != nil { + return err + } else { + _field = []byte(v) + } + p.GlobalInfo = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField3(iprot thrift.TProtocol) error { + _field := types.NewTNetworkAddress() + if err := _field.Read(iprot); err != nil { + return err + } + p.MasterAddress = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField4(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ExpiredAt = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField5(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.CommitSeq = _field + return nil +} + +func (p *TGetGlobalSnapshotResult_) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("TGetGlobalSnapshotResult"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetStatus() { + if err = oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Status.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetGlobalInfo() { + if err = oprot.WriteFieldBegin("global_info", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBinary([]byte(p.GlobalInfo)); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetMasterAddress() { + if err = oprot.WriteFieldBegin("master_address", thrift.STRUCT, 3); err != nil { + goto WriteFieldBeginError + } + if err := p.MasterAddress.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetExpiredAt() { + if err = oprot.WriteFieldBegin("expiredAt", thrift.I64, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ExpiredAt); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitSeq() { + if err = oprot.WriteFieldBegin("commit_seq", thrift.I64, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.CommitSeq); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("TGetGlobalSnapshotResult_(%+v)", *p) + +} + +func (p *TGetGlobalSnapshotResult_) DeepEqual(ano *TGetGlobalSnapshotResult_) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Status) { + return false + } + if !p.Field2DeepEqual(ano.GlobalInfo) { + return false + } + if !p.Field3DeepEqual(ano.MasterAddress) { + return false + } + if !p.Field4DeepEqual(ano.ExpiredAt) { + return false + } + if !p.Field5DeepEqual(ano.CommitSeq) { + return false + } + return true +} + +func (p *TGetGlobalSnapshotResult_) Field1DeepEqual(src *status.TStatus) bool { + + if !p.Status.DeepEqual(src) { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field2DeepEqual(src []byte) bool { + + if bytes.Compare(p.GlobalInfo, src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field3DeepEqual(src *types.TNetworkAddress) bool { + + if !p.MasterAddress.DeepEqual(src) { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field4DeepEqual(src *int64) bool { + + if p.ExpiredAt == src { + return true + } else if p.ExpiredAt == nil || src == nil { + return false + } + if *p.ExpiredAt != *src { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field5DeepEqual(src *int64) bool { + + if p.CommitSeq == src { + return true + } else if p.CommitSeq == nil || src == nil { + return false + } + if *p.CommitSeq != *src { + return false + } + return true +} + type TTableRef struct { Table *string `thrift:"table,1,optional" frugal:"1,optional,string" json:"table,omitempty"` AliasName *string `thrift:"alias_name,3,optional" frugal:"3,optional,string" json:"alias_name,omitempty"` @@ -74380,6 +75468,8 @@ type FrontendService interface { GetSnapshot(ctx context.Context, request *TGetSnapshotRequest) (r *TGetSnapshotResult_, err error) + GetGlobalSnapshot(ctx context.Context, request *TGetGlobalSnapshotRequest) (r *TGetGlobalSnapshotResult_, err error) + RestoreSnapshot(ctx context.Context, request *TRestoreSnapshotRequest) (r *TRestoreSnapshotResult_, err error) LockBinlog(ctx context.Context, request *TLockBinlogRequest) (r *TLockBinlogResult_, err error) @@ -74705,6 +75795,15 @@ func (p *FrontendServiceClient) GetSnapshot(ctx context.Context, request *TGetSn } return _result.GetSuccess(), nil } +func (p *FrontendServiceClient) GetGlobalSnapshot(ctx context.Context, request *TGetGlobalSnapshotRequest) (r *TGetGlobalSnapshotResult_, err error) { + var _args FrontendServiceGetGlobalSnapshotArgs + _args.Request = request + var _result FrontendServiceGetGlobalSnapshotResult + if err = p.Client_().Call(ctx, "getGlobalSnapshot", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} func (p *FrontendServiceClient) RestoreSnapshot(ctx context.Context, request *TRestoreSnapshotRequest) (r *TRestoreSnapshotResult_, err error) { var _args FrontendServiceRestoreSnapshotArgs _args.Request = request @@ -75083,6 +76182,7 @@ func NewFrontendServiceProcessor(handler FrontendService) *FrontendServiceProces self.AddToProcessorMap("rollbackTxn", &frontendServiceProcessorRollbackTxn{handler: handler}) self.AddToProcessorMap("getBinlog", &frontendServiceProcessorGetBinlog{handler: handler}) self.AddToProcessorMap("getSnapshot", &frontendServiceProcessorGetSnapshot{handler: handler}) + self.AddToProcessorMap("getGlobalSnapshot", &frontendServiceProcessorGetGlobalSnapshot{handler: handler}) self.AddToProcessorMap("restoreSnapshot", &frontendServiceProcessorRestoreSnapshot{handler: handler}) self.AddToProcessorMap("lockBinlog", &frontendServiceProcessorLockBinlog{handler: handler}) self.AddToProcessorMap("waitingTxnStatus", &frontendServiceProcessorWaitingTxnStatus{handler: handler}) @@ -76340,6 +77440,54 @@ func (p *frontendServiceProcessorGetSnapshot) Process(ctx context.Context, seqId return true, err } +type frontendServiceProcessorGetGlobalSnapshot struct { + handler FrontendService +} + +func (p *frontendServiceProcessorGetGlobalSnapshot) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := FrontendServiceGetGlobalSnapshotArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getGlobalSnapshot", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := FrontendServiceGetGlobalSnapshotResult{} + var retval *TGetGlobalSnapshotResult_ + if retval, err2 = p.handler.GetGlobalSnapshot(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getGlobalSnapshot: "+err2.Error()) + oprot.WriteMessageBegin("getGlobalSnapshot", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getGlobalSnapshot", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + type frontendServiceProcessorRestoreSnapshot struct { handler FrontendService } @@ -80449,7 +81597,270 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceReportResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceReportResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *FrontendServiceReportResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("FrontendServiceReportResult(%+v)", *p) + +} + +func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMasterResult_) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type FrontendServiceFetchResourceArgs struct { +} + +func NewFrontendServiceFetchResourceArgs() *FrontendServiceFetchResourceArgs { + return &FrontendServiceFetchResourceArgs{} +} + +func (p *FrontendServiceFetchResourceArgs) InitDefault() { +} + +var fieldIDToName_FrontendServiceFetchResourceArgs = map[int16]string{} + +func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldTypeError + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +SkipFieldTypeError: + return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteStructBegin("fetchResource_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("FrontendServiceFetchResourceArgs(%+v)", *p) + +} + +func (p *FrontendServiceFetchResourceArgs) DeepEqual(ano *FrontendServiceFetchResourceArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + return true +} + +type FrontendServiceFetchResourceResult struct { + Success *masterservice.TFetchResourceResult_ `thrift:"success,0,optional" frugal:"0,optional,masterservice.TFetchResourceResult_" json:"success,omitempty"` +} + +func NewFrontendServiceFetchResourceResult() *FrontendServiceFetchResourceResult { + return &FrontendServiceFetchResourceResult{} +} + +func (p *FrontendServiceFetchResourceResult) InitDefault() { +} + +var FrontendServiceFetchResourceResult_Success_DEFAULT *masterservice.TFetchResourceResult_ + +func (p *FrontendServiceFetchResourceResult) GetSuccess() (v *masterservice.TFetchResourceResult_) { + if !p.IsSetSuccess() { + return FrontendServiceFetchResourceResult_Success_DEFAULT + } + return p.Success +} +func (p *FrontendServiceFetchResourceResult) SetSuccess(x interface{}) { + p.Success = x.(*masterservice.TFetchResourceResult_) +} + +var fieldIDToName_FrontendServiceFetchResourceResult = map[int16]string{ + 0: "success", +} + +func (p *FrontendServiceFetchResourceResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *FrontendServiceFetchResourceResult) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceFetchResourceResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) error { + _field := masterservice.NewTFetchResourceResult_() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *FrontendServiceFetchResourceResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("fetchResource_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -80468,15 +81879,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceReportResult) String() string { +func (p *FrontendServiceFetchResourceResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceReportResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceFetchResourceResult(%+v)", *p) } -func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult) bool { +func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetchResourceResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80488,7 +81899,7 @@ func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult return true } -func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMasterResult_) bool { +func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice.TFetchResourceResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -80496,19 +81907,38 @@ func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMaster return true } -type FrontendServiceFetchResourceArgs struct { +type FrontendServiceForwardArgs struct { + Params *TMasterOpRequest `thrift:"params,1" frugal:"1,default,TMasterOpRequest" json:"params"` } -func NewFrontendServiceFetchResourceArgs() *FrontendServiceFetchResourceArgs { - return &FrontendServiceFetchResourceArgs{} +func NewFrontendServiceForwardArgs() *FrontendServiceForwardArgs { + return &FrontendServiceForwardArgs{} } -func (p *FrontendServiceFetchResourceArgs) InitDefault() { +func (p *FrontendServiceForwardArgs) InitDefault() { } -var fieldIDToName_FrontendServiceFetchResourceArgs = map[int16]string{} +var FrontendServiceForwardArgs_Params_DEFAULT *TMasterOpRequest -func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardArgs) GetParams() (v *TMasterOpRequest) { + if !p.IsSetParams() { + return FrontendServiceForwardArgs_Params_DEFAULT + } + return p.Params +} +func (p *FrontendServiceForwardArgs) SetParams(val *TMasterOpRequest) { + p.Params = val +} + +var fieldIDToName_FrontendServiceForwardArgs = map[int16]string{ + 1: "params", +} + +func (p *FrontendServiceForwardArgs) IsSetParams() bool { + return p.Params != nil +} + +func (p *FrontendServiceForwardArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80525,8 +81955,20 @@ func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err err if fieldTypeId == thrift.STOP { break } - if err = iprot.Skip(fieldTypeId); err != nil { - goto SkipFieldTypeError + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } } if err = iprot.ReadFieldEnd(); err != nil { goto ReadFieldEndError @@ -80541,8 +81983,10 @@ ReadStructBeginError: return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) -SkipFieldTypeError: - return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, fieldTypeId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) ReadFieldEndError: return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) @@ -80550,11 +81994,25 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteStructBegin("fetchResource_args"); err != nil { +func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTMasterOpRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Params = _field + return nil +} + +func (p *FrontendServiceForwardArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("forward_args"); err != nil { goto WriteStructBeginError } if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } } if err = oprot.WriteFieldStop(); err != nil { goto WriteFieldStopError @@ -80565,61 +82023,91 @@ func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err er return nil WriteStructBeginError: return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) WriteFieldStopError: return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceArgs) String() string { +func (p *FrontendServiceForwardArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Params.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *FrontendServiceForwardArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceFetchResourceArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceForwardArgs(%+v)", *p) } -func (p *FrontendServiceFetchResourceArgs) DeepEqual(ano *FrontendServiceFetchResourceArgs) bool { +func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) bool { if p == ano { return true } else if p == nil || ano == nil { return false } + if !p.Field1DeepEqual(ano.Params) { + return false + } return true } -type FrontendServiceFetchResourceResult struct { - Success *masterservice.TFetchResourceResult_ `thrift:"success,0,optional" frugal:"0,optional,masterservice.TFetchResourceResult_" json:"success,omitempty"` +func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool { + + if !p.Params.DeepEqual(src) { + return false + } + return true } -func NewFrontendServiceFetchResourceResult() *FrontendServiceFetchResourceResult { - return &FrontendServiceFetchResourceResult{} +type FrontendServiceForwardResult struct { + Success *TMasterOpResult_ `thrift:"success,0,optional" frugal:"0,optional,TMasterOpResult_" json:"success,omitempty"` } -func (p *FrontendServiceFetchResourceResult) InitDefault() { +func NewFrontendServiceForwardResult() *FrontendServiceForwardResult { + return &FrontendServiceForwardResult{} } -var FrontendServiceFetchResourceResult_Success_DEFAULT *masterservice.TFetchResourceResult_ +func (p *FrontendServiceForwardResult) InitDefault() { +} -func (p *FrontendServiceFetchResourceResult) GetSuccess() (v *masterservice.TFetchResourceResult_) { +var FrontendServiceForwardResult_Success_DEFAULT *TMasterOpResult_ + +func (p *FrontendServiceForwardResult) GetSuccess() (v *TMasterOpResult_) { if !p.IsSetSuccess() { - return FrontendServiceFetchResourceResult_Success_DEFAULT + return FrontendServiceForwardResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceFetchResourceResult) SetSuccess(x interface{}) { - p.Success = x.(*masterservice.TFetchResourceResult_) +func (p *FrontendServiceForwardResult) SetSuccess(x interface{}) { + p.Success = x.(*TMasterOpResult_) } -var fieldIDToName_FrontendServiceFetchResourceResult = map[int16]string{ +var fieldIDToName_FrontendServiceForwardResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceFetchResourceResult) IsSetSuccess() bool { +func (p *FrontendServiceForwardResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceFetchResourceResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80665,7 +82153,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceFetchResourceResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -80675,8 +82163,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) error { - _field := masterservice.NewTFetchResourceResult_() +func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTMasterOpResult_() if err := _field.Read(iprot); err != nil { return err } @@ -80684,9 +82172,9 @@ func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceFetchResourceResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("fetchResource_result"); err != nil { + if err = oprot.WriteStructBegin("forward_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -80712,7 +82200,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -80731,15 +82219,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) String() string { +func (p *FrontendServiceForwardResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceFetchResourceResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceForwardResult(%+v)", *p) } -func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetchResourceResult) bool { +func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80751,7 +82239,7 @@ func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetch return true } -func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice.TFetchResourceResult_) bool { +func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -80759,38 +82247,38 @@ func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice. return true } -type FrontendServiceForwardArgs struct { - Params *TMasterOpRequest `thrift:"params,1" frugal:"1,default,TMasterOpRequest" json:"params"` +type FrontendServiceListTableStatusArgs struct { + Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceForwardArgs() *FrontendServiceForwardArgs { - return &FrontendServiceForwardArgs{} +func NewFrontendServiceListTableStatusArgs() *FrontendServiceListTableStatusArgs { + return &FrontendServiceListTableStatusArgs{} } -func (p *FrontendServiceForwardArgs) InitDefault() { +func (p *FrontendServiceListTableStatusArgs) InitDefault() { } -var FrontendServiceForwardArgs_Params_DEFAULT *TMasterOpRequest +var FrontendServiceListTableStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceForwardArgs) GetParams() (v *TMasterOpRequest) { +func (p *FrontendServiceListTableStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceForwardArgs_Params_DEFAULT + return FrontendServiceListTableStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceForwardArgs) SetParams(val *TMasterOpRequest) { +func (p *FrontendServiceListTableStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceForwardArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTableStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceForwardArgs) IsSetParams() bool { +func (p *FrontendServiceListTableStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceForwardArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80836,7 +82324,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -80846,8 +82334,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTMasterOpRequest() +func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err } @@ -80855,9 +82343,9 @@ func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *FrontendServiceForwardArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("forward_args"); err != nil { + if err = oprot.WriteStructBegin("listTableStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -80883,7 +82371,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceForwardArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -80900,15 +82388,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceForwardArgs) String() string { +func (p *FrontendServiceListTableStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceForwardArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableStatusArgs(%+v)", *p) } -func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) bool { +func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListTableStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80920,7 +82408,7 @@ func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) return true } -func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool { +func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -80928,38 +82416,38 @@ func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool return true } -type FrontendServiceForwardResult struct { - Success *TMasterOpResult_ `thrift:"success,0,optional" frugal:"0,optional,TMasterOpResult_" json:"success,omitempty"` +type FrontendServiceListTableStatusResult struct { + Success *TListTableStatusResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableStatusResult_" json:"success,omitempty"` } -func NewFrontendServiceForwardResult() *FrontendServiceForwardResult { - return &FrontendServiceForwardResult{} +func NewFrontendServiceListTableStatusResult() *FrontendServiceListTableStatusResult { + return &FrontendServiceListTableStatusResult{} } -func (p *FrontendServiceForwardResult) InitDefault() { +func (p *FrontendServiceListTableStatusResult) InitDefault() { } -var FrontendServiceForwardResult_Success_DEFAULT *TMasterOpResult_ +var FrontendServiceListTableStatusResult_Success_DEFAULT *TListTableStatusResult_ -func (p *FrontendServiceForwardResult) GetSuccess() (v *TMasterOpResult_) { +func (p *FrontendServiceListTableStatusResult) GetSuccess() (v *TListTableStatusResult_) { if !p.IsSetSuccess() { - return FrontendServiceForwardResult_Success_DEFAULT + return FrontendServiceListTableStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceForwardResult) SetSuccess(x interface{}) { - p.Success = x.(*TMasterOpResult_) +func (p *FrontendServiceListTableStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TListTableStatusResult_) } -var fieldIDToName_FrontendServiceForwardResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTableStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceForwardResult) IsSetSuccess() bool { +func (p *FrontendServiceListTableStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceForwardResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81005,7 +82493,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81015,8 +82503,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTMasterOpResult_() +func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListTableStatusResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81024,9 +82512,9 @@ func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceForwardResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("forward_result"); err != nil { + if err = oprot.WriteStructBegin("listTableStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81052,7 +82540,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceForwardResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81071,15 +82559,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceForwardResult) String() string { +func (p *FrontendServiceListTableStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceForwardResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableStatusResult(%+v)", *p) } -func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResult) bool { +func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceListTableStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81091,7 +82579,7 @@ func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResu return true } -func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bool { +func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableStatusResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81099,38 +82587,38 @@ func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bo return true } -type FrontendServiceListTableStatusArgs struct { +type FrontendServiceListTableMetadataNameIdsArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTableStatusArgs() *FrontendServiceListTableStatusArgs { - return &FrontendServiceListTableStatusArgs{} +func NewFrontendServiceListTableMetadataNameIdsArgs() *FrontendServiceListTableMetadataNameIdsArgs { + return &FrontendServiceListTableMetadataNameIdsArgs{} } -func (p *FrontendServiceListTableStatusArgs) InitDefault() { +func (p *FrontendServiceListTableMetadataNameIdsArgs) InitDefault() { } -var FrontendServiceListTableStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTableStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTableStatusArgs_Params_DEFAULT + return FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTableStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTableStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTableStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTableStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81176,7 +82664,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81186,7 +82674,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81195,9 +82683,9 @@ func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceListTableStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listTableMetadataNameIds_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81223,7 +82711,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81240,15 +82728,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) String() string { +func (p *FrontendServiceListTableMetadataNameIdsArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsArgs(%+v)", *p) } -func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListTableStatusArgs) bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81260,7 +82748,7 @@ func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListT return true } -func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81268,38 +82756,38 @@ func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesPara return true } -type FrontendServiceListTableStatusResult struct { - Success *TListTableStatusResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableStatusResult_" json:"success,omitempty"` +type FrontendServiceListTableMetadataNameIdsResult struct { + Success *TListTableMetadataNameIdsResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableMetadataNameIdsResult_" json:"success,omitempty"` } -func NewFrontendServiceListTableStatusResult() *FrontendServiceListTableStatusResult { - return &FrontendServiceListTableStatusResult{} +func NewFrontendServiceListTableMetadataNameIdsResult() *FrontendServiceListTableMetadataNameIdsResult { + return &FrontendServiceListTableMetadataNameIdsResult{} } -func (p *FrontendServiceListTableStatusResult) InitDefault() { +func (p *FrontendServiceListTableMetadataNameIdsResult) InitDefault() { } -var FrontendServiceListTableStatusResult_Success_DEFAULT *TListTableStatusResult_ +var FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT *TListTableMetadataNameIdsResult_ -func (p *FrontendServiceListTableStatusResult) GetSuccess() (v *TListTableStatusResult_) { +func (p *FrontendServiceListTableMetadataNameIdsResult) GetSuccess() (v *TListTableMetadataNameIdsResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTableStatusResult_Success_DEFAULT + return FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTableStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TListTableStatusResult_) +func (p *FrontendServiceListTableMetadataNameIdsResult) SetSuccess(x interface{}) { + p.Success = x.(*TListTableMetadataNameIdsResult_) } -var fieldIDToName_FrontendServiceListTableStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTableMetadataNameIdsResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTableStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTableStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81345,7 +82833,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81355,8 +82843,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListTableStatusResult_() +func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListTableMetadataNameIdsResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81364,9 +82852,9 @@ func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol return nil } -func (p *FrontendServiceListTableStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listTableMetadataNameIds_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81392,7 +82880,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81411,15 +82899,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) String() string { +func (p *FrontendServiceListTableMetadataNameIdsResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsResult(%+v)", *p) } -func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceListTableStatusResult) bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81431,7 +82919,7 @@ func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceLis return true } -func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableStatusResult_) bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TListTableMetadataNameIdsResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81439,38 +82927,38 @@ func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableSt return true } -type FrontendServiceListTableMetadataNameIdsArgs struct { +type FrontendServiceListTablePrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTableMetadataNameIdsArgs() *FrontendServiceListTableMetadataNameIdsArgs { - return &FrontendServiceListTableMetadataNameIdsArgs{} +func NewFrontendServiceListTablePrivilegeStatusArgs() *FrontendServiceListTablePrivilegeStatusArgs { + return &FrontendServiceListTablePrivilegeStatusArgs{} } -func (p *FrontendServiceListTableMetadataNameIdsArgs) InitDefault() { +func (p *FrontendServiceListTablePrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTableMetadataNameIdsArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT + return FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTableMetadataNameIdsArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTableMetadataNameIdsArgs) IsSetParams() bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81516,7 +83004,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81526,7 +83014,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81535,9 +83023,9 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TP return nil } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableMetadataNameIds_args"); err != nil { + if err = oprot.WriteStructBegin("listTablePrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81563,7 +83051,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81580,15 +83068,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) String() string { +func (p *FrontendServiceListTablePrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsArgs) bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81600,7 +83088,7 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81608,38 +83096,38 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetT return true } -type FrontendServiceListTableMetadataNameIdsResult struct { - Success *TListTableMetadataNameIdsResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableMetadataNameIdsResult_" json:"success,omitempty"` +type FrontendServiceListTablePrivilegeStatusResult struct { + Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListTableMetadataNameIdsResult() *FrontendServiceListTableMetadataNameIdsResult { - return &FrontendServiceListTableMetadataNameIdsResult{} +func NewFrontendServiceListTablePrivilegeStatusResult() *FrontendServiceListTablePrivilegeStatusResult { + return &FrontendServiceListTablePrivilegeStatusResult{} } -func (p *FrontendServiceListTableMetadataNameIdsResult) InitDefault() { +func (p *FrontendServiceListTablePrivilegeStatusResult) InitDefault() { } -var FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT *TListTableMetadataNameIdsResult_ +var FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListTableMetadataNameIdsResult) GetSuccess() (v *TListTableMetadataNameIdsResult_) { +func (p *FrontendServiceListTablePrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT + return FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTableMetadataNameIdsResult) SetSuccess(x interface{}) { - p.Success = x.(*TListTableMetadataNameIdsResult_) +func (p *FrontendServiceListTablePrivilegeStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListTableMetadataNameIdsResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTablePrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTableMetadataNameIdsResult) IsSetSuccess() bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTableMetadataNameIdsResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81685,7 +83173,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81695,8 +83183,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListTableMetadataNameIdsResult_() +func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81704,9 +83192,9 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift. return nil } -func (p *FrontendServiceListTableMetadataNameIdsResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableMetadataNameIds_result"); err != nil { + if err = oprot.WriteStructBegin("listTablePrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81732,7 +83220,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81751,15 +83239,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) String() string { +func (p *FrontendServiceListTablePrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsResult) bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81771,7 +83259,7 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendS return true } -func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TListTableMetadataNameIdsResult_) bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81779,38 +83267,38 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TLi return true } -type FrontendServiceListTablePrivilegeStatusArgs struct { +type FrontendServiceListSchemaPrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTablePrivilegeStatusArgs() *FrontendServiceListTablePrivilegeStatusArgs { - return &FrontendServiceListTablePrivilegeStatusArgs{} +func NewFrontendServiceListSchemaPrivilegeStatusArgs() *FrontendServiceListSchemaPrivilegeStatusArgs { + return &FrontendServiceListSchemaPrivilegeStatusArgs{} } -func (p *FrontendServiceListTablePrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTablePrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT + return FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTablePrivilegeStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTablePrivilegeStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81856,7 +83344,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81866,7 +83354,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81875,9 +83363,9 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TP return nil } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTablePrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81903,7 +83391,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81920,15 +83408,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) String() string { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusArgs) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81940,7 +83428,7 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81948,38 +83436,38 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetT return true } -type FrontendServiceListTablePrivilegeStatusResult struct { +type FrontendServiceListSchemaPrivilegeStatusResult struct { Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListTablePrivilegeStatusResult() *FrontendServiceListTablePrivilegeStatusResult { - return &FrontendServiceListTablePrivilegeStatusResult{} +func NewFrontendServiceListSchemaPrivilegeStatusResult() *FrontendServiceListSchemaPrivilegeStatusResult { + return &FrontendServiceListSchemaPrivilegeStatusResult{} } -func (p *FrontendServiceListTablePrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) InitDefault() { } -var FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListTablePrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT + return FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTablePrivilegeStatusResult) SetSuccess(x interface{}) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) SetSuccess(x interface{}) { p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListTablePrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTablePrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTablePrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82025,7 +83513,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82035,7 +83523,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err @@ -82044,9 +83532,9 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift. return nil } -func (p *FrontendServiceListTablePrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTablePrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82072,7 +83560,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82091,15 +83579,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) String() string { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusResult) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82111,7 +83599,7 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendS return true } -func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82119,38 +83607,38 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TLi return true } -type FrontendServiceListSchemaPrivilegeStatusArgs struct { +type FrontendServiceListUserPrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListSchemaPrivilegeStatusArgs() *FrontendServiceListSchemaPrivilegeStatusArgs { - return &FrontendServiceListSchemaPrivilegeStatusArgs{} +func NewFrontendServiceListUserPrivilegeStatusArgs() *FrontendServiceListUserPrivilegeStatusArgs { + return &FrontendServiceListUserPrivilegeStatusArgs{} } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceListUserPrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT + return FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82196,7 +83684,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82206,7 +83694,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListUserPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -82215,9 +83703,9 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.T return nil } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listUserPrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82243,7 +83731,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -82260,15 +83748,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) String() string { +func (p *FrontendServiceListUserPrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusArgs) bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82280,7 +83768,7 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendSe return true } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -82288,38 +83776,38 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGet return true } -type FrontendServiceListSchemaPrivilegeStatusResult struct { +type FrontendServiceListUserPrivilegeStatusResult struct { Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListSchemaPrivilegeStatusResult() *FrontendServiceListSchemaPrivilegeStatusResult { - return &FrontendServiceListSchemaPrivilegeStatusResult{} +func NewFrontendServiceListUserPrivilegeStatusResult() *FrontendServiceListUserPrivilegeStatusResult { + return &FrontendServiceListUserPrivilegeStatusResult{} } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceListUserPrivilegeStatusResult) InitDefault() { } -var FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListSchemaPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceListUserPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT + return FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) SetSuccess(x interface{}) { +func (p *FrontendServiceListUserPrivilegeStatusResult) SetSuccess(x interface{}) { p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListUserPrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82365,7 +83853,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82375,7 +83863,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { +func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err @@ -82384,9 +83872,9 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift return nil } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listUserPrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82412,7 +83900,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82431,15 +83919,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) String() string { +func (p *FrontendServiceListUserPrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusResult) bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82451,7 +83939,7 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *Frontend return true } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82459,38 +83947,38 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TL return true } -type FrontendServiceListUserPrivilegeStatusArgs struct { - Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` +type FrontendServiceUpdateExportTaskStatusArgs struct { + Request *TUpdateExportTaskStatusRequest `thrift:"request,1" frugal:"1,default,TUpdateExportTaskStatusRequest" json:"request"` } -func NewFrontendServiceListUserPrivilegeStatusArgs() *FrontendServiceListUserPrivilegeStatusArgs { - return &FrontendServiceListUserPrivilegeStatusArgs{} +func NewFrontendServiceUpdateExportTaskStatusArgs() *FrontendServiceUpdateExportTaskStatusArgs { + return &FrontendServiceUpdateExportTaskStatusArgs{} } -func (p *FrontendServiceListUserPrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceUpdateExportTaskStatusArgs) InitDefault() { } -var FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT *TUpdateExportTaskStatusRequest -func (p *FrontendServiceListUserPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { - if !p.IsSetParams() { - return FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT +func (p *FrontendServiceUpdateExportTaskStatusArgs) GetRequest() (v *TUpdateExportTaskStatusRequest) { + if !p.IsSetRequest() { + return FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT } - return p.Params + return p.Request } -func (p *FrontendServiceListUserPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { - p.Params = val +func (p *FrontendServiceUpdateExportTaskStatusArgs) SetRequest(val *TUpdateExportTaskStatusRequest) { + p.Request = val } -var fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs = map[int16]string{ - 1: "params", +var fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs = map[int16]string{ + 1: "request", } -func (p *FrontendServiceListUserPrivilegeStatusArgs) IsSetParams() bool { - return p.Params != nil +func (p *FrontendServiceUpdateExportTaskStatusArgs) IsSetRequest() bool { + return p.Request != nil } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82536,7 +84024,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82546,18 +84034,18 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetTablesParams() +func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTUpdateExportTaskStatusRequest() if err := _field.Read(iprot); err != nil { return err } - p.Params = _field + p.Request = _field return nil } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listUserPrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("updateExportTaskStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82583,11 +84071,11 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { +func (p *FrontendServiceUpdateExportTaskStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } - if err := p.Params.Write(oprot); err != nil { + if err := p.Request.Write(oprot); err != nil { return err } if err = oprot.WriteFieldEnd(); err != nil { @@ -82600,66 +84088,66 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) String() string { +func (p *FrontendServiceUpdateExportTaskStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusArgs(%+v)", *p) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusArgs) bool { +func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { return false } - if !p.Field1DeepEqual(ano.Params) { + if !p.Field1DeepEqual(ano.Request) { return false } return true } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdateExportTaskStatusRequest) bool { - if !p.Params.DeepEqual(src) { + if !p.Request.DeepEqual(src) { return false } return true } -type FrontendServiceListUserPrivilegeStatusResult struct { - Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` +type FrontendServiceUpdateExportTaskStatusResult struct { + Success *TFeResult_ `thrift:"success,0,optional" frugal:"0,optional,TFeResult_" json:"success,omitempty"` } -func NewFrontendServiceListUserPrivilegeStatusResult() *FrontendServiceListUserPrivilegeStatusResult { - return &FrontendServiceListUserPrivilegeStatusResult{} +func NewFrontendServiceUpdateExportTaskStatusResult() *FrontendServiceUpdateExportTaskStatusResult { + return &FrontendServiceUpdateExportTaskStatusResult{} } -func (p *FrontendServiceListUserPrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceUpdateExportTaskStatusResult) InitDefault() { } -var FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT *TFeResult_ -func (p *FrontendServiceListUserPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceUpdateExportTaskStatusResult) GetSuccess() (v *TFeResult_) { if !p.IsSetSuccess() { - return FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT + return FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListUserPrivilegeStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TListPrivilegesResult_) +func (p *FrontendServiceUpdateExportTaskStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TFeResult_) } -var fieldIDToName_FrontendServiceListUserPrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceUpdateExportTaskStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListUserPrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListUserPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82705,7 +84193,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82715,8 +84203,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListPrivilegesResult_() +func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTFeResult_() if err := _field.Read(iprot); err != nil { return err } @@ -82724,9 +84212,9 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.T return nil } -func (p *FrontendServiceListUserPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listUserPrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("updateExportTaskStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82752,7 +84240,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82771,15 +84259,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) String() string { +func (p *FrontendServiceUpdateExportTaskStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusResult(%+v)", *p) } -func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusResult) bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82791,7 +84279,7 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendSe return true } -func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82799,38 +84287,38 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TLis return true } -type FrontendServiceUpdateExportTaskStatusArgs struct { - Request *TUpdateExportTaskStatusRequest `thrift:"request,1" frugal:"1,default,TUpdateExportTaskStatusRequest" json:"request"` +type FrontendServiceLoadTxnBeginArgs struct { + Request *TLoadTxnBeginRequest `thrift:"request,1" frugal:"1,default,TLoadTxnBeginRequest" json:"request"` } -func NewFrontendServiceUpdateExportTaskStatusArgs() *FrontendServiceUpdateExportTaskStatusArgs { - return &FrontendServiceUpdateExportTaskStatusArgs{} +func NewFrontendServiceLoadTxnBeginArgs() *FrontendServiceLoadTxnBeginArgs { + return &FrontendServiceLoadTxnBeginArgs{} } -func (p *FrontendServiceUpdateExportTaskStatusArgs) InitDefault() { +func (p *FrontendServiceLoadTxnBeginArgs) InitDefault() { } -var FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT *TUpdateExportTaskStatusRequest +var FrontendServiceLoadTxnBeginArgs_Request_DEFAULT *TLoadTxnBeginRequest -func (p *FrontendServiceUpdateExportTaskStatusArgs) GetRequest() (v *TUpdateExportTaskStatusRequest) { +func (p *FrontendServiceLoadTxnBeginArgs) GetRequest() (v *TLoadTxnBeginRequest) { if !p.IsSetRequest() { - return FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT + return FrontendServiceLoadTxnBeginArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceUpdateExportTaskStatusArgs) SetRequest(val *TUpdateExportTaskStatusRequest) { +func (p *FrontendServiceLoadTxnBeginArgs) SetRequest(val *TLoadTxnBeginRequest) { p.Request = val } -var fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnBeginArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceUpdateExportTaskStatusArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnBeginArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82876,7 +84364,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82886,8 +84374,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTUpdateExportTaskStatusRequest() +func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnBeginRequest() if err := _field.Read(iprot); err != nil { return err } @@ -82895,9 +84383,9 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TPro return nil } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("updateExportTaskStatus_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnBegin_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82923,7 +84411,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -82940,15 +84428,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) String() string { +func (p *FrontendServiceLoadTxnBeginArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnBeginArgs(%+v)", *p) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusArgs) bool { +func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnBeginArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82960,7 +84448,7 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServi return true } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdateExportTaskStatusRequest) bool { +func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -82968,38 +84456,38 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdate return true } -type FrontendServiceUpdateExportTaskStatusResult struct { - Success *TFeResult_ `thrift:"success,0,optional" frugal:"0,optional,TFeResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnBeginResult struct { + Success *TLoadTxnBeginResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnBeginResult_" json:"success,omitempty"` } -func NewFrontendServiceUpdateExportTaskStatusResult() *FrontendServiceUpdateExportTaskStatusResult { - return &FrontendServiceUpdateExportTaskStatusResult{} +func NewFrontendServiceLoadTxnBeginResult() *FrontendServiceLoadTxnBeginResult { + return &FrontendServiceLoadTxnBeginResult{} } -func (p *FrontendServiceUpdateExportTaskStatusResult) InitDefault() { +func (p *FrontendServiceLoadTxnBeginResult) InitDefault() { } -var FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT *TFeResult_ +var FrontendServiceLoadTxnBeginResult_Success_DEFAULT *TLoadTxnBeginResult_ -func (p *FrontendServiceUpdateExportTaskStatusResult) GetSuccess() (v *TFeResult_) { +func (p *FrontendServiceLoadTxnBeginResult) GetSuccess() (v *TLoadTxnBeginResult_) { if !p.IsSetSuccess() { - return FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT + return FrontendServiceLoadTxnBeginResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceUpdateExportTaskStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TFeResult_) +func (p *FrontendServiceLoadTxnBeginResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnBeginResult_) } -var fieldIDToName_FrontendServiceUpdateExportTaskStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnBeginResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceUpdateExportTaskStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnBeginResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceUpdateExportTaskStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83045,7 +84533,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83055,8 +84543,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTFeResult_() +func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnBeginResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83064,9 +84552,9 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TP return nil } -func (p *FrontendServiceUpdateExportTaskStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("updateExportTaskStatus_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnBegin_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83092,7 +84580,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83111,15 +84599,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) String() string { +func (p *FrontendServiceLoadTxnBeginResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnBeginResult(%+v)", *p) } -func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusResult) bool { +func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTxnBeginResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83131,7 +84619,7 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeResult_) bool { +func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83139,38 +84627,38 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeRe return true } -type FrontendServiceLoadTxnBeginArgs struct { - Request *TLoadTxnBeginRequest `thrift:"request,1" frugal:"1,default,TLoadTxnBeginRequest" json:"request"` +type FrontendServiceLoadTxnPreCommitArgs struct { + Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` } -func NewFrontendServiceLoadTxnBeginArgs() *FrontendServiceLoadTxnBeginArgs { - return &FrontendServiceLoadTxnBeginArgs{} +func NewFrontendServiceLoadTxnPreCommitArgs() *FrontendServiceLoadTxnPreCommitArgs { + return &FrontendServiceLoadTxnPreCommitArgs{} } -func (p *FrontendServiceLoadTxnBeginArgs) InitDefault() { +func (p *FrontendServiceLoadTxnPreCommitArgs) InitDefault() { } -var FrontendServiceLoadTxnBeginArgs_Request_DEFAULT *TLoadTxnBeginRequest +var FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest -func (p *FrontendServiceLoadTxnBeginArgs) GetRequest() (v *TLoadTxnBeginRequest) { +func (p *FrontendServiceLoadTxnPreCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnBeginArgs_Request_DEFAULT + return FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnBeginArgs) SetRequest(val *TLoadTxnBeginRequest) { +func (p *FrontendServiceLoadTxnPreCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnBeginArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnPreCommitArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnBeginArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnBeginArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83216,7 +84704,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83226,8 +84714,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnBeginRequest() +func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83235,9 +84723,9 @@ func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) err return nil } -func (p *FrontendServiceLoadTxnBeginArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnBegin_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnPreCommit_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83263,7 +84751,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83280,15 +84768,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) String() string { +func (p *FrontendServiceLoadTxnPreCommitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnBeginArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnPreCommitArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnBeginArgs) bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnPreCommitArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83300,7 +84788,7 @@ func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnB return true } -func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequest) bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83308,38 +84796,38 @@ func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequ return true } -type FrontendServiceLoadTxnBeginResult struct { - Success *TLoadTxnBeginResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnBeginResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnPreCommitResult struct { + Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnBeginResult() *FrontendServiceLoadTxnBeginResult { - return &FrontendServiceLoadTxnBeginResult{} +func NewFrontendServiceLoadTxnPreCommitResult() *FrontendServiceLoadTxnPreCommitResult { + return &FrontendServiceLoadTxnPreCommitResult{} } -func (p *FrontendServiceLoadTxnBeginResult) InitDefault() { +func (p *FrontendServiceLoadTxnPreCommitResult) InitDefault() { } -var FrontendServiceLoadTxnBeginResult_Success_DEFAULT *TLoadTxnBeginResult_ +var FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ -func (p *FrontendServiceLoadTxnBeginResult) GetSuccess() (v *TLoadTxnBeginResult_) { +func (p *FrontendServiceLoadTxnPreCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnBeginResult_Success_DEFAULT + return FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnBeginResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnBeginResult_) +func (p *FrontendServiceLoadTxnPreCommitResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnCommitResult_) } -var fieldIDToName_FrontendServiceLoadTxnBeginResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnPreCommitResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnBeginResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnPreCommitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnBeginResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83385,7 +84873,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83395,8 +84883,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnBeginResult_() +func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83404,9 +84892,9 @@ func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) e return nil } -func (p *FrontendServiceLoadTxnBeginResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnBegin_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnPreCommit_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83432,7 +84920,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83451,15 +84939,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) String() string { +func (p *FrontendServiceLoadTxnPreCommitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnBeginResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnPreCommitResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTxnBeginResult) bool { +func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLoadTxnPreCommitResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83471,7 +84959,7 @@ func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTx return true } -func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginResult_) bool { +func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83479,38 +84967,38 @@ func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginRe return true } -type FrontendServiceLoadTxnPreCommitArgs struct { - Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` +type FrontendServiceLoadTxn2PCArgs struct { + Request *TLoadTxn2PCRequest `thrift:"request,1" frugal:"1,default,TLoadTxn2PCRequest" json:"request"` } -func NewFrontendServiceLoadTxnPreCommitArgs() *FrontendServiceLoadTxnPreCommitArgs { - return &FrontendServiceLoadTxnPreCommitArgs{} +func NewFrontendServiceLoadTxn2PCArgs() *FrontendServiceLoadTxn2PCArgs { + return &FrontendServiceLoadTxn2PCArgs{} } -func (p *FrontendServiceLoadTxnPreCommitArgs) InitDefault() { +func (p *FrontendServiceLoadTxn2PCArgs) InitDefault() { } -var FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest +var FrontendServiceLoadTxn2PCArgs_Request_DEFAULT *TLoadTxn2PCRequest -func (p *FrontendServiceLoadTxnPreCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxn2PCArgs) GetRequest() (v *TLoadTxn2PCRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT + return FrontendServiceLoadTxn2PCArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnPreCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxn2PCArgs) SetRequest(val *TLoadTxn2PCRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnPreCommitArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxn2PCArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnPreCommitArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxn2PCArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnPreCommitArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83556,7 +85044,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83566,8 +85054,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitRequest() +func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxn2PCRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83575,9 +85063,9 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnPreCommitArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnPreCommit_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxn2PC_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83603,7 +85091,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83620,15 +85108,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) String() string { +func (p *FrontendServiceLoadTxn2PCArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnPreCommitArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxn2PCArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnPreCommitArgs) bool { +func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PCArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83640,7 +85128,7 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoad return true } -func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { +func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83648,38 +85136,38 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommi return true } -type FrontendServiceLoadTxnPreCommitResult struct { - Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` +type FrontendServiceLoadTxn2PCResult struct { + Success *TLoadTxn2PCResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxn2PCResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnPreCommitResult() *FrontendServiceLoadTxnPreCommitResult { - return &FrontendServiceLoadTxnPreCommitResult{} +func NewFrontendServiceLoadTxn2PCResult() *FrontendServiceLoadTxn2PCResult { + return &FrontendServiceLoadTxn2PCResult{} } -func (p *FrontendServiceLoadTxnPreCommitResult) InitDefault() { +func (p *FrontendServiceLoadTxn2PCResult) InitDefault() { } -var FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ +var FrontendServiceLoadTxn2PCResult_Success_DEFAULT *TLoadTxn2PCResult_ -func (p *FrontendServiceLoadTxnPreCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { +func (p *FrontendServiceLoadTxn2PCResult) GetSuccess() (v *TLoadTxn2PCResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT + return FrontendServiceLoadTxn2PCResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnPreCommitResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnCommitResult_) +func (p *FrontendServiceLoadTxn2PCResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxn2PCResult_) } -var fieldIDToName_FrontendServiceLoadTxnPreCommitResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxn2PCResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnPreCommitResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxn2PCResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnPreCommitResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83725,7 +85213,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83735,8 +85223,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitResult_() +func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxn2PCResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83744,9 +85232,9 @@ func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtoco return nil } -func (p *FrontendServiceLoadTxnPreCommitResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnPreCommit_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxn2PC_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83772,7 +85260,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83791,15 +85279,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) String() string { +func (p *FrontendServiceLoadTxn2PCResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnPreCommitResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxn2PCResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLoadTxnPreCommitResult) bool { +func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2PCResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83811,7 +85299,7 @@ func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLo return true } -func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { +func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83819,38 +85307,38 @@ func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCom return true } -type FrontendServiceLoadTxn2PCArgs struct { - Request *TLoadTxn2PCRequest `thrift:"request,1" frugal:"1,default,TLoadTxn2PCRequest" json:"request"` +type FrontendServiceLoadTxnCommitArgs struct { + Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` } -func NewFrontendServiceLoadTxn2PCArgs() *FrontendServiceLoadTxn2PCArgs { - return &FrontendServiceLoadTxn2PCArgs{} +func NewFrontendServiceLoadTxnCommitArgs() *FrontendServiceLoadTxnCommitArgs { + return &FrontendServiceLoadTxnCommitArgs{} } -func (p *FrontendServiceLoadTxn2PCArgs) InitDefault() { +func (p *FrontendServiceLoadTxnCommitArgs) InitDefault() { } -var FrontendServiceLoadTxn2PCArgs_Request_DEFAULT *TLoadTxn2PCRequest +var FrontendServiceLoadTxnCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest -func (p *FrontendServiceLoadTxn2PCArgs) GetRequest() (v *TLoadTxn2PCRequest) { +func (p *FrontendServiceLoadTxnCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxn2PCArgs_Request_DEFAULT + return FrontendServiceLoadTxnCommitArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxn2PCArgs) SetRequest(val *TLoadTxn2PCRequest) { +func (p *FrontendServiceLoadTxnCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxn2PCArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnCommitArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxn2PCArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnCommitArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxn2PCArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83896,7 +85384,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83906,8 +85394,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxn2PCRequest() +func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83915,9 +85403,9 @@ func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceLoadTxn2PCArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxn2PC_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnCommit_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83943,7 +85431,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83960,15 +85448,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) String() string { +func (p *FrontendServiceLoadTxnCommitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxn2PCArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnCommitArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PCArgs) bool { +func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnCommitArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83980,7 +85468,7 @@ func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PC return true } -func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) bool { +func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83988,38 +85476,38 @@ func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) return true } -type FrontendServiceLoadTxn2PCResult struct { - Success *TLoadTxn2PCResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxn2PCResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnCommitResult struct { + Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxn2PCResult() *FrontendServiceLoadTxn2PCResult { - return &FrontendServiceLoadTxn2PCResult{} +func NewFrontendServiceLoadTxnCommitResult() *FrontendServiceLoadTxnCommitResult { + return &FrontendServiceLoadTxnCommitResult{} } -func (p *FrontendServiceLoadTxn2PCResult) InitDefault() { +func (p *FrontendServiceLoadTxnCommitResult) InitDefault() { } -var FrontendServiceLoadTxn2PCResult_Success_DEFAULT *TLoadTxn2PCResult_ +var FrontendServiceLoadTxnCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ -func (p *FrontendServiceLoadTxn2PCResult) GetSuccess() (v *TLoadTxn2PCResult_) { +func (p *FrontendServiceLoadTxnCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxn2PCResult_Success_DEFAULT + return FrontendServiceLoadTxnCommitResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxn2PCResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxn2PCResult_) +func (p *FrontendServiceLoadTxnCommitResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnCommitResult_) } -var fieldIDToName_FrontendServiceLoadTxn2PCResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnCommitResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxn2PCResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnCommitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxn2PCResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84065,7 +85553,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84075,8 +85563,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxn2PCResult_() +func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84084,9 +85572,9 @@ func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) err return nil } -func (p *FrontendServiceLoadTxn2PCResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxn2PC_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnCommit_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84112,7 +85600,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84131,15 +85619,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) String() string { +func (p *FrontendServiceLoadTxnCommitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxn2PCResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnCommitResult(%+v)", *p) } -func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2PCResult) bool { +func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadTxnCommitResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84151,7 +85639,7 @@ func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2 return true } -func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult_) bool { +func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84159,38 +85647,38 @@ func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult return true } -type FrontendServiceLoadTxnCommitArgs struct { - Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` +type FrontendServiceLoadTxnRollbackArgs struct { + Request *TLoadTxnRollbackRequest `thrift:"request,1" frugal:"1,default,TLoadTxnRollbackRequest" json:"request"` } -func NewFrontendServiceLoadTxnCommitArgs() *FrontendServiceLoadTxnCommitArgs { - return &FrontendServiceLoadTxnCommitArgs{} +func NewFrontendServiceLoadTxnRollbackArgs() *FrontendServiceLoadTxnRollbackArgs { + return &FrontendServiceLoadTxnRollbackArgs{} } -func (p *FrontendServiceLoadTxnCommitArgs) InitDefault() { +func (p *FrontendServiceLoadTxnRollbackArgs) InitDefault() { } -var FrontendServiceLoadTxnCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest +var FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT *TLoadTxnRollbackRequest -func (p *FrontendServiceLoadTxnCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxnRollbackArgs) GetRequest() (v *TLoadTxnRollbackRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnCommitArgs_Request_DEFAULT + return FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxnRollbackArgs) SetRequest(val *TLoadTxnRollbackRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnCommitArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnRollbackArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnCommitArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnRollbackArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnCommitArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84236,7 +85724,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84246,8 +85734,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitRequest() +func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnRollbackRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84255,9 +85743,9 @@ func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceLoadTxnCommitArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnCommit_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnRollback_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84283,7 +85771,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84300,15 +85788,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) String() string { +func (p *FrontendServiceLoadTxnRollbackArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnCommitArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnRollbackArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnCommitArgs) bool { +func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadTxnRollbackArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84320,7 +85808,7 @@ func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxn return true } -func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { +func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollbackRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -84328,38 +85816,38 @@ func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRe return true } -type FrontendServiceLoadTxnCommitResult struct { - Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnRollbackResult struct { + Success *TLoadTxnRollbackResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnRollbackResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnCommitResult() *FrontendServiceLoadTxnCommitResult { - return &FrontendServiceLoadTxnCommitResult{} +func NewFrontendServiceLoadTxnRollbackResult() *FrontendServiceLoadTxnRollbackResult { + return &FrontendServiceLoadTxnRollbackResult{} } -func (p *FrontendServiceLoadTxnCommitResult) InitDefault() { +func (p *FrontendServiceLoadTxnRollbackResult) InitDefault() { } -var FrontendServiceLoadTxnCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ +var FrontendServiceLoadTxnRollbackResult_Success_DEFAULT *TLoadTxnRollbackResult_ -func (p *FrontendServiceLoadTxnCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { +func (p *FrontendServiceLoadTxnRollbackResult) GetSuccess() (v *TLoadTxnRollbackResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnCommitResult_Success_DEFAULT + return FrontendServiceLoadTxnRollbackResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnCommitResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnCommitResult_) +func (p *FrontendServiceLoadTxnRollbackResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnRollbackResult_) } -var fieldIDToName_FrontendServiceLoadTxnCommitResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnRollbackResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnCommitResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnRollbackResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnCommitResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84405,7 +85893,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84415,8 +85903,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitResult_() +func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnRollbackResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84424,9 +85912,9 @@ func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnCommitResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnCommit_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnRollback_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84452,7 +85940,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84471,15 +85959,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) String() string { +func (p *FrontendServiceLoadTxnRollbackResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnCommitResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnRollbackResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadTxnCommitResult) bool { +func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoadTxnRollbackResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84491,7 +85979,7 @@ func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadT return true } -func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { +func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRollbackResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84499,38 +85987,38 @@ func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommit return true } -type FrontendServiceLoadTxnRollbackArgs struct { - Request *TLoadTxnRollbackRequest `thrift:"request,1" frugal:"1,default,TLoadTxnRollbackRequest" json:"request"` +type FrontendServiceBeginTxnArgs struct { + Request *TBeginTxnRequest `thrift:"request,1" frugal:"1,default,TBeginTxnRequest" json:"request"` } -func NewFrontendServiceLoadTxnRollbackArgs() *FrontendServiceLoadTxnRollbackArgs { - return &FrontendServiceLoadTxnRollbackArgs{} +func NewFrontendServiceBeginTxnArgs() *FrontendServiceBeginTxnArgs { + return &FrontendServiceBeginTxnArgs{} } -func (p *FrontendServiceLoadTxnRollbackArgs) InitDefault() { +func (p *FrontendServiceBeginTxnArgs) InitDefault() { } -var FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT *TLoadTxnRollbackRequest +var FrontendServiceBeginTxnArgs_Request_DEFAULT *TBeginTxnRequest -func (p *FrontendServiceLoadTxnRollbackArgs) GetRequest() (v *TLoadTxnRollbackRequest) { +func (p *FrontendServiceBeginTxnArgs) GetRequest() (v *TBeginTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT + return FrontendServiceBeginTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnRollbackArgs) SetRequest(val *TLoadTxnRollbackRequest) { +func (p *FrontendServiceBeginTxnArgs) SetRequest(val *TBeginTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnRollbackArgs = map[int16]string{ +var fieldIDToName_FrontendServiceBeginTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnRollbackArgs) IsSetRequest() bool { +func (p *FrontendServiceBeginTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnRollbackArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84576,7 +86064,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84586,8 +86074,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnRollbackRequest() +func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTBeginTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84595,9 +86083,9 @@ func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnRollbackArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnRollback_args"); err != nil { + if err = oprot.WriteStructBegin("beginTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84623,7 +86111,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84640,15 +86128,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) String() string { +func (p *FrontendServiceBeginTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnRollbackArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceBeginTxnArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadTxnRollbackArgs) bool { +func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84660,7 +86148,7 @@ func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadT return true } -func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollbackRequest) bool { +func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -84668,38 +86156,38 @@ func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollba return true } -type FrontendServiceLoadTxnRollbackResult struct { - Success *TLoadTxnRollbackResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnRollbackResult_" json:"success,omitempty"` +type FrontendServiceBeginTxnResult struct { + Success *TBeginTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TBeginTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnRollbackResult() *FrontendServiceLoadTxnRollbackResult { - return &FrontendServiceLoadTxnRollbackResult{} +func NewFrontendServiceBeginTxnResult() *FrontendServiceBeginTxnResult { + return &FrontendServiceBeginTxnResult{} } -func (p *FrontendServiceLoadTxnRollbackResult) InitDefault() { +func (p *FrontendServiceBeginTxnResult) InitDefault() { } -var FrontendServiceLoadTxnRollbackResult_Success_DEFAULT *TLoadTxnRollbackResult_ +var FrontendServiceBeginTxnResult_Success_DEFAULT *TBeginTxnResult_ -func (p *FrontendServiceLoadTxnRollbackResult) GetSuccess() (v *TLoadTxnRollbackResult_) { +func (p *FrontendServiceBeginTxnResult) GetSuccess() (v *TBeginTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnRollbackResult_Success_DEFAULT + return FrontendServiceBeginTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnRollbackResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnRollbackResult_) +func (p *FrontendServiceBeginTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TBeginTxnResult_) } -var fieldIDToName_FrontendServiceLoadTxnRollbackResult = map[int16]string{ +var fieldIDToName_FrontendServiceBeginTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnRollbackResult) IsSetSuccess() bool { +func (p *FrontendServiceBeginTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnRollbackResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84745,7 +86233,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84755,8 +86243,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnRollbackResult_() +func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTBeginTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84764,9 +86252,9 @@ func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol return nil } -func (p *FrontendServiceLoadTxnRollbackResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnRollback_result"); err != nil { + if err = oprot.WriteStructBegin("beginTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84792,7 +86280,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84811,15 +86299,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) String() string { +func (p *FrontendServiceBeginTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnRollbackResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceBeginTxnResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoadTxnRollbackResult) bool { +func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84831,7 +86319,7 @@ func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoa return true } -func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRollbackResult_) bool { +func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84839,38 +86327,38 @@ func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRoll return true } -type FrontendServiceBeginTxnArgs struct { - Request *TBeginTxnRequest `thrift:"request,1" frugal:"1,default,TBeginTxnRequest" json:"request"` +type FrontendServiceCommitTxnArgs struct { + Request *TCommitTxnRequest `thrift:"request,1" frugal:"1,default,TCommitTxnRequest" json:"request"` } -func NewFrontendServiceBeginTxnArgs() *FrontendServiceBeginTxnArgs { - return &FrontendServiceBeginTxnArgs{} +func NewFrontendServiceCommitTxnArgs() *FrontendServiceCommitTxnArgs { + return &FrontendServiceCommitTxnArgs{} } -func (p *FrontendServiceBeginTxnArgs) InitDefault() { +func (p *FrontendServiceCommitTxnArgs) InitDefault() { } -var FrontendServiceBeginTxnArgs_Request_DEFAULT *TBeginTxnRequest +var FrontendServiceCommitTxnArgs_Request_DEFAULT *TCommitTxnRequest -func (p *FrontendServiceBeginTxnArgs) GetRequest() (v *TBeginTxnRequest) { +func (p *FrontendServiceCommitTxnArgs) GetRequest() (v *TCommitTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceBeginTxnArgs_Request_DEFAULT + return FrontendServiceCommitTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceBeginTxnArgs) SetRequest(val *TBeginTxnRequest) { +func (p *FrontendServiceCommitTxnArgs) SetRequest(val *TCommitTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceBeginTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceCommitTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceBeginTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceCommitTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceBeginTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84916,7 +86404,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84926,8 +86414,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTBeginTxnRequest() +func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTCommitTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84935,9 +86423,9 @@ func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *FrontendServiceBeginTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("beginTxn_args"); err != nil { + if err = oprot.WriteStructBegin("commitTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84963,7 +86451,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84980,15 +86468,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) String() string { +func (p *FrontendServiceCommitTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceBeginTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceCommitTxnArgs(%+v)", *p) } -func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs) bool { +func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85000,7 +86488,7 @@ func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs return true } -func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) bool { +func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85008,38 +86496,38 @@ func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) boo return true } -type FrontendServiceBeginTxnResult struct { - Success *TBeginTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TBeginTxnResult_" json:"success,omitempty"` +type FrontendServiceCommitTxnResult struct { + Success *TCommitTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TCommitTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceBeginTxnResult() *FrontendServiceBeginTxnResult { - return &FrontendServiceBeginTxnResult{} +func NewFrontendServiceCommitTxnResult() *FrontendServiceCommitTxnResult { + return &FrontendServiceCommitTxnResult{} } -func (p *FrontendServiceBeginTxnResult) InitDefault() { +func (p *FrontendServiceCommitTxnResult) InitDefault() { } -var FrontendServiceBeginTxnResult_Success_DEFAULT *TBeginTxnResult_ +var FrontendServiceCommitTxnResult_Success_DEFAULT *TCommitTxnResult_ -func (p *FrontendServiceBeginTxnResult) GetSuccess() (v *TBeginTxnResult_) { +func (p *FrontendServiceCommitTxnResult) GetSuccess() (v *TCommitTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceBeginTxnResult_Success_DEFAULT + return FrontendServiceCommitTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceBeginTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TBeginTxnResult_) +func (p *FrontendServiceCommitTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TCommitTxnResult_) } -var fieldIDToName_FrontendServiceBeginTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceCommitTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceBeginTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceCommitTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceBeginTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85085,7 +86573,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85095,8 +86583,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTBeginTxnResult_() +func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTCommitTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85104,9 +86592,9 @@ func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceBeginTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("beginTxn_result"); err != nil { + if err = oprot.WriteStructBegin("commitTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85132,7 +86620,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85151,15 +86639,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) String() string { +func (p *FrontendServiceCommitTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceBeginTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceCommitTxnResult(%+v)", *p) } -func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnResult) bool { +func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85171,7 +86659,7 @@ func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnRe return true } -func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) bool { +func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85179,38 +86667,38 @@ func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) b return true } -type FrontendServiceCommitTxnArgs struct { - Request *TCommitTxnRequest `thrift:"request,1" frugal:"1,default,TCommitTxnRequest" json:"request"` +type FrontendServiceRollbackTxnArgs struct { + Request *TRollbackTxnRequest `thrift:"request,1" frugal:"1,default,TRollbackTxnRequest" json:"request"` } -func NewFrontendServiceCommitTxnArgs() *FrontendServiceCommitTxnArgs { - return &FrontendServiceCommitTxnArgs{} +func NewFrontendServiceRollbackTxnArgs() *FrontendServiceRollbackTxnArgs { + return &FrontendServiceRollbackTxnArgs{} } -func (p *FrontendServiceCommitTxnArgs) InitDefault() { +func (p *FrontendServiceRollbackTxnArgs) InitDefault() { } -var FrontendServiceCommitTxnArgs_Request_DEFAULT *TCommitTxnRequest +var FrontendServiceRollbackTxnArgs_Request_DEFAULT *TRollbackTxnRequest -func (p *FrontendServiceCommitTxnArgs) GetRequest() (v *TCommitTxnRequest) { +func (p *FrontendServiceRollbackTxnArgs) GetRequest() (v *TRollbackTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceCommitTxnArgs_Request_DEFAULT + return FrontendServiceRollbackTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceCommitTxnArgs) SetRequest(val *TCommitTxnRequest) { +func (p *FrontendServiceRollbackTxnArgs) SetRequest(val *TRollbackTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceCommitTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceRollbackTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceCommitTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceRollbackTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceCommitTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85256,7 +86744,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85266,8 +86754,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTCommitTxnRequest() +func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTRollbackTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85275,9 +86763,9 @@ func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceCommitTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("commitTxn_args"); err != nil { + if err = oprot.WriteStructBegin("rollbackTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85303,7 +86791,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -85320,15 +86808,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) String() string { +func (p *FrontendServiceRollbackTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceCommitTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceRollbackTxnArgs(%+v)", *p) } -func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnArgs) bool { +func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85340,7 +86828,7 @@ func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnAr return true } -func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) bool { +func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85348,38 +86836,38 @@ func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) b return true } -type FrontendServiceCommitTxnResult struct { - Success *TCommitTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TCommitTxnResult_" json:"success,omitempty"` +type FrontendServiceRollbackTxnResult struct { + Success *TRollbackTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TRollbackTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceCommitTxnResult() *FrontendServiceCommitTxnResult { - return &FrontendServiceCommitTxnResult{} +func NewFrontendServiceRollbackTxnResult() *FrontendServiceRollbackTxnResult { + return &FrontendServiceRollbackTxnResult{} } -func (p *FrontendServiceCommitTxnResult) InitDefault() { +func (p *FrontendServiceRollbackTxnResult) InitDefault() { } -var FrontendServiceCommitTxnResult_Success_DEFAULT *TCommitTxnResult_ +var FrontendServiceRollbackTxnResult_Success_DEFAULT *TRollbackTxnResult_ -func (p *FrontendServiceCommitTxnResult) GetSuccess() (v *TCommitTxnResult_) { +func (p *FrontendServiceRollbackTxnResult) GetSuccess() (v *TRollbackTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceCommitTxnResult_Success_DEFAULT + return FrontendServiceRollbackTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceCommitTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TCommitTxnResult_) +func (p *FrontendServiceRollbackTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TRollbackTxnResult_) } -var fieldIDToName_FrontendServiceCommitTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceRollbackTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceCommitTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceRollbackTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceCommitTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85425,7 +86913,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85435,8 +86923,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTCommitTxnResult_() +func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTRollbackTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85444,9 +86932,9 @@ func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceCommitTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("commitTxn_result"); err != nil { + if err = oprot.WriteStructBegin("rollbackTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85472,7 +86960,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85491,15 +86979,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) String() string { +func (p *FrontendServiceRollbackTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceCommitTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceRollbackTxnResult(%+v)", *p) } -func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxnResult) bool { +func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbackTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85511,7 +86999,7 @@ func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxn return true } -func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) bool { +func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85519,38 +87007,38 @@ func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) return true } -type FrontendServiceRollbackTxnArgs struct { - Request *TRollbackTxnRequest `thrift:"request,1" frugal:"1,default,TRollbackTxnRequest" json:"request"` +type FrontendServiceGetBinlogArgs struct { + Request *TGetBinlogRequest `thrift:"request,1" frugal:"1,default,TGetBinlogRequest" json:"request"` } -func NewFrontendServiceRollbackTxnArgs() *FrontendServiceRollbackTxnArgs { - return &FrontendServiceRollbackTxnArgs{} +func NewFrontendServiceGetBinlogArgs() *FrontendServiceGetBinlogArgs { + return &FrontendServiceGetBinlogArgs{} } -func (p *FrontendServiceRollbackTxnArgs) InitDefault() { +func (p *FrontendServiceGetBinlogArgs) InitDefault() { } -var FrontendServiceRollbackTxnArgs_Request_DEFAULT *TRollbackTxnRequest +var FrontendServiceGetBinlogArgs_Request_DEFAULT *TGetBinlogRequest -func (p *FrontendServiceRollbackTxnArgs) GetRequest() (v *TRollbackTxnRequest) { +func (p *FrontendServiceGetBinlogArgs) GetRequest() (v *TGetBinlogRequest) { if !p.IsSetRequest() { - return FrontendServiceRollbackTxnArgs_Request_DEFAULT + return FrontendServiceGetBinlogArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceRollbackTxnArgs) SetRequest(val *TRollbackTxnRequest) { +func (p *FrontendServiceGetBinlogArgs) SetRequest(val *TGetBinlogRequest) { p.Request = val } -var fieldIDToName_FrontendServiceRollbackTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetBinlogArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceRollbackTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceGetBinlogArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceRollbackTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85596,7 +87084,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85606,8 +87094,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTRollbackTxnRequest() +func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetBinlogRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85615,9 +87103,9 @@ func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceRollbackTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("rollbackTxn_args"); err != nil { + if err = oprot.WriteStructBegin("getBinlog_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85643,7 +87131,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -85660,15 +87148,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) String() string { +func (p *FrontendServiceGetBinlogArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceRollbackTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetBinlogArgs(%+v)", *p) } -func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackTxnArgs) bool { +func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85680,7 +87168,7 @@ func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackT return true } -func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnRequest) bool { +func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85688,38 +87176,38 @@ func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnReques return true } -type FrontendServiceRollbackTxnResult struct { - Success *TRollbackTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TRollbackTxnResult_" json:"success,omitempty"` +type FrontendServiceGetBinlogResult struct { + Success *TGetBinlogResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetBinlogResult_" json:"success,omitempty"` } -func NewFrontendServiceRollbackTxnResult() *FrontendServiceRollbackTxnResult { - return &FrontendServiceRollbackTxnResult{} +func NewFrontendServiceGetBinlogResult() *FrontendServiceGetBinlogResult { + return &FrontendServiceGetBinlogResult{} } -func (p *FrontendServiceRollbackTxnResult) InitDefault() { +func (p *FrontendServiceGetBinlogResult) InitDefault() { } -var FrontendServiceRollbackTxnResult_Success_DEFAULT *TRollbackTxnResult_ +var FrontendServiceGetBinlogResult_Success_DEFAULT *TGetBinlogResult_ -func (p *FrontendServiceRollbackTxnResult) GetSuccess() (v *TRollbackTxnResult_) { +func (p *FrontendServiceGetBinlogResult) GetSuccess() (v *TGetBinlogResult_) { if !p.IsSetSuccess() { - return FrontendServiceRollbackTxnResult_Success_DEFAULT + return FrontendServiceGetBinlogResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceRollbackTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TRollbackTxnResult_) +func (p *FrontendServiceGetBinlogResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetBinlogResult_) } -var fieldIDToName_FrontendServiceRollbackTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetBinlogResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceRollbackTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceGetBinlogResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceRollbackTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85765,7 +87253,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85775,8 +87263,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTRollbackTxnResult_() +func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetBinlogResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85784,9 +87272,9 @@ func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceRollbackTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("rollbackTxn_result"); err != nil { + if err = oprot.WriteStructBegin("getBinlog_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85812,7 +87300,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85831,15 +87319,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) String() string { +func (p *FrontendServiceGetBinlogResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceRollbackTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetBinlogResult(%+v)", *p) } -func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbackTxnResult) bool { +func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlogResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85851,7 +87339,7 @@ func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbac return true } -func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResult_) bool { +func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85859,38 +87347,38 @@ func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResu return true } -type FrontendServiceGetBinlogArgs struct { - Request *TGetBinlogRequest `thrift:"request,1" frugal:"1,default,TGetBinlogRequest" json:"request"` +type FrontendServiceGetSnapshotArgs struct { + Request *TGetSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetSnapshotRequest" json:"request"` } -func NewFrontendServiceGetBinlogArgs() *FrontendServiceGetBinlogArgs { - return &FrontendServiceGetBinlogArgs{} +func NewFrontendServiceGetSnapshotArgs() *FrontendServiceGetSnapshotArgs { + return &FrontendServiceGetSnapshotArgs{} } -func (p *FrontendServiceGetBinlogArgs) InitDefault() { +func (p *FrontendServiceGetSnapshotArgs) InitDefault() { } -var FrontendServiceGetBinlogArgs_Request_DEFAULT *TGetBinlogRequest +var FrontendServiceGetSnapshotArgs_Request_DEFAULT *TGetSnapshotRequest -func (p *FrontendServiceGetBinlogArgs) GetRequest() (v *TGetBinlogRequest) { +func (p *FrontendServiceGetSnapshotArgs) GetRequest() (v *TGetSnapshotRequest) { if !p.IsSetRequest() { - return FrontendServiceGetBinlogArgs_Request_DEFAULT + return FrontendServiceGetSnapshotArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceGetBinlogArgs) SetRequest(val *TGetBinlogRequest) { +func (p *FrontendServiceGetSnapshotArgs) SetRequest(val *TGetSnapshotRequest) { p.Request = val } -var fieldIDToName_FrontendServiceGetBinlogArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetSnapshotArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceGetBinlogArgs) IsSetRequest() bool { +func (p *FrontendServiceGetSnapshotArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceGetBinlogArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85936,7 +87424,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85946,8 +87434,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetBinlogRequest() +func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetSnapshotRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85955,9 +87443,9 @@ func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceGetBinlogArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getBinlog_args"); err != nil { + if err = oprot.WriteStructBegin("getSnapshot_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85983,7 +87471,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -86000,15 +87488,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) String() string { +func (p *FrontendServiceGetSnapshotArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetBinlogArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetSnapshotArgs(%+v)", *p) } -func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogArgs) bool { +func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapshotArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86020,7 +87508,7 @@ func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogAr return true } -func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) bool { +func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -86028,38 +87516,38 @@ func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) b return true } -type FrontendServiceGetBinlogResult struct { - Success *TGetBinlogResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetBinlogResult_" json:"success,omitempty"` +type FrontendServiceGetSnapshotResult struct { + Success *TGetSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetSnapshotResult_" json:"success,omitempty"` } -func NewFrontendServiceGetBinlogResult() *FrontendServiceGetBinlogResult { - return &FrontendServiceGetBinlogResult{} +func NewFrontendServiceGetSnapshotResult() *FrontendServiceGetSnapshotResult { + return &FrontendServiceGetSnapshotResult{} } -func (p *FrontendServiceGetBinlogResult) InitDefault() { +func (p *FrontendServiceGetSnapshotResult) InitDefault() { } -var FrontendServiceGetBinlogResult_Success_DEFAULT *TGetBinlogResult_ +var FrontendServiceGetSnapshotResult_Success_DEFAULT *TGetSnapshotResult_ -func (p *FrontendServiceGetBinlogResult) GetSuccess() (v *TGetBinlogResult_) { +func (p *FrontendServiceGetSnapshotResult) GetSuccess() (v *TGetSnapshotResult_) { if !p.IsSetSuccess() { - return FrontendServiceGetBinlogResult_Success_DEFAULT + return FrontendServiceGetSnapshotResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceGetBinlogResult) SetSuccess(x interface{}) { - p.Success = x.(*TGetBinlogResult_) +func (p *FrontendServiceGetSnapshotResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetSnapshotResult_) } -var fieldIDToName_FrontendServiceGetBinlogResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetSnapshotResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceGetBinlogResult) IsSetSuccess() bool { +func (p *FrontendServiceGetSnapshotResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceGetBinlogResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86105,7 +87593,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86115,8 +87603,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTGetBinlogResult_() +func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetSnapshotResult_() if err := _field.Read(iprot); err != nil { return err } @@ -86124,9 +87612,9 @@ func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceGetBinlogResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getBinlog_result"); err != nil { + if err = oprot.WriteStructBegin("getSnapshot_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86152,7 +87640,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -86171,15 +87659,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) String() string { +func (p *FrontendServiceGetSnapshotResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetBinlogResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetSnapshotResult(%+v)", *p) } -func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlogResult) bool { +func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnapshotResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86191,7 +87679,7 @@ func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlog return true } -func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) bool { +func (p *FrontendServiceGetSnapshotResult) Field0DeepEqual(src *TGetSnapshotResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -86199,38 +87687,38 @@ func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) return true } -type FrontendServiceGetSnapshotArgs struct { - Request *TGetSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetSnapshotRequest" json:"request"` +type FrontendServiceGetGlobalSnapshotArgs struct { + Request *TGetGlobalSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetGlobalSnapshotRequest" json:"request"` } -func NewFrontendServiceGetSnapshotArgs() *FrontendServiceGetSnapshotArgs { - return &FrontendServiceGetSnapshotArgs{} +func NewFrontendServiceGetGlobalSnapshotArgs() *FrontendServiceGetGlobalSnapshotArgs { + return &FrontendServiceGetGlobalSnapshotArgs{} } -func (p *FrontendServiceGetSnapshotArgs) InitDefault() { +func (p *FrontendServiceGetGlobalSnapshotArgs) InitDefault() { } -var FrontendServiceGetSnapshotArgs_Request_DEFAULT *TGetSnapshotRequest +var FrontendServiceGetGlobalSnapshotArgs_Request_DEFAULT *TGetGlobalSnapshotRequest -func (p *FrontendServiceGetSnapshotArgs) GetRequest() (v *TGetSnapshotRequest) { +func (p *FrontendServiceGetGlobalSnapshotArgs) GetRequest() (v *TGetGlobalSnapshotRequest) { if !p.IsSetRequest() { - return FrontendServiceGetSnapshotArgs_Request_DEFAULT + return FrontendServiceGetGlobalSnapshotArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceGetSnapshotArgs) SetRequest(val *TGetSnapshotRequest) { +func (p *FrontendServiceGetGlobalSnapshotArgs) SetRequest(val *TGetGlobalSnapshotRequest) { p.Request = val } -var fieldIDToName_FrontendServiceGetSnapshotArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetGlobalSnapshotArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceGetSnapshotArgs) IsSetRequest() bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceGetSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86276,7 +87764,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86286,8 +87774,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetSnapshotRequest() +func (p *FrontendServiceGetGlobalSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetGlobalSnapshotRequest() if err := _field.Read(iprot); err != nil { return err } @@ -86295,9 +87783,9 @@ func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceGetSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getSnapshot_args"); err != nil { + if err = oprot.WriteStructBegin("getGlobalSnapshot_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86323,7 +87811,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -86340,15 +87828,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) String() string { +func (p *FrontendServiceGetGlobalSnapshotArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetSnapshotArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetGlobalSnapshotArgs(%+v)", *p) } -func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapshotArgs) bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) DeepEqual(ano *FrontendServiceGetGlobalSnapshotArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86360,7 +87848,7 @@ func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapsh return true } -func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotRequest) bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) Field1DeepEqual(src *TGetGlobalSnapshotRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -86368,38 +87856,38 @@ func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotReques return true } -type FrontendServiceGetSnapshotResult struct { - Success *TGetSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetSnapshotResult_" json:"success,omitempty"` +type FrontendServiceGetGlobalSnapshotResult struct { + Success *TGetGlobalSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetGlobalSnapshotResult_" json:"success,omitempty"` } -func NewFrontendServiceGetSnapshotResult() *FrontendServiceGetSnapshotResult { - return &FrontendServiceGetSnapshotResult{} +func NewFrontendServiceGetGlobalSnapshotResult() *FrontendServiceGetGlobalSnapshotResult { + return &FrontendServiceGetGlobalSnapshotResult{} } -func (p *FrontendServiceGetSnapshotResult) InitDefault() { +func (p *FrontendServiceGetGlobalSnapshotResult) InitDefault() { } -var FrontendServiceGetSnapshotResult_Success_DEFAULT *TGetSnapshotResult_ +var FrontendServiceGetGlobalSnapshotResult_Success_DEFAULT *TGetGlobalSnapshotResult_ -func (p *FrontendServiceGetSnapshotResult) GetSuccess() (v *TGetSnapshotResult_) { +func (p *FrontendServiceGetGlobalSnapshotResult) GetSuccess() (v *TGetGlobalSnapshotResult_) { if !p.IsSetSuccess() { - return FrontendServiceGetSnapshotResult_Success_DEFAULT + return FrontendServiceGetGlobalSnapshotResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceGetSnapshotResult) SetSuccess(x interface{}) { - p.Success = x.(*TGetSnapshotResult_) +func (p *FrontendServiceGetGlobalSnapshotResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetGlobalSnapshotResult_) } -var fieldIDToName_FrontendServiceGetSnapshotResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetGlobalSnapshotResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceGetSnapshotResult) IsSetSuccess() bool { +func (p *FrontendServiceGetGlobalSnapshotResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceGetSnapshotResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86445,7 +87933,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86455,8 +87943,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTGetSnapshotResult_() +func (p *FrontendServiceGetGlobalSnapshotResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetGlobalSnapshotResult_() if err := _field.Read(iprot); err != nil { return err } @@ -86464,9 +87952,9 @@ func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceGetSnapshotResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getSnapshot_result"); err != nil { + if err = oprot.WriteStructBegin("getGlobalSnapshot_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86492,7 +87980,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -86511,15 +87999,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) String() string { +func (p *FrontendServiceGetGlobalSnapshotResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetSnapshotResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetGlobalSnapshotResult(%+v)", *p) } -func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnapshotResult) bool { +func (p *FrontendServiceGetGlobalSnapshotResult) DeepEqual(ano *FrontendServiceGetGlobalSnapshotResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86531,7 +88019,7 @@ func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnap return true } -func (p *FrontendServiceGetSnapshotResult) Field0DeepEqual(src *TGetSnapshotResult_) bool { +func (p *FrontendServiceGetGlobalSnapshotResult) Field0DeepEqual(src *TGetGlobalSnapshotResult_) bool { if !p.Success.DeepEqual(src) { return false diff --git a/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go b/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go index a3cc2f1b..f6b59f5e 100644 --- a/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go +++ b/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go @@ -38,6 +38,7 @@ type Client interface { RollbackTxn(ctx context.Context, request *frontendservice.TRollbackTxnRequest, callOptions ...callopt.Option) (r *frontendservice.TRollbackTxnResult_, err error) GetBinlog(ctx context.Context, request *frontendservice.TGetBinlogRequest, callOptions ...callopt.Option) (r *frontendservice.TGetBinlogResult_, err error) GetSnapshot(ctx context.Context, request *frontendservice.TGetSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetSnapshotResult_, err error) + GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetGlobalSnapshotResult_, err error) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TRestoreSnapshotResult_, err error) LockBinlog(ctx context.Context, request *frontendservice.TLockBinlogRequest, callOptions ...callopt.Option) (r *frontendservice.TLockBinlogResult_, err error) WaitingTxnStatus(ctx context.Context, request *frontendservice.TWaitingTxnStatusRequest, callOptions ...callopt.Option) (r *frontendservice.TWaitingTxnStatusResult_, err error) @@ -231,6 +232,11 @@ func (p *kFrontendServiceClient) GetSnapshot(ctx context.Context, request *front return p.kClient.GetSnapshot(ctx, request) } +func (p *kFrontendServiceClient) GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetGlobalSnapshotResult_, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetGlobalSnapshot(ctx, request) +} + func (p *kFrontendServiceClient) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TRestoreSnapshotResult_, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.RestoreSnapshot(ctx, request) diff --git a/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go b/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go index 536209f7..d5aad21c 100644 --- a/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go +++ b/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go @@ -46,6 +46,7 @@ func NewServiceInfo() *kitex.ServiceInfo { "rollbackTxn": kitex.NewMethodInfo(rollbackTxnHandler, newFrontendServiceRollbackTxnArgs, newFrontendServiceRollbackTxnResult, false), "getBinlog": kitex.NewMethodInfo(getBinlogHandler, newFrontendServiceGetBinlogArgs, newFrontendServiceGetBinlogResult, false), "getSnapshot": kitex.NewMethodInfo(getSnapshotHandler, newFrontendServiceGetSnapshotArgs, newFrontendServiceGetSnapshotResult, false), + "getGlobalSnapshot": kitex.NewMethodInfo(getGlobalSnapshotHandler, newFrontendServiceGetGlobalSnapshotArgs, newFrontendServiceGetGlobalSnapshotResult, false), "restoreSnapshot": kitex.NewMethodInfo(restoreSnapshotHandler, newFrontendServiceRestoreSnapshotArgs, newFrontendServiceRestoreSnapshotResult, false), "lockBinlog": kitex.NewMethodInfo(lockBinlogHandler, newFrontendServiceLockBinlogArgs, newFrontendServiceLockBinlogResult, false), "waitingTxnStatus": kitex.NewMethodInfo(waitingTxnStatusHandler, newFrontendServiceWaitingTxnStatusArgs, newFrontendServiceWaitingTxnStatusResult, false), @@ -549,6 +550,24 @@ func newFrontendServiceGetSnapshotResult() interface{} { return frontendservice.NewFrontendServiceGetSnapshotResult() } +func getGlobalSnapshotHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*frontendservice.FrontendServiceGetGlobalSnapshotArgs) + realResult := result.(*frontendservice.FrontendServiceGetGlobalSnapshotResult) + success, err := handler.(frontendservice.FrontendService).GetGlobalSnapshot(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} +func newFrontendServiceGetGlobalSnapshotArgs() interface{} { + return frontendservice.NewFrontendServiceGetGlobalSnapshotArgs() +} + +func newFrontendServiceGetGlobalSnapshotResult() interface{} { + return frontendservice.NewFrontendServiceGetGlobalSnapshotResult() +} + func restoreSnapshotHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { realArg := arg.(*frontendservice.FrontendServiceRestoreSnapshotArgs) realResult := result.(*frontendservice.FrontendServiceRestoreSnapshotResult) @@ -1474,6 +1493,16 @@ func (p *kClient) GetSnapshot(ctx context.Context, request *frontendservice.TGet return _result.GetSuccess(), nil } +func (p *kClient) GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest) (r *frontendservice.TGetGlobalSnapshotResult_, err error) { + var _args frontendservice.FrontendServiceGetGlobalSnapshotArgs + _args.Request = request + var _result frontendservice.FrontendServiceGetGlobalSnapshotResult + if err = p.c.Call(ctx, "getGlobalSnapshot", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + func (p *kClient) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest) (r *frontendservice.TRestoreSnapshotResult_, err error) { var _args frontendservice.FrontendServiceRestoreSnapshotArgs _args.Request = request diff --git a/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go b/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go index 2b756ca5..7a86e8c9 100644 --- a/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go +++ b/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go @@ -38865,6 +38865,781 @@ func (p *TGetSnapshotResult_) field7Length() int { return l } +func (p *TGetGlobalSnapshotRequest) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 6: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField6(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 7: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField7(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Cluster = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.User = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField3(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Passwd = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField4(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Token = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField5(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.LabelName = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField6(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.SnapshotName = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField7(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + tmp := TSnapshotType(v) + p.SnapshotType = &tmp + + } + return offset, nil +} + +// for compatibility +func (p *TGetGlobalSnapshotRequest) FastWrite(buf []byte) int { + return 0 +} + +func (p *TGetGlobalSnapshotRequest) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "TGetGlobalSnapshotRequest") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField3(buf[offset:], binaryWriter) + offset += p.fastWriteField4(buf[offset:], binaryWriter) + offset += p.fastWriteField5(buf[offset:], binaryWriter) + offset += p.fastWriteField6(buf[offset:], binaryWriter) + offset += p.fastWriteField7(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *TGetGlobalSnapshotRequest) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("TGetGlobalSnapshotRequest") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + l += p.field6Length() + l += p.field7Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetCluster() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "cluster", thrift.STRING, 1) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Cluster) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetUser() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "user", thrift.STRING, 2) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.User) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetPasswd() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "passwd", thrift.STRING, 3) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Passwd) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField4(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetToken() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "token", thrift.STRING, 4) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Token) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField5(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetLabelName() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "label_name", thrift.STRING, 5) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.LabelName) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField6(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSnapshotName() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "snapshot_name", thrift.STRING, 6) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.SnapshotName) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField7(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSnapshotType() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "snapshot_type", thrift.I32, 7) + offset += bthrift.Binary.WriteI32(buf[offset:], int32(*p.SnapshotType)) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) field1Length() int { + l := 0 + if p.IsSetCluster() { + l += bthrift.Binary.FieldBeginLength("cluster", thrift.STRING, 1) + l += bthrift.Binary.StringLengthNocopy(*p.Cluster) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field2Length() int { + l := 0 + if p.IsSetUser() { + l += bthrift.Binary.FieldBeginLength("user", thrift.STRING, 2) + l += bthrift.Binary.StringLengthNocopy(*p.User) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field3Length() int { + l := 0 + if p.IsSetPasswd() { + l += bthrift.Binary.FieldBeginLength("passwd", thrift.STRING, 3) + l += bthrift.Binary.StringLengthNocopy(*p.Passwd) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field4Length() int { + l := 0 + if p.IsSetToken() { + l += bthrift.Binary.FieldBeginLength("token", thrift.STRING, 4) + l += bthrift.Binary.StringLengthNocopy(*p.Token) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field5Length() int { + l := 0 + if p.IsSetLabelName() { + l += bthrift.Binary.FieldBeginLength("label_name", thrift.STRING, 5) + l += bthrift.Binary.StringLengthNocopy(*p.LabelName) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field6Length() int { + l := 0 + if p.IsSetSnapshotName() { + l += bthrift.Binary.FieldBeginLength("snapshot_name", thrift.STRING, 6) + l += bthrift.Binary.StringLengthNocopy(*p.SnapshotName) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field7Length() int { + l := 0 + if p.IsSetSnapshotType() { + l += bthrift.Binary.FieldBeginLength("snapshot_type", thrift.I32, 7) + l += bthrift.Binary.I32Length(int32(*p.SnapshotType)) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotResult_[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := status.NewTStatus() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Status = tmp + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadBinary(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.GlobalInfo = []byte(v) + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField3(buf []byte) (int, error) { + offset := 0 + + tmp := types.NewTNetworkAddress() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.MasterAddress = tmp + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField4(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.ExpiredAt = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField5(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.CommitSeq = &v + + } + return offset, nil +} + +// for compatibility +func (p *TGetGlobalSnapshotResult_) FastWrite(buf []byte) int { + return 0 +} + +func (p *TGetGlobalSnapshotResult_) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "TGetGlobalSnapshotResult") + if p != nil { + offset += p.fastWriteField4(buf[offset:], binaryWriter) + offset += p.fastWriteField5(buf[offset:], binaryWriter) + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField3(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *TGetGlobalSnapshotResult_) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("TGetGlobalSnapshotResult") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetStatus() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "status", thrift.STRUCT, 1) + offset += p.Status.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetGlobalInfo() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "global_info", thrift.STRING, 2) + offset += bthrift.Binary.WriteBinaryNocopy(buf[offset:], binaryWriter, []byte(p.GlobalInfo)) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetMasterAddress() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "master_address", thrift.STRUCT, 3) + offset += p.MasterAddress.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField4(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetExpiredAt() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "expiredAt", thrift.I64, 4) + offset += bthrift.Binary.WriteI64(buf[offset:], *p.ExpiredAt) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField5(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetCommitSeq() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "commit_seq", thrift.I64, 5) + offset += bthrift.Binary.WriteI64(buf[offset:], *p.CommitSeq) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) field1Length() int { + l := 0 + if p.IsSetStatus() { + l += bthrift.Binary.FieldBeginLength("status", thrift.STRUCT, 1) + l += p.Status.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field2Length() int { + l := 0 + if p.IsSetGlobalInfo() { + l += bthrift.Binary.FieldBeginLength("global_info", thrift.STRING, 2) + l += bthrift.Binary.BinaryLengthNocopy([]byte(p.GlobalInfo)) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field3Length() int { + l := 0 + if p.IsSetMasterAddress() { + l += bthrift.Binary.FieldBeginLength("master_address", thrift.STRUCT, 3) + l += p.MasterAddress.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field4Length() int { + l := 0 + if p.IsSetExpiredAt() { + l += bthrift.Binary.FieldBeginLength("expiredAt", thrift.I64, 4) + l += bthrift.Binary.I64Length(*p.ExpiredAt) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field5Length() int { + l := 0 + if p.IsSetCommitSeq() { + l += bthrift.Binary.FieldBeginLength("commit_seq", thrift.I64, 5) + l += bthrift.Binary.I64Length(*p.CommitSeq) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + func (p *TTableRef) FastRead(buf []byte) (int, error) { var err error var offset int @@ -60453,6 +61228,264 @@ func (p *FrontendServiceGetSnapshotResult) field0Length() int { return l } +func (p *FrontendServiceGetGlobalSnapshotArgs) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := NewTGetGlobalSnapshotRequest() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = tmp + return offset, nil +} + +// for compatibility +func (p *FrontendServiceGetGlobalSnapshotArgs) FastWrite(buf []byte) int { + return 0 +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "getGlobalSnapshot_args") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("getGlobalSnapshot_args") + if p != nil { + l += p.field1Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "request", thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("request", thrift.STRUCT, 1) + l += p.Request.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + + tmp := NewTGetGlobalSnapshotResult_() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = tmp + return offset, nil +} + +// for compatibility +func (p *FrontendServiceGetGlobalSnapshotResult) FastWrite(buf []byte) int { + return 0 +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "getGlobalSnapshot_result") + if p != nil { + offset += p.fastWriteField0(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotResult) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("getGlobalSnapshot_result") + if p != nil { + l += p.field0Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotResult) fastWriteField0(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "success", thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += bthrift.Binary.FieldBeginLength("success", thrift.STRUCT, 0) + l += p.Success.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + func (p *FrontendServiceRestoreSnapshotArgs) FastRead(buf []byte) (int, error) { var err error var offset int @@ -70154,6 +71187,14 @@ func (p *FrontendServiceGetSnapshotResult) GetResult() interface{} { return p.Success } +func (p *FrontendServiceGetGlobalSnapshotArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *FrontendServiceGetGlobalSnapshotResult) GetResult() interface{} { + return p.Success +} + func (p *FrontendServiceRestoreSnapshotArgs) GetFirstArgument() interface{} { return p.Request } diff --git a/pkg/rpc/thrift/FrontendService.thrift b/pkg/rpc/thrift/FrontendService.thrift index 3b74dca0..40e864db 100644 --- a/pkg/rpc/thrift/FrontendService.thrift +++ b/pkg/rpc/thrift/FrontendService.thrift @@ -1197,6 +1197,24 @@ struct TGetSnapshotResult { 7: optional i64 commit_seq; } +struct TGetGlobalSnapshotRequest { + 1: optional string cluster + 2: optional string user + 3: optional string passwd + 4: optional string token + 5: optional string label_name + 6: optional string snapshot_name + 7: optional TSnapshotType snapshot_type +} + +struct TGetGlobalSnapshotResult { + 1: optional Status.TStatus status + 2: optional binary global_info + 3: optional Types.TNetworkAddress master_address + 4: optional i64 expiredAt; // in millis + 5: optional i64 commit_seq; +} + struct TTableRef { 1: optional string table 3: optional string alias_name @@ -1590,6 +1608,7 @@ service FrontendService { TRollbackTxnResult rollbackTxn(1: TRollbackTxnRequest request) TGetBinlogResult getBinlog(1: TGetBinlogRequest request) TGetSnapshotResult getSnapshot(1: TGetSnapshotRequest request) + TGetGlobalSnapshotResult getGlobalSnapshot(1: TGetGlobalSnapshotRequest request) TRestoreSnapshotResult restoreSnapshot(1: TRestoreSnapshotRequest request) TLockBinlogResult lockBinlog(1: TLockBinlogRequest request) diff --git a/pkg/service/http_service.go b/pkg/service/http_service.go index 3429c441..3d5c6352 100644 --- a/pkg/service/http_service.go +++ b/pkg/service/http_service.go @@ -40,6 +40,12 @@ import ( log "github.com/sirupsen/logrus" ) +// Global sync related constants +const ( + MAX_CHECK_RETRY_TIMES = 20 + BACKUP_CHECK_DURATION = 5 * time.Second +) + // TODO(Drogon): impl a generic http request handle parse json func writeJson(w http.ResponseWriter, data interface{}) { @@ -103,7 +109,7 @@ type CreateCcrRequest struct { // For table sync, allow to create ccr job even if the target table already exists. AllowTableExists bool `json:"allow_table_exists"` ReuseBinlogLabel bool `json:"reuse_binlog_label"` - // 是否为集群级同步，如果为true，将获取源集群所有数据库并为每个数据库创建同步任务 + // Whether it's cluster-level sync, if true, will get all databases from source cluster and create sync task for each database ClusterSync bool `json:"cluster_sync"` } @@ -158,12 +164,12 @@ func createCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobMana return nil } -// createClusterCcr 创建集群级别的CCR同步任务 -// 获取源集群的所有数据库，为每个数据库创建一个同步任务 +// createClusterCcr creates cluster-level CCR sync tasks +// Gets all databases from source cluster and creates a sync task for each database func createClusterCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager) error { log.Infof("create cluster ccr %s", request) - // 获取源集群的所有数据库列表 + // Get all database list from source cluster databases, err := getDatabaseList(&request.Src) if err != nil { return xerror.Wrapf(err, xerror.Normal, "Failed to get database list from source cluster") @@ -179,15 +185,15 @@ func createClusterCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr. successCount := 0 for _, dbName := range databases { - // 为每个数据库创建一个新的请求 + // Create a new request for each database dbRequest := &CreateCcrRequest{ - Name: fmt.Sprintf("%s_%s", request.Name, dbName), // 任务名称加上数据库名称 + Name: fmt.Sprintf("%s_%s", request.Name, dbName), // Task name with database name Src: request.Src, Dest: request.Dest, SkipError: request.SkipError, AllowTableExists: request.AllowTableExists, ReuseBinlogLabel: request.ReuseBinlogLabel, - ClusterSync: false, // 设置为false，避免递归调用 + ClusterSync: false, // Set to false to avoid recursive calls } dbRequest.Src.Database = dbName @@ -214,13 +220,13 @@ func createClusterCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr. log.Infof("Cluster-level sync tasks creation completed, success: %d, failed: %d", successCount, len(errors)) - // 启动守护任务，周期性检测源集群新增数据库，传入已有的数据库列表 + // Start daemon task to periodically detect new databases in source cluster, pass existing database list go startDatabaseMonitor(request, db, jobManager, databases) return nil } -// startDatabaseMonitor 启动一个守护任务，周期性检测源集群新增和删除的数据库，并创建或删除对应的同步任务 +// startDatabaseMonitor starts a daemon task to periodically detect new and deleted databases in source cluster, and create or delete corresponding sync tasks func startDatabaseMonitor(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, initialDatabases []string) { log.Infof("Starting database monitor daemon, task name prefix: %s", request.Name) @@ -244,7 +250,7 @@ func initializeDatabaseTracking(initialDatabases []string) map[string]bool { return existingDatabases } -// monitorDatabaseChanges 检测数据库变化并处理 +// monitorDatabaseChanges detects database changes and handles them func monitorDatabaseChanges(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, existingDatabases map[string]bool) { currentDatabases, err := request.Src.GetAllDatabases() if err != nil { @@ -322,7 +328,7 @@ func handleNewDatabases(newDatabases []string, request *CreateCcrRequest, db sto SkipError: request.SkipError, AllowTableExists: request.AllowTableExists, ReuseBinlogLabel: request.ReuseBinlogLabel, - ClusterSync: false, // 设置为false，避免递归调用 + ClusterSync: false, // Set to false to avoid recursive calls } dbRequest.Src.Database = dbName @@ -332,10 +338,12 @@ func handleNewDatabases(newDatabases []string, request *CreateCcrRequest, db sto for i := 0; i < maxRetries; i++ { if err := createCcr(dbRequest, db, jobManager); err != nil { if i == maxRetries-1 { - log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v", dbName, i+1, maxRetries, err) + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v", + dbName, i+1, maxRetries, err) } else { - log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v, will retry", dbName, i+1, maxRetries, err) - time.Sleep(time.Second * time.Duration(i+1)) // 指数退避 + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v, will retry", + dbName, i+1, maxRetries, err) + time.Sleep(time.Second * time.Duration(i+1)) // Exponential backoff } } else { log.Infof("Successfully created sync task for new database %s", dbName) @@ -367,7 +375,7 @@ func handleDeletedDatabases(deletedDatabases []string, request *CreateCcrRequest log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v", dbName, i+1, maxRetries, err) } else { log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v, will retry", dbName, i+1, maxRetries, err) - time.Sleep(time.Second * time.Duration(i+1)) // 指数退避 + time.Sleep(time.Second * time.Duration(i+1)) // Exponential backoff } } else { log.Infof("Successfully removed sync task for deleted database %s", dbName) @@ -377,7 +385,7 @@ func handleDeletedDatabases(deletedDatabases []string, request *CreateCcrRequest } } -// logMonitoringStatus 记录监控状态 +// logMonitoringStatus logs monitoring status func logMonitoringStatus(newDatabases []string, deletedDatabases []string, existingDatabases map[string]bool) { if len(newDatabases) == 0 && len(deletedDatabases) == 0 { log.Infof("No database changes detected, currently have %d databases", len(existingDatabases)) @@ -387,7 +395,7 @@ func logMonitoringStatus(newDatabases []string, deletedDatabases []string, exist func getDatabaseList(spec *base.Spec) ([]string, error) { log.Infof("Getting database list for cluster %s", spec.Host) - // 使用Specer接口的GetAllDatabases方法 + // Use Specer interface's GetAllDatabases method databases, err := spec.GetAllDatabases() if err != nil { return nil, xerror.Wrapf(err, xerror.Normal, "Failed to get database list") @@ -1333,9 +1341,195 @@ func (s *HttpService) failpointHandler(w http.ResponseWriter, r *http.Request) { result = newSuccessResult() } +// SyncGlobalRequest defines the structure of global sync request +type SyncGlobalRequest struct { + // Required fields + Name string `json:"name"` + Src base.Spec `json:"src"` + Dest base.Spec `json:"dest"` + // Optional fields + All bool `json:"all"` + BackupPrivilege bool `json:"backup_privilege"` + BackupCatalog bool `json:"backup_catalog"` + BackupWorkloadGroup bool `json:"backup_workload_group"` +} + +// Validate SyncGlobalRequest to ensure only one optional field is true +func (r *SyncGlobalRequest) validate() error { + // Check required fields + if r.Name == "" { + return xerror.Errorf(xerror.Normal, "name is required") + } + + // Check optional fields logic: + // If 'all' is set, other options don't need to be checked + // If 'all' is not set, other options can be set freely (multiple or none) + if r.All { + // If 'all' is set, validation passes regardless of other options + return nil + } + + // If 'all' is not set, check if at least one other option is set + if !r.BackupPrivilege && !r.BackupCatalog && !r.BackupWorkloadGroup { + return xerror.Errorf(xerror.Normal, "Must specify at least one sync option: all, backup_privilege, backup_catalog, backup_workload_group") + } + + return nil +} + +// String method implements Stringer interface +func (r *SyncGlobalRequest) String() string { + return fmt.Sprintf("name: %s, src: %v, dest: %v, all: %v, backup_privilege: %v, backup_catalog: %v, backup_workload_group: %v", + r.Name, r.Src, r.Dest, r.All, r.BackupPrivilege, r.BackupCatalog, r.BackupWorkloadGroup) +} + +// syncGlobal executes global sync operation +// createGlobalSnapshot creates a global snapshot on the source cluster +func createGlobalSnapshot(request *SyncGlobalRequest) error { + log.Infof("Creating global snapshot %s", request.Name) + + err := request.Src.CreateGlobalSnapshot( + request.Name, + request.BackupPrivilege, + request.BackupCatalog, + request.BackupWorkloadGroup, + ) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to create global snapshot") + } + + return nil +} + +// waitForGlobalBackupCompletion waits for the global backup to complete +func waitForGlobalBackupCompletion(request *SyncGlobalRequest) error { + log.Infof("Waiting for global backup %s to complete", request.Name) + + for i := 0; i < MAX_CHECK_RETRY_TIMES; i++ { + finished, err := request.Src.CheckGlobalBackupFinished(request.Name) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to check global backup status") + } + + if finished { + log.Infof("Global backup %s completed", request.Name) + return nil + } + + time.Sleep(BACKUP_CHECK_DURATION) + } + + return xerror.Errorf(xerror.Normal, "Timeout waiting for global backup completion, max retry times: %d", MAX_CHECK_RETRY_TIMES) +} + +// processGlobalSnapshotInfo retrieves and processes global snapshot information +func processGlobalSnapshotInfo(request *SyncGlobalRequest) error { + log.Infof("Getting global snapshot %s details", request.Name) + + feRpc, err := rpc.NewFeRpc(&request.Src) + if err != nil { + log.Warnf("Failed to create FE RPC client: %+v", err) + // Don't return error because backup has completed successfully + return nil + } + + snapshot, err := feRpc.GetGlobalSnapshot(&request.Src, request.Name) + if err != nil { + log.Warnf("Failed to get global snapshot details: %+v", err) + // Don't return error because backup has completed successfully + return nil + } + + log.Infof("Global snapshot details: %+v", snapshot) + + if snapshot.GlobalInfo == nil { + log.Warnf("Global snapshot information is empty") + return nil + } + + return executeGlobalSnapshotSQL(request, snapshot.GlobalInfo) +} + +// executeGlobalSnapshotSQL converts and executes global snapshot SQL statements +func executeGlobalSnapshotSQL(request *SyncGlobalRequest, globalInfo []byte) error { + // GlobalInfo contains SQL statements, not JSON format + sqlStatements, err := ccr.NewBackupSqlsFromBytes(globalInfo) + if err != nil { + log.Warnf("Failed to convert global snapshot SQL statements: %+v", err) + return nil // Don't return error as this is not critical + } + + log.Infof("Global snapshot SQL statements: %s", sqlStatements) + + // Call RestoreGlobalInfo function to execute corresponding SQL on dest cluster + err = request.Dest.RestoreGlobalInfo(sqlStatements) + if err != nil { + log.Errorf("Failed to execute global snapshot SQL: %+v", err) + return err + } + + log.Infof("Global snapshot SQL executed successfully") + return nil +} + +// syncGlobal executes global sync operation +func syncGlobal(request *SyncGlobalRequest) error { + log.Infof("Executing global sync %s", request) + + // Step 1: Create global snapshot + if err := createGlobalSnapshot(request); err != nil { + return err + } + + // Step 2: Wait for backup completion + if err := waitForGlobalBackupCompletion(request); err != nil { + return err + } + + // Step 3: Process snapshot information and execute SQL + if err := processGlobalSnapshotInfo(request); err != nil { + return err + } + + return nil +} + +// syncGlobalHandler handles global sync requests +func (s *HttpService) syncGlobalHandler(w http.ResponseWriter, r *http.Request) { + log.Infof("Global sync request") + + var syncResult *defaultResult + defer func() { writeJson(w, syncResult) }() + + // Parse JSON request body + var request SyncGlobalRequest + err := json.NewDecoder(r.Body).Decode(&request) + if err != nil { + log.Warnf("Failed to parse global sync request: %+v", err) + syncResult = newErrorResult(err.Error()) + return + } + + // Validate request + if err = request.validate(); err != nil { + log.Warnf("Global sync request validation failed: %+v", err) + syncResult = newErrorResult(err.Error()) + return + } + + // Execute global sync + if err = syncGlobal(&request); err != nil { + log.Warnf("Global sync failed: %+v", err) + syncResult = newErrorResult(err.Error()) + } else { + syncResult = newSuccessResult() + } +} + func (s *HttpService) RegisterHandlers() { s.mux.HandleFunc("/version", s.versionHandler) s.mux.HandleFunc("/create_ccr", s.createHandler) + s.mux.HandleFunc("/sync_global", s.syncGlobalHandler) s.mux.HandleFunc("/pause", s.pauseHandler) s.mux.HandleFunc("/resume", s.resumeHandler) s.mux.HandleFunc("/delete", s.deleteHandler)