obitools3/src/obidmscolumn.c

/****************************************************************************
 * OBIDMS_column functions                                                   *
 ****************************************************************************/

/**
 * @file OBIDMS_column.h
 * @author Celine Mercier
 * @date 22 May 2015
 * @brief Functions for the shared elements of all the OBIColumn structures.
 */


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>	/* mmap() is defined in this header */

#include "obidmscolumn.h"
#include "obidms.h"
#include "obitypes.h"
#include "obierrno.h"
#include "obilittlebigman.h"
#include "private_openat.h"

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


/**
 * @brief Internal function building the file name for a column.
 *
 * The function builds the file name corresponding to a column of an OBIDMS.
 *
 * @warning The returned pointer has to be freed by the caller.
 *
 * @param column_name the name of the OBIDMS column.
 *
 * @return a pointer to the column file name
 * @retvalue NULL if an error occurs
 *
 * ###Error values
 * 		- OBIDMS_MEMORY_ERROR    : something wrong occured during memory allocation.
 *
 * @since May 2015
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 */
static char *build_column_file_name(const char *column_name, obiversion_t version_number);


/**
 * @brief Internal function building the file name for a column version file.
 *
 * The column version file indicates the latest version number for a column.
 * This function returns the name of the file storing this information.
 *
 * @warning The returned pointer has to be freed by the caller.
 *
 * @param column_name the name of the OBIDMS column.
 *
 * @return a pointer to the version file name
 * @retvalue NULL if an error occurs
 *
 * ###Error values
 * 		- OBIDMS_MEMORY_ERROR    : something wrong occurs during memory allocation.
 *
 * @since May 2015
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 */
static char *build_version_file_name(const char *column_name);


/**
 * @brief Internal function returning a new column version number
 *        in the `dms` database
 *
 * @param dms a pointer as returned by obi_create_dms() or obi_open_dms()
 * @param column_name the name of the column
 * @param block is the call is blocking or not
 *                 - `true` the call is blocking
 *                 - `false` the call is not blocking
 *
 * @return the bigger version number used for this column
 * @retvalue -1 if the column does not exist
 *
 * @since May 2015
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 */
static obiversion_t obi_get_new_version_number(OBIDMS_p dms, char *column_name, bool block);


/**
 * @brief Internal function creating a new column version file
 *        in the `dms` database
 *
 * The new file is initialized with the minimum version number `0`.
 *
 * @param dms a pointer as returned by obi_create_dms() or obi_open_dms()
 * @param column_name the name of the column
 *
 * @return the next usable version number for this column : `0`
 * @retvalue -1 if the column does not exist
 *
 * @since May 2015
 * @author Eric Coissac (eric.coissac@metabarcoding.org)
 */
