pytest/lib/palo_job.py

#!/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__)