option.c

/*-------------------------------------------------------------------------
 *
 * option.c
 * 		Foreign-data wrapper for remote MongoDB servers
 *
 * Portions Copyright (c) 2012-2014, PostgreSQL Global Development Group
 *
 * Portions Copyright (c) 2004-2014, EnterpriseDB Corporation.
 *
 * Portions Copyright (c) 2012–2014 Citus Data, Inc.
 *
 * IDENTIFICATION
 * 		option.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"
#include "mongo_wrapper.h"
#include "mongo_fdw.h"

#include "access/reloptions.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "commands/explain.h"
#include "commands/vacuum.h"
#include "foreign/fdwapi.h"
#include "foreign/foreign.h"
#include "nodes/makefuncs.h"
#include "optimizer/cost.h"
#include "optimizer/pathnode.h"
#include "optimizer/plancat.h"
#include "optimizer/planmain.h"
#include "optimizer/restrictinfo.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/hsearch.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/memutils.h"
#include "miscadmin.h"

static char * mongo_get_option_value(Oid foreignTableId, const char *optionName);

/*
 * Validate the generic options given to a FOREIGN DATA WRAPPER, SERVER,
 * USER MAPPING or FOREIGN TABLE that uses postgres_fdw.
 *
 * Raise an ERROR if the option or its value is considered invalid.
 */
extern Datum mongo_fdw_validator(PG_FUNCTION_ARGS);

PG_FUNCTION_INFO_V1(mongo_fdw_validator);

/*
 * mongo_fdw_validator validates options given to one of the following commands:
 * foreign data wrapper, server, user mapping, or foreign table. This function
 * errors out if the given option name or its value is considered invalid.
 */
Datum
mongo_fdw_validator(PG_FUNCTION_ARGS)
{
	Datum    optionArray = PG_GETARG_DATUM(0);
	Oid      optionContextId = PG_GETARG_OID(1);
	List     *optionList = untransformRelOptions(optionArray);
	ListCell *optionCell = NULL;

	foreach(optionCell, optionList)
	{
		DefElem *optionDef = (DefElem *) lfirst(optionCell);
		char *optionName = optionDef->defname;
		bool optionValid = false;

		int32 optionIndex = 0;
		for (optionIndex = 0; optionIndex < ValidOptionCount; optionIndex++)
		{
			const MongoValidOption *validOption = &(ValidOptionArray[optionIndex]);

			if ((optionContextId == validOption->optionContextId) &&
				(strncmp(optionName, validOption->optionName, NAMEDATALEN) == 0))
			{
				optionValid = true;
				break;
			}
		}

		/* if invalid option, display an informative error message */
		if (!optionValid)
		{
			StringInfo optionNamesString = mongo_option_names_string(optionContextId);

			ereport(ERROR, (errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
							errmsg("invalid option \"%s\"", optionName),
							errhint("Valid options in this context are: %s",
									optionNamesString->data)));
		}

		/* if port option is given, error out if its value isn't an integer */
		if (strncmp(optionName, OPTION_NAME_PORT, NAMEDATALEN) == 0)
		{
			char *optionValue = defGetString(optionDef);
			int32 portNumber = pg_atoi(optionValue, sizeof(int32), 0);
			(void) portNumber;
		}
	}
	PG_RETURN_VOID();
}

/*
 * mongo_option_names_string finds all options that are valid for the current context,
 * and concatenates these option names in a comma separated string.
 */
StringInfo
mongo_option_names_string(Oid currentContextId)
{
	StringInfo  optionNamesString = makeStringInfo();
	bool        firstOptionPrinted = false;

	int32 optionIndex = 0;
	for (optionIndex = 0; optionIndex < ValidOptionCount; optionIndex++)
	{
		const MongoValidOption *validOption = &(ValidOptionArray[optionIndex]);

		/* if option belongs to current context, append option name */
		if (currentContextId == validOption->optionContextId)
		{
			if (firstOptionPrinted)
				appendStringInfoString(optionNamesString, ", ");

			appendStringInfoString(optionNamesString, validOption->optionName);
			firstOptionPrinted = true;
		}
	}
	return optionNamesString;
}


/*
 * mongo_get_options returns the option values to be used when connecting to and
 * querying MongoDB. To resolve these values, the function checks the foreign
 * table's options, and if not present, falls back to default values.
 */
