hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove qc_pp

Browse Source 
There will not be a plugin process.
This commit is contained in:
Johan Wikman
2016-03-07 12:19:51 +02:00
parent 60714135c4
commit e8c2b27c27
4 changed files with 0 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
query_classifier/CMakeLists.txt
View File

@ -1,5 +1,4 @@
add_subdirectory(qc_mysqlembedded) add_subdirectory(qc_mysqlembedded)
add_subdirectory(qc_pp)
if(BUILD_TESTS) if(BUILD_TESTS)
add_subdirectory(test) add_subdirectory(test)

7
query_classifier/qc_pp/CMakeLists.txt
View File

@ -1,7 +0,0 @@
add_library(qc_pp SHARED qc_pp.c)
target_link_libraries(qc_pp maxscale-common)
set_target_properties(qc_pp PROPERTIES LINK_FLAGS -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/qc_pp.map)
set_target_properties(qc_pp PROPERTIES LINK_FLAGS -Wl,-z,defs)
install(TARGETS qc_pp COMPONENT lib DESTINATION ${MAXSCALE_LIBDIR})

363
query_classifier/qc_pp/qc_pp.c
View File

@ -1,363 +0,0 @@
/**
* @section LICENCE
*
* This file is distributed as part of the MariaDB Corporation MaxScale. It 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.
*
* 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.
*
* Copyright MariaDB Corporation Ab
*
* @file
*
*/
#include <elf.h>
#include <log_manager.h>
#include <modules.h>
#include <query_classifier.h>
#include <gwdirs.h>
//#define QC_TRACE_ENABLED
#undef QC_TRACE_ENABLED
#if defined(QC_TRACE_ENABLED)
#define QC_TRACE() MXS_NOTICE(__func__)
#else
#define QC_TRACE()
#endif
static const char QC_MYSQLEMBEDDED[] = "qc_mysqlembedded"; // The qc plugin we'll temporarily use.
static const char MAXPP[] = "maxpp"; // The name of the plugin process executable.
static struct pp_self
{
QUERY_CLASSIFIER* classifier; // The classifier.
char classifier_name[PATH_MAX]; // The name of the classifier.
pid_t pp_pid; // The pid of the plugin process.
char pp_path[PATH_MAX]; // The path of the plugin process.
} *self = 0;
static QUERY_CLASSIFIER* load_and_init_classifier(const char* name)
{
QUERY_CLASSIFIER* classifier = NULL;
void* module = load_module(name, MODULE_QUERY_CLASSIFIER);
if (module)
{
classifier = (QUERY_CLASSIFIER*) module;
bool success = classifier->qc_init();
if (success)
{
MXS_NOTICE("%s loaded and initialized.", name);
}
else
{
MXS_ERROR("Could not initialize %s.", name);
unload_module(name);
classifier = NULL;
}
}
else
{
MXS_ERROR("Could not load %s.", name);
}
return classifier;
}
static void end_and_unload_classifier(QUERY_CLASSIFIER* classifier, const char* name)
{
classifier->qc_end();
unload_module(name);
}
static bool resolve_pp_path(char* path, int size)
{
bool success = false;
const char* exe_path = (const char*) get_execdir();
size_t len = strlen(exe_path);
if (len < size)
{
/** get_execdir will always return a cleaned up version of
* the executable path */
strcpy(path, exe_path);
int required_size = len + sizeof(MAXPP) + 1;
if (required_size <= size)
{
strcat(path, MAXPP);
MXS_NOTICE("Path of plugin process executable: %s", path);
success = true;
}
else
{
MXS_ERROR("The full path of the plugin process executable does "
"not fit into a buffer of %d bytes. ", size);
}
}
else
{
MXS_ERROR("The full path of the current executable does not fit in a "
"buffer of %d bytes.", size);
}
return success;
}
static bool is_executable(const char* path)
{
return access(path, X_OK) == 0;
}
static bool qc_pp_init(void)
{
QC_TRACE();
ss_dassert(!self);
bool success = false;
self = malloc(sizeof(*self));
if (self)
{
memset(self, 0, sizeof(*self));
const char* classifier_name = QC_MYSQLEMBEDDED;
QUERY_CLASSIFIER* classifier = load_and_init_classifier(classifier_name);
if (classifier)
{
char pp_path[PATH_MAX];
if (resolve_pp_path(pp_path, sizeof(pp_path)))
{
if (is_executable(pp_path))
{
self->classifier = classifier;
strcpy(self->classifier_name, classifier_name);
strcpy(self->pp_path, pp_path);
success = true;
}
else
{
MXS_ERROR("%s does not exist or is not an executable.", pp_path);
}
}
else
{
MXS_ERROR("Could not resolve the path of the plugin process executable. "
"Plugin process will not be launched.");
}
if (!success)
{
end_and_unload_classifier(classifier, classifier_name);
}
}
if (!success)
{
free(self);
self = NULL;
}
}
else
{
MXS_ERROR("Out of memory.");
}
return success;
}
static void qc_pp_end(void)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
end_and_unload_classifier(self->classifier, self->classifier_name);
free(self);
self = NULL;
}
static bool qc_pp_thread_init(void)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_thread_init();
}
static void qc_pp_thread_end(void)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_thread_end();
}
static qc_query_type_t qc_pp_get_type(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_type(query);
}
static qc_query_op_t qc_pp_get_operation(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_operation(query);
}
static char* qc_pp_get_created_table_name(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_created_table_name(query);
}
static bool qc_pp_is_drop_table_query(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_is_drop_table_query(query);
}
static bool qc_pp_is_real_query(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_is_real_query(query);
}
static char** qc_pp_get_table_names(GWBUF* query, int* tblsize, bool fullnames)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_table_names(query, tblsize, fullnames);
}
static char* qc_pp_get_canonical(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_canonical(query);
}
static bool qc_pp_query_has_clause(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_query_has_clause(query);
}
static char* qc_pp_get_qtype_str(qc_query_type_t qtype)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_qtype_str(qtype);
}
static char* qc_pp_get_affected_fields(GWBUF* query)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_affected_fields(query);
}
static char** qc_pp_get_database_names(GWBUF* query, int* sizep)
{
QC_TRACE();
ss_dassert(self);
ss_dassert(self->classifier);
return self->classifier->qc_get_database_names(query, sizep);
}
/**
* EXPORTS
*/
static char version_string[] = "V1.0.0";
static QUERY_CLASSIFIER qc =
{
qc_pp_init,
qc_pp_end,
qc_pp_thread_init,
qc_pp_thread_end,
qc_pp_get_type,
qc_pp_get_operation,
qc_pp_get_created_table_name,
qc_pp_is_drop_table_query,
qc_pp_is_real_query,
qc_pp_get_table_names,
qc_pp_get_canonical,
qc_pp_query_has_clause,
qc_pp_get_qtype_str,
qc_pp_get_affected_fields,
qc_pp_get_database_names,
};
MODULE_INFO info =
{
MODULE_API_QUERY_CLASSIFIER,
MODULE_IN_DEVELOPMENT,
QUERY_CLASSIFIER_VERSION,
"Query classifier using external process.",
};
char* version()
{
return version_string;
}
void ModuleInit()
{
}
QUERY_CLASSIFIER* GetModuleObject()
{
return &qc;
}

9
query_classifier/qc_pp/qc_pp.map
View File

@ -1,9 +0,0 @@
{
global:
info;
version;
GetModuleObject;
ModuleInit;
local:
*;
};