| #!/bin/env python |
| # -*- coding: utf-8 -*- |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| ############################################################################ |
| # |
| # @file palo_job.py |
| # @date 2018-05-08 14:42:27 |
| # @brief 记录palo元数据中的job信息 |
| # |
| ############################################################################# |
| |
| """Palo meta info""" |
| |
| import socket |
| |
| class RepoInfo(object): |
| """ |
| show repositories |
| RepoId： 唯一的仓库ID |
| RepoName： 仓库名称 |
| CreateTime： 第一次创建该仓库的时间 |
| IsReadOnly： 是否为只读仓库 |
| Location： 仓库中用于备份数据的根目录 |
| Broker： 依赖的 Broker |
| ErrMsg： Palo 会定期检查仓库的连通性，如果出现问题，这里会显示错误信息 |
| """ |
| RepoId = 0 |
| RepoName = 1 |
| CreateTime = 2 |
| IsReadOnly = 3 |
| Location = 4 |
| Broker = 5 |
| Type = 6 |
| ErrMsg = 7 |
| |
| def __init__(self, repo_info): |
| self.repo_info = repo_info |
| |
| def get_repo_id(self): |
| """get repoid""" |
| return self.repo_info[RepoInfo.RepoId] |
| |
| def get_repo_name(self): |
| """get repo name""" |
| return self.repo_info[RepoInfo.RepoName] |
| |
| def get_isReadOnly(self): |
| """get isreadonly""" |
| return self.repo_info[RepoInfo.IsReadOnly] |
| |
| def get_location(self): |
| """get repo location""" |
| return self.repo_info[RepoInfo.Location] |
| |
| def get_broker(self): |
| """get broker""" |
| return self.repo_info[RepoInfo.Broker] |
| |
| def get_errmsg(self): |
| """get errmsg""" |
| return self.repo_info[RepoInfo.ErrMsg] |
| |
| def get_create_time(self): |
| """get create time""" |
| return self.repo_info[RepoInfo.CreateTime] |
| |
| |
| class BackupJob(object): |
| """ |
| JobId： 唯一作业id |
| SnapshotName： 备份的名称 |
| DbName： 所属数据库 |
| State： 当前阶段 |
| PENDING： 提交作业后的初始状态 |
| SNAPSHOTING： 执行快照中 |
| UPLOAD_SNAPSHOT：快照完成，准备上传 |
| UPLOADING： 快照上传中 |
| SAVE_META： 将作业元信息保存为本地文件 |
| UPLOAD_INFO： 上传作业元信息 |
| FINISHED： 作业成功 |
| CANCELLED： 作业失败 |
| BackupObjs： 备份的表和分区 |
| CreateTime： 任务提交时间 |
| SnapshotFinishedTime： 快照完成时间 |
| UploadFinishedTime： 快照上传完成时间 |
| FinishedTime： 作业结束时间 |
| UnfinishedTasks： 在 SNAPSHOTING 和 UPLOADING 阶段会显示还未完成的子任务id |
| Status： 如果作业失败，显示失败信息 |
| Timeout： 作业超时时间，单位秒 |
| """ |
| JobId = 0 |
| SnapshotName = 1 |
| DbName = 2 |
| State = 3 |
| BackupObjs = 4 |
| CreateTime = 5 |
| SnapshotFinishedTime = 6 |
| UploadFinishedTime = 7 |
| FinishedTime = 8 |
| UnfinishedTasks = 9 |
| Progress = 10 |
| TaskErrMsg = 11 |
| Status = 12 |
| Timeout = 13 |
| |
| def __init__(self, backup_job): |
| self.backup_job = backup_job |
| |
| def get_state(self): |
| """get state""" |
| return self.backup_job[BackupJob.State] |
| |
| def get_dbName(self): |
| """get dbname""" |
| return self.backup_job[BackupJob.DbName] |
| |
| def get_snapshotName(self): |
| """get snapshot name""" |
| return self.backup_job[BackupJob.SnapshotName] |
| |
| def get_create_time(self): |
| """get_create_time""" |
| return self.backup_job[BackupJob.CreateTime] |
| |
| def get_snap_finish_time(self): |
| """get_snap_finish_time""" |
| return self.backup_job[BackupJob.SnapshotFinishedTime] |
| |
| def get_upload_finish_time(self): |
| """get_upload_finish_time""" |
| return self.backup_job[BackupJob.UploadFinishedTime] |
| |
| def get_finished_time(self): |
| """get_finished_time""" |
| return self.backup_job[BackupJob.FinishedTime] |
| |
| |
| class RestoreJob(object): |
| """ |
| show restore |
| JobId： 唯一作业id |
| Label： 要恢复的备份的名称 |
| Timestamp： 要恢复的备份的时间版本 |
| DbName： 所属数据库 |
| State： 当前阶段 |
| PENDING： 提交作业后的初始状态 |
| SNAPSHOTING： 执行快照中 |
| DOWNLOAD： 快照完成，准备下载仓库中的快照 |
| DOWNLOADING： 快照下载中 |
| COMMIT： 快照下载完成，准备生效 |
| COMMITING： 生效中 |
| FINISHED： 作业成功 |
| CANCELLED： 作业失败 |
| AllowLoad： 恢复时是否允许导入（当前不支持） |
| ReplicationNum： 指定恢复的副本数 |
| ReplicaAllocation |
| RestoreJobs： 要恢复的表和分区 |
| CreateTime： 任务提交时间 |
| MetaPreparedTime： 元数据准备完成时间 |
| SnapshotFinishedTime： 快照完成时间 |
| DownloadFinishedTime： 快照下载完成时间 |
| FinishedTime： 作业结束时间 |
| UnfinishedTasks： 在 SNAPSHOTING、DOWNLOADING 和 COMMITING 阶段会显示还未完成的子任务id |
| Status： 如果作业失败，显示失败信息 |
| Timeout： 作业超时时间，单位秒 |
| """ |
| JobId = 0 |
| Label = 1 |
| Timestamp = 2 |
| DbName = 3 |
| State = 4 |
| AllowLoad = 5 |
| ReplicationNum = 6 |
| ReplicaAllocation = 7 |
| ReserveReplica = 8 |
| RestoreObjs = 9 |
| CreateTime = 10 |
| MetaPreparedTime = 11 |
| SnapshotFinishedTime = 12 |
| DownloadFinishedTime = 13 |
| FinishedTime = 14 |
| UnfinishedTaskes = 15 |
| Progress = 16 |
| TaskErrMsg = 17 |
| Status = 18 |
| Timout = 19 |
| |
| def __init__(self, restore_job): |
| self.restore_job = restore_job |
| |
| def get_dbName(self): |
| """get dbname""" |
| return self.restore_job[RestoreJob.DbName] |
| |
| def get_state(self): |
| """get state""" |
| return self.restore_job[RestoreJob.State] |
| |
| def get_allowLoad(self): |
| """get allowload""" |
| return self.restore_job[RestoreJob.AllowLoad] |
| |
| def get_create_time(self): |
| """get_create_time""" |
| return self.restore_job[RestoreJob.CreateTime] |
| |
| def get_meta_prepare_time(self): |
| """get MetaPreparedTime""" |
| return self.restore_job[RestoreJob.MetaPreparedTime] |
| |
| def get_snapshot_finished_time(self): |
| """get SnapshotFinishedTime""" |
| return self.restore_job[RestoreJob.SnapshotFinishedTime] |
| |
| def get_down_load_finished(self): |
| """get DownloadFinishedTime""" |
| return self.restore_job[RestoreJob.DownloadFinishedTime] |
| |
| def get_finished(self): |
| """get FinishedTime""" |
| return self.restore_job[RestoreJob.FinishedTime] |
| |
| |
| class SnapshotInfo(object): |
| """show snapshot on repo""" |
| Snapshot = 0 |
| Timestamp = 1 |
| Status = 2 |
| |
| def __init__(self, snapshot): |
| self.snapshot = snapshot |
| |
| def get_snapshot_name(self): |
| """get snapshot name""" |
| return self.snapshot[SnapshotInfo.Snapshot] |
| |
| def get_timestamp(self): |
| """get backup timestamp""" |
| return self.snapshot[SnapshotInfo.Timestamp] |
| |
| |
| class SchemaChangeJob(object): |
| """show alter table column same with show proc '/jobs/dbid/schema_change'""" |
| JobId = 0 |
| TableName = 1 |
| CreateTime = 2 |
| FinishTime = 3 |
| IndexName = 4 |
| IndexId = 5 |
| OriginIndexId = 6 |
| SchemaVersion = 7 |
| TransactionId = 8 |
| State = 9 |
| Msg = 10 |
| Progress = 11 |
| Timeout = 12 |
| |
| def __init__(self, schemachange_job): |
| self.schema_change_job = schemachange_job |
| |
| def get_state(self): |
| """get state""" |
| return self.schema_change_job[SchemaChangeJob.State] |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.schema_change_job[SchemaChangeJob.TableName] |
| |
| def get_msg(self): |
| """get msg""" |
| return self.schema_change_job[SchemaChangeJob.Msg] |
| |
| def get_create_time(self): |
| """get CreateTime""" |
| return self.schema_change_job[SchemaChangeJob.CreateTime] |
| |
| def get_finish_time(self): |
| """get FinishTime""" |
| return self.schema_change_job[SchemaChangeJob.FinishTime] |
| |
| |
| class RollupJob(object): |
| """show alter table rolllup same with show proc '/jobs/dbid/rollup'""" |
| JobId = 0 |
| TableName = 1 |
| CreateTime = 2 |
| FinishedTime = 3 |
| BaseIndexName = 4 |
| RollupIndexName = 5 |
| RollupId = 6 |
| TransactionId = 7 |
| State = 8 |
| Msg = 9 |
| Progress = 10 |
| Timeout = 11 |
| |
| def __init__(self, rollup_job): |
| self.rollup_job = rollup_job |
| |
| def get_state(self): |
| """get state""" |
| return self.rollup_job[RollupJob.State] |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.rollup_job[RollupJob.TableName] |
| |
| def get_index_name(self): |
| """get index name""" |
| return self.rollup_job[RollupJob.RollupIndexName] |
| |
| def get_msg(self): |
| """get msg""" |
| return self.rollup_job[RollupJob.Msg] |
| |
| |
| class DeleteJob(object): |
| """show delete different with show proc '/jobs/dbid/delete', this show delete result""" |
| TableName = 0 |
| PartitionName = 1 |
| CreateTime = 2 |
| DeleteCondition = 3 |
| State = 4 |
| |
| def __init__(self, delete_job): |
| self.delete_job = delete_job |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.delete_job[DeleteJob.TableName] |
| |
| def get_partition_name(self): |
| """get partition name""" |
| return self.delete_job[DeleteJob.PartitionName] |
| |
| def get_create_time(self): |
| """get CreateTime""" |
| return self.delete_job[DeleteJob.CreateTime] |
| |
| def get_state(self): |
| """get state""" |
| return self.delete_job[DeleteJob.State] |
| |
| |
| class LoadJob(object): |
| """show load same with show proc '/jobs/dbid/load'""" |
| JobId = 0 |
| Label = 1 |
| State = 2 |
| Progress = 3 |
| Type = 4 |
| EtlInfo = 5 |
| TaskInfo = 6 |
| Errormsg = 7 |
| CreateTime = 8 |
| EtlStartTime = 9 |
| EtlFinishTime = 10 |
| LoadStartTime = 11 |
| LoadFinishTime = 12 |
| URL = 13 |
| JobDetails = 14 |
| |
| def __init__(self, load_job): |
| self.load_job = load_job |
| |
| def get_label(self): |
| """get label""" |
| return self.load_job[self.Label] |
| |
| def get_state(self): |
| """get state""" |
| return self.load_job[self.State] |
| |
| def get_errormsg(self): |
| """get errormsg""" |
| return self.load_job[self.Errormsg] |
| |
| def get_url(self): |
| """get url""" |
| return self.load_job[self.URL] |
| |
| def get_etlinfo(self): |
| """get etl info""" |
| return self.load_job[self.EtlInfo] |
| |
| def get_taskinfo(self): |
| """get task info""" |
| return self.load_job[self.TaskInfo] |
| |
| |
| class ExportJob(object): |
| """show export same with show proc '/jobs/dbid/export'""" |
| JobId = 0 |
| Label = 1 |
| State = 2 |
| Progress = 3 |
| TaskInfo = 4 |
| Path = 5 |
| CreateTime = 6 |
| StartTime = 7 |
| FinishTime = 8 |
| Timeout = 9 |
| ErrorMsg = 10 |
| |
| def __init__(self, export_job): |
| self.export_job = export_job |
| |
| def get_state(self): |
| """get state""" |
| return self.export_job[self.State] |
| |
| def get_label(self): |
| """get label""" |
| return self.export_job[self.Label] |
| |
| def get_timeout(self): |
| """get timeout""" |
| return self.export_job[self.Timeout] |
| |
| def get_error_msg(self): |
| """get error msg""" |
| return self.export_job[self.ErrorMsg] |
| |
| def get_task_info(self): |
| """get statistic""" |
| statistic = self.export_job[self.TaskInfo] |
| return eval(statistic) |
| |
| def get_exec_mem_limit(self): |
| """get exec mem limit""" |
| return self.get_task_info()["exec mem limit"] |
| |
| def get_column_separator(self): |
| """get column separator""" |
| return self.get_task_info()["column separator"] |
| |
| def get_line_delimiter(self): |
| """get line delimiter""" |
| return self.get_task_info()["line delimiter"] |
| |
| def get_tablet_num(self): |
| """get tablet num""" |
| return self.get_task_info()["tablet num"] |
| |
| def get_coord_num(self): |
| """get coord num""" |
| return self.get_task_info()["coord num"] |
| |
| |
| class SelectIntoInfo(object): |
| """select into """ |
| FileNumber = 0 |
| TotalRows= 1 |
| FileSize = 2 |
| URL = 3 |
| |
| def __init__(self, info): |
| self.select_into_info = info |
| |
| def get_file_number(self): |
| """get file number""" |
| return self.select_into_info[self.FileNumber] |
| |
| def get_total_rows(self): |
| """get file number""" |
| return self.select_into_info[self.TotalRows] |
| |
| def get_url(self): |
| """get file number""" |
| return self.select_into_info[self.URL] |
| |
| |
| class BackendShowInfo(object): |
| """show backends different with show proc '/backends';""" |
| BackendId = 0 |
| Host = 1 |
| HeartbeatPort = 2 |
| BePort = 3 |
| HttpPort = 4 |
| BrpcPort = 5 |
| LastStartTime = 6 |
| LastHeartbeat = 7 |
| Alive = 8 |
| SystemDecommissioned = 9 |
| TabletNum = 10 |
| DataUsedCapacity = 11 |
| AvailCapacity = 12 |
| TotalCapacity = 13 |
| UsedPct = 14 |
| MaxDiskUsedPct = 15 |
| RemoteUsedCapacity = 16 |
| Tag = 17 |
| ErrMsg = 18 |
| Version = 19 |
| Status = 20 |
| HeartbeatFailureCounter = 21 |
| NodeRole = 22 |
| |
| def __init__(self, be_info): |
| self.be_info = be_info |
| |
| def get_backend_id(self): |
| """get backend id""" |
| return self.be_info[self.BackendId] |
| |
| def get_ip(self): |
| """get ip""" |
| return socket.gethostbyname(self.be_info[self.Host]) |
| |
| def get_alive(self): |
| """get be state """ |
| return self.be_info[self.Alive] |
| |
| |
| class BackendProcInfo(object): |
| """show proc '/backends' info different with show backends""" |
| BackendId = 0 |
| Host = 1 |
| HeartbeatPort = 2 |
| BePort = 3 |
| HttpPort = 4 |
| BrpcPort = 5 |
| LastStartTime = 6 |
| LastHeartbeat = 7 |
| Alive = 8 |
| SystemDecommissioned = 9 |
| TabletNum = 10 |
| DataUsedCapacity = 11 |
| AvailCapacity = 12 |
| TotalCapacity = 13 |
| UsedPct = 14 |
| MaxDiskUsedPct = 15 |
| RemoteUsedCapacity = 16 |
| Tag = 17 |
| ErrMsg = 18 |
| Version = 19 |
| Status = 20 |
| HeartbeatFailureCounter = 21 |
| NodeRole = 22 |
| |
| def __init__(self, be_info): |
| self.be_info = be_info |
| |
| def get_backend_id(self): |
| """get backend_id""" |
| return self.be_info[self.BackendId] |
| |
| def get_ip(self): |
| """get ip""" |
| return socket.gethostbyname(self.be_info[self.Host]) |
| |
| def get_hostname(self): |
| """get hostname""" |
| return self.be_info[self.Host] |
| |
| def get_alive(self): |
| """get alive""" |
| return self.be_info[self.Alive] |
| |
| def get_httpport(self): |
| """get httpport""" |
| return self.be_info[self.HttpPort] |
| |
| def get_heartbeatport(self): |
| """get heartbeatport""" |
| return self.be_info[self.HeartbeatPort] |
| |
| def get_backend_start_time(self): |
| """get start time""" |
| return self.be_info[self.LastStartTime] |
| |
| def get_tag(self): |
| """get tag""" |
| tag_json = eval(self.be_info[self.Tag]) |
| tags = tag_json['location'] |
| return tags |
| |
| |
| class FrontendInfo(object): |
| """show proc '/frontends'""" |
| Name = 0 |
| Host = 1 |
| EditLogPort = 2 |
| HttpPort = 3 |
| QueryPort = 4 |
| RpcPort = 5 |
| Role = 6 |
| IsMaster = 7 |
| ClusterId = 8 |
| Join = 9 |
| Alive = 10 |
| ReplayedJournalId = 11 |
| LastHeartbeat = 12 |
| IsHelper = 13 |
| ErrMsg = 14 |
| Version = 15 |
| CurrentConnected =16 |
| |
| def __init__(self, frontend): |
| self.frontend = frontend |
| |
| def get_ismaster(self): |
| """get ismaster""" |
| return self.frontend[self.IsMaster] |
| |
| def get_host(self): |
| """get host""" |
| return self.frontend[self.Host] |
| |
| def get_httpport(self): |
| """get port""" |
| return self.frontend[self.HttpPort] |
| |
| def get_role(self): |
| """get role""" |
| return self.frontend[self.Role] |
| |
| def get_alive(self): |
| """get alive""" |
| return self.frontend[self.Alive] |
| |
| def get_IP(self): |
| """get IP""" |
| return socket.gethostbyname(self.frontend[self.Host]) |
| |
| def get_LastHeartbeat(self): |
| """get LastUpdateTime""" |
| return self.frontend[self.LastHeartbeat] |
| |
| |
| class FrontendShowInfo(object): |
| """show frontends """ |
| Name = 0 |
| Host = 1 |
| EditLogPort = 2 |
| HttpPort = 3 |
| QueryPort = 4 |
| RpcPort = 5 |
| Role = 6 |
| IsMaster = 7 |
| ClusterId = 8 |
| Join = 9 |
| Alive = 10 |
| ReplayedJournalId = 11 |
| LastHeartbeat = 12 |
| IsHelper = 13 |
| ErrMsg = 14 |
| Version = 15 |
| CurrentConnected = 16 |
| |
| def __init__(self, frontend): |
| self.frontend = frontend |
| |
| def get_ismaster(self): |
| """get ismaster""" |
| return self.frontend[self.IsMaster] |
| |
| def get_ip(self): |
| """get ip""" |
| return socket.gethostbyname(self.frontend[self.Host]) |
| |
| |
| class BrokerInfo(object): |
| """ |
| show proc '/brokers' |
| Name: broker 名字 |
| Host： broker host |
| Port：端口 |
| Alive：是否活着 |
| LastStartTime：上一次启动时间 |
| LastUpdateTime：上一次心跳时间，随时变 |
| ErrMsg： Palo 会定期检查仓库的连通性，如果出现问题，这里会显示错误信息 |
| """ |
| Name = 0 |
| Host = 1 |
| Port = 2 |
| Alive = 3 |
| LastStartTime = 4 |
| LastUpdateTime = 5 |
| ErrMsg = 6 |
| |
| def __init__(self, broker_info): |
| self.broker_info = broker_info |
| |
| def get_name(self): |
| """get Name""" |
| return self.broker_info[BrokerInfo.Name] |
| |
| def get_ip(self): |
| """get IP""" |
| return socket.gethostbyname(self.broker_info[self.Host]) |
| |
| def get_port(self): |
| """get Port""" |
| return self.broker_info[BrokerInfo.Port] |
| |
| def get_alive(self): |
| """get Alive""" |
| return self.broker_info[BrokerInfo.Alive] |
| |
| def get_last_start_time(self): |
| """get LastStartTime""" |
| return self.broker_info[BrokerInfo.LastStartTime] |
| |
| def get_last_update_time(self): |
| """get LastUpdateTime""" |
| return self.broker_info[BrokerInfo.LastUpdateTime] |
| |
| def get_errmsg(self): |
| """get ErrMsg""" |
| return self.broker_info[BrokerInfo.ErrMsg] |
| |
| |
| class GrantInfo(object): |
| """show grants ; show proc '/auth'""" |
| UserIdentity = 0 |
| Password = 1 |
| Roles = 2 |
| GlobalPrivs = 3 |
| CatalogPrivs = 4 |
| DatabasePrivs = 5 |
| TablePrivs = 6 |
| ResourcePrivs = 7 |
| |
| def __init__(self, grant): |
| self.grant = grant |
| |
| def get_user_identity(self): |
| """get user identity""" |
| return self.grant[self.UserIdentity] |
| |
| def get_password(self): |
| """get password""" |
| return self.grant[self.Password] |
| |
| def get_global_privs(self): |
| """get global privs""" |
| return self.grant[self.GlobalPrivs] |
| |
| def get_database_privs(self): |
| """get database privs""" |
| return self.grant[self.DatabasePrivs] |
| |
| def get_table_privs(self): |
| """get table privs""" |
| return self.grant[self.TablePrivs] |
| |
| |
| class DescInfo(object): |
| """desc table_name""" |
| Field = 0 |
| Type = 1 |
| Null = 2 |
| Key = 3 |
| Default = 4 |
| Extra = 5 |
| |
| def __init__(self, column_info): |
| self.column_info = column_info |
| |
| def get_field(self): |
| """get column filed name""" |
| return self.column_info[self.Field] |
| |
| def get_type(self): |
| """get column type""" |
| return self.column_info[self.Type] |
| |
| def get_null(self): |
| """get column is null""" |
| return self.column_info[self.Null] |
| |
| def get_key(self): |
| """get column is key""" |
| return self.column_info[self.Key] |
| |
| def get_default(self): |
| """get column is key""" |
| return self.column_info[self.Key] |
| |
| def get_extra(self): |
| """get extra""" |
| return self.column_info[self.Extra] |
| |
| |
| class DescInfoAll(object): |
| """desc all""" |
| IndexName = 0 |
| IndexKeyType = 1 |
| Field = 2 |
| Type = 3 |
| Null = 4 |
| Key = 5 |
| Default = 6 |
| Extra = 7 |
| |
| def __init__(self, column_info): |
| self.column_info = column_info |
| |
| def get_index_name(self): |
| """get index name""" |
| return self.column_info[self.IndexName] |
| |
| def get_field(self): |
| """get column filed name""" |
| return self.column_info[self.Field] |
| |
| def get_type(self): |
| """get column type""" |
| return self.column_info[self.Type] |
| |
| def get_null(self): |
| """get column is null""" |
| return self.column_info[self.Null] |
| |
| def get_key(self): |
| """get column is key""" |
| return self.column_info[self.Key] |
| |
| def get_default(self): |
| """get column is key""" |
| return self.column_info[self.Key] |
| |
| def get_extra(self): |
| """get extra""" |
| return self.column_info[self.Extra] |
| |
| |
| class PartitionInfo(object): |
| """show partitions""" |
| PartitionId = 0 |
| PartitionName = 1 |
| VisibleVersion = 2 |
| VisibleVersionTime = 3 |
| State = 4 |
| PartitionKey = 5 |
| Range = 6 |
| DistributionKey = 7 |
| Buckets = 8 |
| ReplicationNum = 9 |
| StorageMedium = 10 |
| CooldownTime = 11 |
| RemoteStoragePolicy = 12 |
| LastConsistencyCheckTime = 13 |
| DataSize = 14 |
| IsInMemory = 15 |
| ReplicaAllocation = 16 |
| IsMutable = 17 |
| |
| def __init__(self, partition): |
| self.partition = partition |
| |
| def get_partition_name(self): |
| """get partition name""" |
| return self.partition[self.PartitionName] |
| |
| def get_replication_num(self): |
| """get replication num""" |
| return self.partition[self.ReplicationNum] |
| |
| def get_buckets(self): |
| """get buckets""" |
| return self.partition[self.Buckets] |
| |
| def get_is_in_memory(self): |
| """get is in memory""" |
| return self.partition[self.IsInMemory] |
| |
| def get_replica_allocation(self): |
| """get replica allocation""" |
| return self.partition[self.ReplicaAllocation] |
| |
| |
| class RoutineLoadJob(object): |
| """show routine load """ |
| Id = 0 |
| Name = 1 |
| CreateTime = 2 |
| PauseTime = 3 |
| EndTime = 4 |
| DbName = 5 |
| TableName = 6 |
| IsMultiTable = 7 |
| State = 8 |
| DataSourceType = 9 |
| CurrentTaskNum = 10 |
| JobProperties = 11 |
| DataSourceProperties = 12 |
| CustomProperties = 13 |
| Statistic = 14 |
| Progress = 15 |
| Lag = 16 |
| ReasonOfStateChanged = 17 |
| ErrorLogUrls = 18 |
| OtherMsg = 19 |
| User = 20 |
| Comment = 21 |
| |
| def __init__(self, routine_job): |
| self.routine_job = routine_job |
| |
| def get_state(self): |
| """get routine job state""" |
| return self.routine_job[self.State] |
| |
| def get_name(self): |
| """get routine job name""" |
| return self.routine_job[self.Name] |
| |
| def get_progress(self): |
| """get progress""" |
| return self.routine_job[self.Progress] |
| |
| def get_statistic(self): |
| """get statistic""" |
| statistic = self.routine_job[self.Statistic] |
| return eval(statistic) |
| |
| def get_error_log_urls(self): |
| """get errorlogurls""" |
| return self.routine_job[self.ErrorLogUrls] |
| |
| def get_job_properties(self): |
| """get job properties""" |
| property = self.routine_job[self.JobProperties] |
| return eval(property) |
| |
| def get_current_task_num(self): |
| """get current task num""" |
| return self.routine_job[self.CurrentTaskNum] |
| |
| def get_reason_of_state_changed(self): |
| """get reason of state changed""" |
| return self.routine_job[self.ReasonOfStateChanged] |
| |
| def get_received_bytes_rate(self): |
| """get received bytes rate""" |
| return self.get_statistic()["receivedBytesRate"] |
| |
| def get_loaded_rows(self): |
| """get loaded rows""" |
| return self.get_statistic()["loadedRows"] |
| |
| def get_error_rows(self): |
| """get error rows""" |
| return self.get_statistic()["errorRows"] |
| |
| def get_total_rows(self): |
| """get total rows""" |
| return self.get_statistic()["totalRows"] |
| |
| def get_unselected_rows(self): |
| """get unselected rows""" |
| return self.get_statistic()["unselectedRows"] |
| |
| def get_task_execute_time_ms(self): |
| """get task execute time ms""" |
| return self.get_statistic()["taskExecuteTimeMs"] |
| |
| def get_task_committed_task_num(self): |
| """get task committed task num""" |
| return self.get_statistic()["committedTaskNum"] |
| |
| def get_task_aborted_task_num(self): |
| """get task aborted task num""" |
| return self.get_statistic()["abortedTaskNum"] |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.routine_job[self.TableName] |
| |
| def get_db_name(self): |
| """get database name""" |
| return self.routine_job[self.DbName] |
| |
| def get_merge_type(self): |
| """get merge type""" |
| return self.get_job_properties()["mergeType"] |
| |
| |
| class RoutineLoadTask(object): |
| """show routine load task""" |
| TaskId = 0 |
| TxnId = 1 |
| JobId = 2 |
| CreateTime = 3 |
| ExecuteStartTime = 4 |
| BeId = 5 |
| DataSourceProperties = 6 |
| |
| def __init__(self, routine_task): |
| self.routine_task = routine_task |
| |
| def get_taskid(self): |
| """get taskid""" |
| return self.routine_task[self.TaskId] |
| |
| def get_jobid(self): |
| """get jobid""" |
| return self.routine_task[self.JobId] |
| |
| def get_beid(self): |
| """get beid""" |
| return self.routine_task[self.BeId] |
| |
| |
| class TabletsInfo(object): |
| """ |
| show tablets from table_name |
| SHOW PROC '/dbs/db_id/table_id/partitions/partition_id/index_id/tablet_id' |
| """ |
| TabletId = 0 |
| ReplicaId = 1 |
| BackendId = 2 |
| SchemaHash = 3 |
| Version = 4 |
| LstSuccessVersion = 5 |
| LstFailedVersion = 6 |
| LstFailedTime = 7 |
| LocalDataSize = 8 |
| RemoteDataSize = 9 |
| RowCount = 10 |
| State = 11 |
| LstConsistencyCheckTime = 12 |
| CheckVersion = 13 |
| VersionCount = 14 |
| QueryHits = 15 |
| PathHash = 16 |
| MetaUrl = 17 |
| CompactionStatus = 18 |
| CooldownReplicaId = 19 |
| CooldownMetaId = 20 |
| |
| def __init__(self, tablet_info): |
| self.tablet_info = tablet_info |
| |
| def get_tablet_id(self): |
| """get tablet id""" |
| return self.tablet_info[self.TabletId] |
| |
| def get_replica_id(self): |
| """get replica id""" |
| return self.tablet_info[self.ReplicaId] |
| |
| def get_backend_id(self): |
| """get backend id""" |
| return self.tablet_info[self.BackendId] |
| |
| def get_state(self): |
| """get state""" |
| return self.tablet_info[self.State] |
| |
| def get_compaction_status(self): |
| """get compaction status""" |
| return self.tablet_info[self.CompactionStatus] |
| |
| |
| class TabletIdInfo(object): |
| """show tablet tablet_id""" |
| DbName = 0 |
| TableName = 1 |
| PartitionName = 2 |
| IndexName = 3 |
| DbId = 4 |
| TableId = 5 |
| PartitionId = 6 |
| IndexId = 7 |
| IsSync = 8 |
| Order = 9 |
| QueryHits = 10 |
| DetailCmd = 11 |
| |
| def __init__(self, tablet_id_info): |
| self.tablet_id_info = tablet_id_info |
| |
| def get_db_name(self): |
| """get db name""" |
| return self.tablet_id_info[self.DbName] |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.tablet_id_info[self.TableName] |
| |
| def get_partition_name(self): |
| """get partition name""" |
| return self.tablet_id_info[self.PartitionName] |
| |
| def get_index_name(self): |
| """get index name""" |
| return self.tablet_id_info[self.IndexName] |
| |
| def get_db_id(self): |
| """get db id""" |
| return self.tablet_id_info[self.DbId] |
| |
| def get_table_id(self): |
| """get table id""" |
| return self.tablet_id_info[self.TableId] |
| |
| def get_partition_id(self): |
| """get partition id""" |
| return self.tablet_id_info[self.PartitionId] |
| |
| def get_index_id(self): |
| """get index id""" |
| return self.tablet_id_info[self.IndexId] |
| |
| def get_is_sync(self): |
| """get is sync""" |
| return self.tablet_id_info[self.IsSync] |
| |
| def get_detail_cmd(self): |
| """get detail cmd""" |
| return self.tablet_id_info[self.DetailCmd] |
| |
| |
| class TransactionInfo(object): |
| """show transcation""" |
| TransactionId = 0 |
| Label = 1 |
| Coordinator = 2 |
| TransactionStatus = 3 |
| LoadJobSourceType = 4 |
| PrepareTime = 5 |
| PreCommitTime = 6 |
| CommitTime = 7 |
| PublishTime = 8 |
| FinishTime = 9 |
| Reason = 10 |
| ErrorReplicasCount = 11 |
| ListenerId = 12 |
| TimeoutMs = 13 |
| ErrMsg = 14 |
| |
| def __init__(self, txn): |
| self.txn = txn |
| |
| def get_transaction_id(self): |
| """get transaction id""" |
| return self.txn[self.TransactionId] |
| |
| def get_label(self): |
| """get label""" |
| return self.txn[self.Label] |
| |
| def get_transaction_status(self): |
| """get txn status""" |
| return self.txn[self.TransactionStatus] |
| |
| def get_timeout_ms(self): |
| """get txn timeout ms""" |
| return self.txn[self.TimeoutMs] |
| |
| |
| class TableIndexInfo(object): |
| """show index from database.table""" |
| TableName = 0 |
| NonUnique = 1 |
| KeyName = 2 |
| SeqInIndex = 3 |
| ColumnName = 4 |
| Collation = 5 |
| Cardinality = 6 |
| SubPart = 7 |
| Packed = 8 |
| IsNull = 9 |
| IndexType = 10 |
| Comment = 11 |
| |
| def __init__(self, table_index_info): |
| self.table_index_info = table_index_info |
| |
| def get_table_name(self): |
| """get table name""" |
| return self.table_index_info[self.TableName] |
| |
| def get_key_name(self): |
| """get index key name""" |
| return self.table_index_info[self.KeyName] |
| |
| def get_column_name(self): |
| """get column name""" |
| return self.table_index_info[self.ColumnName] |
| |
| def get_index_type(self): |
| """get column name""" |
| return self.table_index_info[self.IndexType] |
| |
| |
| class AdminShowConfig(object): |
| """ADMIN SHOW FRONTEND CONFIG [LIKE "pattern"]""" |
| Key = 0 |
| Value = 1 |
| Type = 2 |
| IsMutable = 3 |
| MasterOnly = 4 |
| Comment = 5 |
| |
| def __init__(self, key_config): |
| self.key_config = key_config |
| |
| def get_key(self): |
| """get key""" |
| return self.key_config[self.Key] |
| |
| def get_value(self): |
| """get value""" |
| return self.key_config[self.Value] |
| |
| |
| class DynamicPartitionInfo(object): |
| """show dynamic partition tables""" |
| TableName = 0 |
| Enable = 1 |
| TimeUnit = 2 |
| Start = 3 |
| End = 4 |
| Prefix = 5 |
| Buckets = 6 |
| ReplicationNum = 7 |
| ReplicaAllocation = 8 |
| StartOf = 9 |
| LastUpdatetime = 10 |
| LastSchedulerTime = 11 |
| State = 12 |
| LastCreatePartitionMsg = 13 |
| LastDropPartitionMsg = 14 |
| |
| def __init__(self, dynamic_partition_info): |
| self.dynamic_partition_info = dynamic_partition_info |
| |
| def get_enable(self): |
| """get enable""" |
| return self.dynamic_partition_info[self.Enable] |
| |
| def get_time_unit(self): |
| """get time unit""" |
| return self.dynamic_partition_info[self.TimeUnit] |
| |
| def get_start(self): |
| """get start""" |
| return self.dynamic_partition_info[self.Start] |
| |
| def get_end(self): |
| """get end""" |
| return self.dynamic_partition_info[self.End] |
| |
| def get_prefix(self): |
| """get prefix""" |
| return self.dynamic_partition_info[self.Prefix] |
| |
| def get_buckets(self): |
| """get buckets""" |
| return self.dynamic_partition_info[self.Buckets] |
| |
| def get_replication_num(self): |
| """get replication num""" |
| return self.dynamic_partition_info[self.ReplicationNum] |
| |
| def get_start_of(self): |
| """get start of""" |
| return self.dynamic_partition_info[self.StartOf] |
| |
| |
| class SyncJobInfo(object): |
| """show sync job""" |
| JobId = 0 |
| JobName = 1 |
| Type = 2 |
| State = 3 |
| Channel = 4 |
| Status = 5 |
| JobConfig = 6 |
| CreateTime = 7 |
| LastStartTime = 8 |
| LastStopTime = 9 |
| FinishTime = 10 |
| Msg = 11 |
| |
| def __init__(self, sync_job_info): |
| self.sync_job_info = sync_job_info |
| |
| def get_job_name(self): |
| """get job name""" |
| return self.sync_job_info[self.JobName] |
| |
| def get_state(self): |
| """get state""" |
| return self.sync_job_info[self.State] |
| |
| def get_channel(self): |
| """get channel""" |
| return self.sync_job_info[self.Channel] |
| |
| def get_job_config(self): |
| """get job config""" |
| return self.sync_job_info[self.JobConfig] |
| |
| |
| class ReplicaStatus(object): |
| """admin show replica status""" |
| TabletId = 0 |
| ReplicaId = 1 |
| BackendId = 2 |
| Version = 3 |
| LastFailedVersion = 4 |
| LastSuccessVersion = 5 |
| CommittedVersion = 6 |
| SchemaHash = 7 |
| VersionNum = 8 |
| IsBad = 9 |
| State = 10 |
| Status = 11 |
| |
| def __init__(self, replica_status): |
| self.replica_status = replica_status |
| |
| def get_backend_id(self): |
| """get backend id""" |
| return self.replica_status[self.BackendId] |
| |
| |
| if __name__ == '__main__': |
| print(ReplicaStatus.__name__) |
| |