MongoFdwOptions *
mongo_get_options(Oid foreignTableId)
{
	MongoFdwOptions         *options = NULL;
	char                    *addressName = NULL;
	char                    *portName = NULL;
	int32                   portNumber = 0;
	char                    *svr_database = NULL;
	char                    *collectionName = NULL;
	char                    *svr_username= NULL;
	char                    *svr_password= NULL;
#ifdef META_DRIVER
	char                    *readPreference = NULL;
	char                    *authenticationDatabase = NULL;
	char                    *replicaSet = NULL;
 	bool  									ssl = false;
	char 										*pem_file = NULL;
 	char 										*pem_pwd = NULL;
 	char 										*ca_file = NULL;
 	char 										*ca_dir = NULL;
 	char 										*crl_file = NULL;
 	bool 										weak_cert_validation = false;

	readPreference = mongo_get_option_value(foreignTableId, OPTION_NAME_READ_PREFERENCE);
	authenticationDatabase = mongo_get_option_value(foreignTableId, OPTION_NAME_AUTHENTICATION_DATABASE);
	replicaSet = mongo_get_option_value(foreignTableId, OPTION_NAME_REPLICA_SET);
	ssl = mongo_get_option_value(foreignTableId, OPTION_NAME_SSL);
	pem_file = mongo_get_option_value(foreignTableId, OPTION_NAME_PEM_FILE);
	pem_pwd = mongo_get_option_value(foreignTableId, OPTION_NAME_PEM_PWD);
	ca_file = mongo_get_option_value(foreignTableId, OPTION_NAME_CA_FILE);
	ca_dir = mongo_get_option_value(foreignTableId, OPTION_NAME_CA_DIR);
	crl_file = mongo_get_option_value(foreignTableId, OPTION_NAME_CRL_FILE);
	weak_cert_validation = mongo_get_option_value(foreignTableId, OPTION_NAME_WEAK_CERT);
#endif
	char										*forceServerIdName = NULL;
	bool                    					force_server_id = DEFAULT_FORCE_SERVER_ID;

	forceServerIdName = mongo_get_option_value(foreignTableId, OPTION_NAME_FORCESERVERID);
	if (forceServerIdName != NULL) {
	    if (strcmp(forceServerIdName, "false") == 0)
	        force_server_id = false;
	}

	addressName = mongo_get_option_value(foreignTableId, OPTION_NAME_ADDRESS);
	if (addressName == NULL)
		addressName = pstrdup(DEFAULT_IP_ADDRESS);

	portName = mongo_get_option_value(foreignTableId, OPTION_NAME_PORT);
	if (portName == NULL)
		portNumber = DEFAULT_PORT_NUMBER;
	else
		portNumber = pg_atoi(portName, sizeof(int32), 0);

	svr_database = mongo_get_option_value(foreignTableId, OPTION_NAME_DATABASE);
	if (svr_database == NULL)
		svr_database = pstrdup(DEFAULT_DATABASE_NAME);

	collectionName = mongo_get_option_value(foreignTableId, OPTION_NAME_COLLECTION);
	if (collectionName == NULL)
		collectionName = get_rel_name(foreignTableId);

	svr_username = mongo_get_option_value(foreignTableId, OPTION_NAME_USERNAME);
	svr_password = mongo_get_option_value(foreignTableId, OPTION_NAME_PASSWORD);

	options = (MongoFdwOptions *) palloc0(sizeof(MongoFdwOptions));

	options->svr_address = addressName;
	options->svr_port = portNumber;
	options->svr_database = svr_database;
	options->collectionName = collectionName;
	options->svr_username = svr_username;
	options->svr_password = svr_password;
	options->force_server_id = force_server_id;
#ifdef META_DRIVER
	options->readPreference = readPreference;
	options->authenticationDatabase = authenticationDatabase;
	options->replicaSet = replicaSet;
	options->ssl = ssl;
	options->pem_file = pem_file;
	options->pem_pwd = pem_pwd;
	options->ca_file = ca_file;
	options->ca_dir = ca_dir;
	options->crl_file = crl_file;
	options->weak_cert_validation = weak_cert_validation;
#endif

	return options;
}

void
mongo_free_options(MongoFdwOptions *options)
{
	if (options)
	{
		pfree(options->svr_address);
		pfree(options->svr_database);
		pfree(options);
	}
}

/*
 * mongo_get_option_value walks over foreign table and foreign server options, and
 * looks for the option with the given name. If found, the function returns the
 * option's value.
 */
static char *
mongo_get_option_value(Oid foreignTableId, const char *optionName)
{
	ForeignTable           *foreignTable = NULL;
	ForeignServer          *foreignServer = NULL;
	List                   *optionList = NIL;
	ListCell               *optionCell = NULL;
	UserMapping            *mapping= NULL;
	char                   *optionValue = NULL;

	foreignTable = GetForeignTable(foreignTableId);
	foreignServer = GetForeignServer(foreignTable->serverid);
	mapping = GetUserMapping(GetUserId(), foreignTable->serverid);

	optionList = list_concat(optionList, foreignTable->options);
	optionList = list_concat(optionList, foreignServer->options);
	optionList = list_concat(optionList, mapping->options);

	foreach(optionCell, optionList)
	{
		DefElem *optionDef = (DefElem *) lfirst(optionCell);
		char *optionDefName = optionDef->defname;

		if (strncmp(optionDefName, optionName, NAMEDATALEN) == 0)
		{
			optionValue = defGetString(optionDef);
			break;
		}
	}
	return optionValue;
}