obitools3/src/obidms.c

/********************************************************************
 * OBIDMS functions                                                 *
 ********************************************************************/

/**
 * @file obidms.c
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 * @date 23 May 2015
 * @brief OBIDMS functions.
 */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <dirent.h>

#include "obidms.h"
#include "obierrno.h"
#include "obidebug.h"
#include "obidmscolumn.h"
#include "private_at_functions.h"
#include "obilittlebigman.h"


#define DEBUG_LEVEL 0	// TODO has to be defined somewhere else (cython compil flag?)


/**************************************************************************
 *
 * D E C L A R A T I O N   O F   T H E   P R I V A T E   F U N C T I O N S
 *
 **************************************************************************/


/**
 * Internal function building the OBIDMS directory name from an OBIDMS name.
 *
 * The function builds the directory name corresponding to an OBIDMS.
 * It also checks that the name is not too long.
 *
 * @warning The returned pointer has to be freed by the caller.
 *
 * @param dms_name The name of the OBIDMS.
 *
 * @returns A pointer to the directory name.
 * @retval NULL if an error occurred.
 *
 * @since May 2015
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 */
static char* build_directory_name(const char* dms_name);


/**
 * Internal function building the informations file name from an OBIDMS name.
 *
 * The function builds the file name for the informations file of an OBIDMS.
 *
 * @warning The returned pointer has to be freed by the caller.
 *
 * @param dms_name The name of the OBIDMS.
 *
 * @returns A pointer to the file name.
 * @retval NULL if an error occurred.
 *
 * @since November 2015
 * @author Celine Mercier (celine.mercier@metabarcoding.org)
 */
static char* build_infos_file_name(const char* dms_name);


/**
 * Internal function creating the file containing basic informations on the OBIDMS.
 *
 * This file contains:
 * 		- The endianness of the platform
 *
 * @warning The returned pointer has to be freed by the caller.
 *
 * @param dms_file_descriptor The file descriptor for the OBIDMS directory.
 * @param dms_name The name of the OBIDMS.
 *
 * @retval 0 if the operation was successfully completed.
 * @retval -1 if an error occurred.
 *
 * @since November 2015
 * @author Celine Mercier (celine.mercier@metabarcoding.org)
 */
int create_dms_infos_file(int dms_file_descriptor, const char* dms_name);


/************************************************************************
 *
 * D E F I N I T I O N   O F   T H E   P R I V A T E   F U N C T I O N S
 *
 ************************************************************************/

static char* build_directory_name(const char* dms_name)
{
	char* directory_name;

	// Build the database directory name
	if (asprintf(&directory_name, "%s.obidms", dms_name) < 0)
	{
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		obidebug(1, "\nProblem building an OBIDMS directory name");
		return NULL;
	}

	// Test if the database name is not too long
	if (strlen(directory_name) >= OBIDMS_MAX_NAME)
	{
		obi_set_errno(OBIDMS_LONG_NAME_ERROR);
		obidebug(1, "\nProblem building an OBIDMS directory name");
		free(directory_name);
		return NULL;
	}

	return directory_name;
}


static char* build_infos_file_name(const char* dms_name)
{
	char* file_name;

	// Build file name
	if (asprintf(&file_name, "%s_infos", dms_name) < 0)
	{
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		obidebug(1, "\nProblem building an informations file name");
		return NULL;
	}

	return file_name;
}


int create_dms_infos_file(int dms_file_descriptor, const char* dms_name)
{
	char* 	file_name;
	int 	infos_file_descriptor;
	off_t 	file_size;
	bool	little_endian;

	file_size = sizeof(bool);

	// Create file name
	file_name = build_infos_file_name(dms_name);
	if (file_name == NULL)
		return -1;

    // Create file
	infos_file_descriptor = openat(dms_file_descriptor, file_name, O_RDWR | O_CREAT | O_EXCL, 0777);
	if (infos_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError creating an informations file");
		free(file_name);
		return -1;
	}

	free(file_name);

	// Truncate the infos file to the right size
	if (ftruncate(infos_file_descriptor, file_size) < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError truncating an informations file");
		close(infos_file_descriptor);
		return -1;
	}

	// Write endianness
	little_endian = obi_is_little_endian();
	if (write(infos_file_descriptor, &little_endian, sizeof(bool)) < ((ssize_t) sizeof(bool)))
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError writing the endianness in an informations file");
		close(infos_file_descriptor);
		return -1;
	}

	// Close file
	close(infos_file_descriptor);

	return 0;
}


/**********************************************************************
 *
 * D E F I N I T I O N   O F   T H E   P U B L I C   F U N C T I O N S
 *
 **********************************************************************/

int obi_dms_exists(const char* dms_name)
{
    struct stat buffer;
	char *directory_name;
    int check_dir;

	// Build and check the directory name
    directory_name = build_directory_name(dms_name);
	if (directory_name == NULL)
		return -1;

	check_dir = stat(directory_name, &buffer);

	free(directory_name);

    if (check_dir == 0)
        return 1;
    else
    	return 0;
}


