mariadb-columnstore-engine/utils/querytele/queryteleclient.cpp

/* 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. */

#include <unistd.h>
#include <stdint.h>
#include <string>
using namespace std;

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
namespace bu=boost::uuids;

#include "queryteleserverparms.h"
#include "querytele_types.h"
#include "QueryTeleService.h"
#include "queryteleprotoimpl.h"
#include "telestats.h"

#include "queryteleclient.h"

namespace
{
using namespace querytele;

#define QT_ASSIGN_(x) out. __set_ ## x (qts. x)
QueryTele qts2qt(const QueryTeleStats& qts)
{
	QueryTele out;

	out.query_uuid = bu::to_string(qts.query_uuid);
	switch (qts.msg_type)
	{
	case QueryTeleStats::QT_SUMMARY:
		out.msg_type = QTType::QT_SUMMARY;
		break;
	case QueryTeleStats::QT_PROGRESS:
		out.msg_type = QTType::QT_PROGRESS;
		break;
	case QueryTeleStats::QT_START:
		out.msg_type = QTType::QT_START;
		break;
	default:
		out.msg_type = QTType::QT_INVALID;
		break;
	}
	QT_ASSIGN_(max_mem_pct);
	QT_ASSIGN_(num_files);
	QT_ASSIGN_(phy_io);
	QT_ASSIGN_(cache_io);
	QT_ASSIGN_(msg_rcv_cnt);
	QT_ASSIGN_(cp_blocks_skipped);
	QT_ASSIGN_(msg_bytes_in);
	QT_ASSIGN_(msg_bytes_out);
	QT_ASSIGN_(rows);
	QT_ASSIGN_(start_time);
	QT_ASSIGN_(end_time);
	QT_ASSIGN_(error_no);
	QT_ASSIGN_(blocks_changed);
	QT_ASSIGN_(session_id);
	QT_ASSIGN_(query_type);
	QT_ASSIGN_(query);
	QT_ASSIGN_(user);
	QT_ASSIGN_(host);
	QT_ASSIGN_(priority);
	QT_ASSIGN_(priority_level);
	QT_ASSIGN_(system_name);
	QT_ASSIGN_(module_name);
	QT_ASSIGN_(local_query);
	QT_ASSIGN_(schema_name);

	return out;
}
#undef QT_ASSIGN_

#define QT_ASSIGN_(x) out. __set_ ## x (sts. x)
StepTele sts2st(const StepTeleStats& sts)
{
	StepTele out;

	out.query_uuid = bu::to_string(sts.query_uuid);
	switch (sts.msg_type)
	{
	case StepTeleStats::ST_SUMMARY:
		out.msg_type = STType::ST_SUMMARY;
		break;
	case StepTeleStats::ST_PROGRESS:
		out.msg_type = STType::ST_PROGRESS;
		break;
	case StepTeleStats::ST_START:
		out.msg_type = STType::ST_START;
		break;
	default:
		out.msg_type = STType::ST_INVALID;
		break;
	}
	out.step_uuid = bu::to_string(sts.step_uuid);
	QT_ASSIGN_(phy_io);
	QT_ASSIGN_(cache_io);
	QT_ASSIGN_(msg_rcv_cnt);
	QT_ASSIGN_(cp_blocks_skipped);
	QT_ASSIGN_(msg_bytes_in);
	QT_ASSIGN_(msg_bytes_out);
	QT_ASSIGN_(rows);
	QT_ASSIGN_(start_time);
	QT_ASSIGN_(end_time);
	QT_ASSIGN_(total_units_of_work);
	QT_ASSIGN_(units_of_work_completed);

	return out;
}
#undef QT_ASSIGN_

#define QT_ASSIGN_(x) out. __set_ ## x (its. x)
ImportTele its2it(const ImportTeleStats& its)
{
	ImportTele out;

	out.job_uuid = bu::to_string(its.job_uuid);
	out.import_uuid = bu::to_string(its.import_uuid);
	switch (its.msg_type)
	{
	case ImportTeleStats::IT_SUMMARY:
		out.msg_type = ITType::IT_SUMMARY;
		break;
	case ImportTeleStats::IT_PROGRESS:
		out.msg_type = ITType::IT_PROGRESS;
		break;
	case ImportTeleStats::IT_START:
		out.msg_type = ITType::IT_START;
		break;
	case ImportTeleStats::IT_TERM:
		out.msg_type = ITType::IT_TERM;
		break;
	default:
		out.msg_type = ITType::IT_INVALID;
		break;
	}
	QT_ASSIGN_(start_time);
	QT_ASSIGN_(end_time);
	QT_ASSIGN_(table_list);
	QT_ASSIGN_(rows_so_far);
	QT_ASSIGN_(system_name);
	QT_ASSIGN_(module_name);
	QT_ASSIGN_(schema_name);

	return out;
}
#undef QT_ASSIGN_

}