static int create_version_file(OBIDMS_p dms, char *column_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_column_file_name(const char *column_name, obiversion_t version_number)
{
	char *filename;

	// Build the database directory name
	if (asprintf(&filename,"%s@%d.odc", column_name, version_number) < 0)
	{
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		return NULL;
	}

	return filename;
}


static char *build_version_file_name(const char *column_name)
{
	char *filename;

	// Build the database directory name
	if (asprintf(&filename,"%s.odv", column_name) < 0)
	{
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		return NULL;
	}

	return filename;
}


static obiversion_t obi_get_new_version_number(OBIDMS_p dms, char *column_name, bool block)
{
	off_t 			loc_size;
	obiversion_t 	new_version_number;
	char* 			version_file_name;
	int    			directory_file_descriptor;
	int    			version_file_descriptor;
	bool   			little_endian;
	int 			lock_mode;

	new_version_number = 0;
	loc_size = sizeof(bool) + sizeof(obiversion_t);

	// Select the correct lockf operation according to the blocking mode
	if (block)
		lock_mode=F_LOCK;
	else
		lock_mode=F_TLOCK;

	// build the version file name
	version_file_name = build_version_file_name(column_name);
	if (version_file_name == NULL)
		return -1;

	// Get the file descriptor associated to the database directory
	directory_file_descriptor = dirfd(dms->directory);
	if (directory_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	//open the version file
	version_file_descriptor = private_openat(directory_file_descriptor, version_file_name, O_RDWR);

	if (version_file_descriptor < 0)
	{
		free(version_file_name);

		if (errno == ENOENT)
		{
			return create_version_file(dms, column_name);
		}
		else
		{
			obi_set_errno(OBIDMS_UNKNOWN_ERROR);
			return -1;
		}
	}

	// Test if the version file size is ok
	if (lseek(version_file_descriptor, 0, SEEK_END) < loc_size)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// prepare the file for locking
	if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// Lock the file
	if (lockf(version_file_descriptor, lock_mode, loc_size) < -1)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// read the endianess of the file
    if (read(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

    // check if endianess is correct
    if (little_endian != obi_is_little_endian())
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_BAD_ENDIAN_ERROR);
		free(version_file_name);
		return -1;
	}

    // read the current version number
    if (read(version_file_descriptor, &new_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

    new_version_number++;

    // write the new version number
	if (lseek(version_file_descriptor, sizeof(bool), SEEK_SET) != sizeof(bool))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (write(version_file_descriptor, &new_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// prepare for the unlocking
	if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// unlock the file
	if (lockf(version_file_descriptor, F_ULOCK, loc_size) < -1)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	close(version_file_descriptor);
	free(version_file_name);
	return new_version_number;
}


static int create_version_file(OBIDMS_p dms, char *column_name)
{
	off_t 			loc_size;
	obiversion_t 	version_number;
	char* 			version_file_name;
	int    			directory_file_descriptor;
	int    			version_file_descriptor;
	bool   			little_endian;

	loc_size = sizeof(bool) + sizeof(obiversion_t);
	version_number = 0;

	version_file_name = build_version_file_name(column_name);

	if (version_file_name == NULL)
		return -1;

	directory_file_descriptor = dirfd(dms->directory);
	if (directory_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	version_file_descriptor = private_openat(directory_file_descriptor,
							  	  	  	  	 version_file_name,
							  	  	  	  	 O_RDWR | O_CREAT);

	if (version_file_descriptor < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// Lock the file
	if (lockf(version_file_descriptor, F_LOCK, loc_size) < -1)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (ftruncate(version_file_descriptor, loc_size) < 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	little_endian = obi_is_little_endian();

	if (write(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (write(version_file_descriptor, &version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// prepare for the unlocking
	if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	// unlock the file
	if (lockf(version_file_descriptor, F_ULOCK, loc_size) < -1)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	close(version_file_descriptor);
	free(version_file_name);
	return version_number;
}


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

obiversion_t obi_get_latest_version_number(OBIDMS_p dms, char *column_name)
{
	off_t 			loc_size;
	obiversion_t 	latest_version_number;
	char * 			version_file_name;
	int    			directory_file_descriptor;
	int    			version_file_descriptor;
	bool   			little_endian;

	loc_size = sizeof(bool) + sizeof(obiversion_t);
	latest_version_number = 0;

	version_file_name = build_version_file_name(column_name);
	if (version_file_name==NULL)
		return -1;

	directory_file_descriptor = dirfd(dms->directory);
	if (directory_file_descriptor < 0) {
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	version_file_descriptor = private_openat(directory_file_descriptor, version_file_name, O_RDONLY);

	if (version_file_descriptor < 0) {
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (lseek(version_file_descriptor, 0, SEEK_END) < loc_size)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

	if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

    if (read(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}

    if (little_endian != obi_is_little_endian())
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_BAD_ENDIAN_ERROR);
		free(version_file_name);
		return -1;
	}

    if (read(version_file_descriptor, &latest_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
	{
		close(version_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(version_file_name);
		return -1;
	}


	close(version_file_descriptor);
	free(version_file_name);
	return latest_version_number;
}


size_t obi_get_platform_header_size()
{
	return getpagesize() * 1;
}


OBIDMS_column_p obi_create_column(OBIDMS_p dms,
		                         char *column_name,
								 OBIType_t type,
								 size_t nb_elements)
{
	OBIDMS_column_p 		new_column;
	OBIDMS_column_header_p 	header;
	size_t 					file_size;
	obiversion_t 			version_number;
	char* 					column_file_name;
	int 					column_file_descriptor;
	int 					directory_file_descriptor;
	size_t 					header_size;
	size_t 					data_size;

	new_column = NULL;

	directory_file_descriptor = dirfd(dms->directory);
	if (directory_file_descriptor < 0) {
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		return NULL;
	}

	header_size = obi_get_platform_header_size();
	data_size = obi_array_sizeof(type, nb_elements);

	file_size = header_size + data_size;

	version_number = obi_get_new_version_number(dms, column_name, true);

	if (version_number < 0)
	{
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		return NULL;
	}

	column_file_name = build_column_file_name(column_name, version_number);

	column_file_descriptor =  private_openat(directory_file_descriptor,
											 column_file_name,
					   		   	   	   	   	 O_RDWR | O_CREAT);

	if (ftruncate(column_file_descriptor, file_size) < 0)
	{
		close(column_file_descriptor);
		obi_set_errno(OBIDMS_UNKNOWN_ERROR);
		free(column_file_name);
		return NULL;
	}

	new_column = (OBIDMS_column_p) malloc(sizeof(OBIDMS_column_t));

	if (new_column)
	{
		close(column_file_descriptor);
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		free(column_file_name);
		return NULL;
	}

	new_column->dms    = dms;
	new_column->header = mmap(NULL,
			                 header_size,
					         PROT_READ | PROT_WRITE,
					         MAP_SHARED,
					         column_file_descriptor,
					         0
			                );

	if (new_column->header == MAP_FAILED)
	{
		close(column_file_descriptor);
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		free(column_file_name);
		free(new_column);
		return NULL;
	}

	new_column->data   = mmap(NULL,
			                 data_size,
					         PROT_READ | PROT_WRITE,
					         MAP_SHARED,
					         column_file_descriptor,
					         header_size
			                );

	if (new_column->data == MAP_FAILED)
	{
		munmap(new_column->header, header_size);
		close(column_file_descriptor);
		obi_set_errno(OBIDMS_MEMORY_ERROR);
		free(column_file_name);
		free(new_column);
		return NULL;
	}

	new_column->writable= true;

	header = new_column->header;
	header->little_endian = obi_is_little_endian();
	header->header_size   = header_size;
	header->line_count    = nb_elements;
	header->lines_used    = 0;
	header->data_type     = type;
	header->creation_date = time(NULL);
	header->version       = version_number;
	header->comments[0]   = 0x0;
	strncpy(header->name, column_name, OBIDMS_MAX_COLNAME);

	free(column_file_name);
	return new_column;
}


//	if( access( fname, F_OK ) != -1 ) {
//	    // file exists
//	} else {
//	    // file doesn't exist
//	}