OBIDMS_p obi_create_dms(const char* dms_name)
{
	char* directory_name;
	DIR*  dms_dir;
	int   dms_file_descriptor;

	// Build and check the directory name
	directory_name = build_directory_name(dms_name);
	if (directory_name == NULL)
		return NULL;

	// Try to create the directory
	if (mkdir(directory_name, 00777) < 0)
	{
		if (errno == EEXIST)
		{
			obi_set_errno(OBIDMS_EXIST_ERROR);
			obidebug(1, "\nAn OBIDMS directory with the same name already exists in this directory.");
		}
		else
			obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nProblem creating an OBIDMS directory");
		free(directory_name);
		return NULL;
	}

	// Get file descriptor of DMS directory to create the arrays directory
	dms_dir = opendir(directory_name);
	if (dms_dir == NULL)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nProblem opening a newly created OBIDMS directory");
		free(directory_name);
		return NULL;
	}

	free(directory_name);

	dms_file_descriptor = dirfd(dms_dir);
	if (dms_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nProblem getting the file descriptor of a newly created OBIDMS directory");
		return NULL;
	}

	// Create the arrays directory
	if (mkdirat(dms_file_descriptor, ARRAYS_DIR_NAME, 00777) < 0)
	{
		obi_set_errno(OBI_ARRAY_ERROR);
		obidebug(1, "\nProblem creating an arrays directory");
		return NULL;
	}

	// Create the informations file
	if (create_dms_infos_file(dms_file_descriptor, dms_name) < 0)
		return NULL;

	return obi_open_dms(dms_name);
}


OBIDMS_p obi_open_dms(const char* dms_name)
{
	OBIDMS_p	dms;
	char*	 	directory_name;
	char* 		infos_file_name;
	int			infos_file_descriptor;
	bool		little_endian_dms;
	bool 		little_endian_platform;

	dms = NULL;

	// Allocate the data structure
	dms = (OBIDMS_p) malloc(sizeof(OBIDMS_t));
	if (dms == NULL)
	{
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		obidebug(1, "\nError allocating the memory for the OBIDMS structure");
		return NULL;
	}

	// Build and check the directory name
	directory_name = build_directory_name(dms_name);
	if (directory_name == NULL)
	{
		free(dms);
		return NULL;
	}

	strncpy(dms->directory_name, directory_name, OBIDMS_MAX_NAME);
	free(directory_name);

	// Try to open the directory
	dms->directory = opendir(dms->directory_name);
	if (dms->directory == NULL)
	{
		switch (errno)
		{
			case ENOENT:
				obi_set_errno(OBIDMS_NOT_EXIST_ERROR);
				break;

			case EACCES:
				obi_set_errno(OBIDMS_ACCESS_ERROR);
				break;

			case ENOMEM:
				obi_set_errno(OBIDMS_MEMORY_ERROR);
				break;

			default:
				obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		}
		obidebug(1, "\nCan't open OBIDMS directory");
		free(dms);
		return NULL;
	}

	// Get and store file descriptor of DMS directory to open the informations file
	dms->dir_fd = dirfd(dms->directory);
	if (dms->dir_fd < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError getting the file descriptor for a newly created OBIDMS directory");
		closedir(dms->directory);
		free(dms);
		return NULL;
	}

	// Open informations file to check endianness
	infos_file_name = build_infos_file_name(dms_name);
	infos_file_descriptor = openat(dms->dir_fd, infos_file_name, O_RDONLY, 0777);
	if (infos_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError opening an informations file");
		closedir(dms->directory);
		free(dms);
		return NULL;
	}

	free(infos_file_name);

	// Check endianness of the platform and DMS
	little_endian_platform = obi_is_little_endian();
	if (read(infos_file_descriptor, &little_endian_dms, sizeof(bool)) < ((ssize_t) sizeof(bool)))
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError reading the endianness in an informations file");
		close(infos_file_descriptor);
		closedir(dms->directory);
		free(dms);
		return NULL;
	}
	if (little_endian_platform != little_endian_dms)
	{
		obi_set_errno(OBIDMS_BAD_ENDIAN_ERROR);
		obidebug(1, "\nError: The DMS and the platform have different endianness");
		close(infos_file_descriptor);
		closedir(dms->directory);
		free(dms);
		return NULL;
	}

	close(infos_file_descriptor);

	// Open the arrays directory
	dms->array_directory = private_opendirat(dms->dir_fd, ARRAYS_DIR_NAME);
	if (dms->array_directory == NULL)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError opening the arrays directory");
		closedir(dms->directory);
		free(dms);
		return NULL;
	}

	// Store the array directory's file descriptor
	dms->array_dir_fd = dirfd(dms->array_directory);
	if (dms->array_dir_fd < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		obidebug(1, "\nError getting the file descriptor of the arrays directory");
		closedir(dms->array_directory);
		closedir(dms->directory);
		free(dms);
		return NULL;
	}

	return dms;
}


OBIDMS_p obi_dms(const char* dms_name)
{
	int exists;

	exists = obi_dms_exists(dms_name);

	switch (exists)
	{
		case 0:
			return obi_create_dms(dms_name);
		case 1:
			return obi_open_dms(dms_name);
	};

	obidebug(1, "\nError checking if an OBIDMS directory exists");
	return NULL;
}


int obi_close_dms(OBIDMS_p dms)
{
	if (dms != NULL)
	{
		if (closedir(dms->directory) < 0)
		{
			obi_set_errno(OBIDMS_MEMORY_ERROR);
			obidebug(1, "\nError closing an OBIDMS directory");
			free(dms);
			return -1;
		}
		if (closedir(dms->array_directory) < 0)
		{
			obi_set_errno(OBI_ARRAY_ERROR);
			obidebug(1, "\nError closing an array directory");
			free(dms);
			return -1;
		}
		free(dms);
	}

	return 0;
}