namespace querytele
{

QueryTeleClient::QueryTeleClient(const QueryTeleServerParms& sp) :
	fProtoImpl(0),
	fServerParms(sp)
{
	if (fServerParms.host.empty() || fServerParms.port == 0) return;
	fProtoImpl = new QueryTeleProtoImpl(fServerParms);
}

QueryTeleClient::~QueryTeleClient()
{
	delete fProtoImpl;
}

QueryTeleClient::QueryTeleClient(const QueryTeleClient& rhs) :
	fProtoImpl(0)
{
	fServerParms = rhs.fServerParms;
	if (rhs.fProtoImpl)
	{
		fProtoImpl = new QueryTeleProtoImpl(*rhs.fProtoImpl);
	}
}

QueryTeleClient& QueryTeleClient::operator=(const QueryTeleClient& rhs)
{
	if (&rhs != this)
	{
		fProtoImpl = 0;
		fServerParms = rhs.fServerParms;
		if (rhs.fProtoImpl)
		{
			fProtoImpl = new QueryTeleProtoImpl(*rhs.fProtoImpl);
		}
	}
	return *this;
}

void QueryTeleClient::serverParms(const QueryTeleServerParms& sp)
{
	fServerParms = sp;
	delete fProtoImpl;
	fProtoImpl = 0;
	if (fServerParms.host.empty() || fServerParms.port == 0) return;
	fProtoImpl = new QueryTeleProtoImpl(fServerParms);
}

void QueryTeleClient::postQueryTele(const QueryTeleStats& qts)
{
	if (!fProtoImpl) return;
	QueryTele qtdata = qts2qt(qts);
	fProtoImpl->enqQueryTele(qtdata);
}

#define QT_STYPE_CASE_(x) case StepTeleStats:: x: {stdata.step_type = StepType:: x; break;}
void QueryTeleClient::postStepTele(const StepTeleStats& sts)
{
	if (!fProtoImpl) return;
	StepTele stdata = sts2st(sts);
	switch (fStepParms.stepType)
	{
	QT_STYPE_CASE_(T_HJS);
	QT_STYPE_CASE_(T_DSS);
	QT_STYPE_CASE_(T_CES);
	QT_STYPE_CASE_(T_SQS);
	QT_STYPE_CASE_(T_TAS);
	QT_STYPE_CASE_(T_TNS);
	QT_STYPE_CASE_(T_BPS);
	QT_STYPE_CASE_(T_TCS);
	QT_STYPE_CASE_(T_HVS);
	QT_STYPE_CASE_(T_WFS);
	QT_STYPE_CASE_(T_SAS);
	QT_STYPE_CASE_(T_TUN);
	default:
		stdata.step_type = StepType::T_INVALID;
		break;
	}
	fProtoImpl->enqStepTele(stdata);
}
#undef QT_STYPE_CASE_

void QueryTeleClient::postImportTele(const ImportTeleStats& its)
{
	if (!fProtoImpl) return;
	ImportTele itdata = its2it(its);
	fProtoImpl->enqImportTele(itdata);
}

void QueryTeleClient::waitForQueues()
{
	if (fProtoImpl)
		fProtoImpl->waitForQueues();
}

}