mariadb-columnstore-engine/writeengine/redistribute/we_redistributedef.h

/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/*
* $Id: we_redistributedef.h 4450 2013-01-21 14:13:24Z rdempsey $
*/

#ifndef WE_REDISTRIBUTEDEF_H
#define WE_REDISTRIBUTEDEF_H

#include <stdint.h>
#include <time.h>

namespace redistribute
{

// version number for parsing the info and plan files
const uint32_t RED_VERSION_NUM   = 1;

// state values
const uint32_t RED_STATE_UNDEF   = 0;  // indication of failed to retrieve redistribute status.
const uint32_t RED_STATE_IDLE    = 1;
const uint32_t RED_STATE_ACTIVE  = 2;
const uint32_t RED_STATE_FINISH  = 3;
const uint32_t RED_STATE_STOPPED = 4;
const uint32_t RED_STATE_FAILED  = 5;
const uint32_t RED_STATE_INCOMP  = 6;

// partition transfer state
const uint32_t RED_TRANS_READY   = 20;
const uint32_t RED_TRANS_SUCCESS = 21;
const uint32_t RED_TRANS_SKIPPED = 22;
const uint32_t RED_TRANS_FAILED  = 23;


// return code to shell or between redistribute entities
enum RED_ErrorCode {
	RED_EC_OK,

	// return code for util, for shell script to check exit status value is [0, 255]
	RED_EC_HELP,
	RED_EC_INVALID_OPTION,
	RED_EC_EXTRA_OPERAND,
	RED_EC_INVALID_DBROOTID,
	RED_EC_GET_DBROOT1,
	RED_EC_CONNECT_FAIL,
	RED_EC_GET_DBROOT_EXCEPT,
	RED_EC_NETWORK_FAIL,
	RED_EC_PROTOCOL_ERROR,
	RED_EC_NO_ARC_NAME,
	RED_EC_ARC_NOT_EXIST,
	RED_EC_READ_ARC_FAIL,

	// return code for control and workers
	RED_EC_CNTL_SETUP_FAIL,
	RED_EC_MAKEPLAN_FAIL,
	RED_EC_EXECUTE_FAIL,
	RED_EC_UPDATE_STATE,
	RED_EC_USER_STOP,

	RED_EC_WKR_SETUP_FAIL,
	RED_EC_WKR_MSG_SHORT,
	RED_EC_FILE_LIST_FAIL,
	RED_EC_NO_TABLE_LOCK,
	RED_EC_IDB_HARD_FAIL,
	RED_EC_EXTENT_ERROR,
	RED_EC_PART_EXIST_ON_TARGET,
	RED_EC_OID_TO_FILENAME,
	RED_EC_OPEN_FILE_FAIL,
	RED_EC_FSEEK_FAIL,
	RED_EC_FREAD_FAIL,
	RED_EC_FWRITE_FAIL,
	RED_EC_SIZE_NACK,
	RED_EC_COPY_FILE_FAIL,
	RED_EC_UPDATE_DBRM_FAIL,
	RED_EC_BS_TOO_SHORT,
	RED_EC_FILE_SIZE_NOT_MATCH,
	RED_EC_UNKNOWN_DATA_MSG,
	RED_EC_UNKNOWN_JOB_MSG,

};


// redistribute message ID
const uint32_t RED_CNTL_START   = 1;
const uint32_t RED_CNTL_STATUS  = 2;
const uint32_t RED_CNTL_STOP    = 3;
const uint32_t RED_CNTL_CLEAR   = 4;
const uint32_t RED_CNTL_RESP    = 5;
const uint32_t RED_CNTL_VIEW    = 6;

const uint32_t RED_ACTN_REQUEST = 21;
const uint32_t RED_ACTN_STOP    = 22;
const uint32_t RED_ACTN_RESP    = 23;
const uint32_t RED_ACTN_REPORT  = 24;

const uint32_t RED_DATA_INIT    = 51;
const uint32_t RED_DATA_START   = 52;
const uint32_t RED_DATA_CONT    = 53;
const uint32_t RED_DATA_FINISH  = 54;
const uint32_t RED_DATA_COMMIT  = 55;
const uint32_t RED_DATA_ABORT   = 56;
const uint32_t RED_DATA_ACK     = 57;

// options for start message
const uint32_t RED_OPTN_REMOVE  = 0x00000001;



// file transfer chunk size
const size_t CHUNK_SIZE = 1024 * 1024;
const size_t PRE_ALLOC_SIZE = 4 * 1024;



// redistribute message header
struct RedistributeMsgHeader
{
	uint32_t  destination;
	uint32_t  source;
	uint32_t  sequenceNum;
	uint32_t  messageId;

	RedistributeMsgHeader(uint32_t d=0, uint32_t s=0, uint32_t n=0, uint32_t i=0) :
		destination(d), source(s), sequenceNum(n), messageId(i) {};
};


// redistribute data transfer control block
struct RedistributeDataControl
{
	uint64_t  oid;
	uint16_t  dbroot;
	uint32_t  partition;
	uint16_t  segment;
	uint64_t  size;

	RedistributeDataControl(uint64_t o=0, uint16_t d=0, uint32_t p=0, uint16_t s=0, uint32_t z=0) :
		oid(o), dbroot(d), partition(p), segment(s), size(z) {};
};


// extent entry
struct RedistributeExtentEntry
{
	int64_t  oid;
	int16_t  dbroot;
	int32_t  partition;
	int16_t  segment;
	int64_t  lbid;
	int64_t  range;
    RedistributeExtentEntry() :
		oid(0), dbroot(0), partition(0), segment(0), lbid(0), range(0) {}
};


// RedistributePlanEntry
struct RedistributePlanEntry
{
	int64_t  table;
	int32_t  source;
	int32_t  partition;
	int32_t  destination;
	int32_t  status;
	time_t   starttime;
	time_t   endtime;

	RedistributePlanEntry() :
		table(0), source(0), partition(0), destination(0), status(0), starttime(0), endtime(0) {}
};


// RedistributeInfo
struct RedistributeInfo
{
	uint64_t version;
	uint64_t state;
	uint64_t planned;
	uint64_t success;
	uint64_t skipped;
	uint64_t failed;
	time_t   startTime;
	time_t   endTime;

	RedistributeInfo() :
		version(RED_VERSION_NUM), state(RED_STATE_UNDEF),
		planned(0), success(0), skipped(0), failed(0),
		startTime(0), endTime(0) {}
};


}  // namespace


#endif  // WE_REDISTRIBUTEDEF_H

// vim:ts=4 sw=4: