obitools/obitools3
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 66 Wiki Activity

fixed bugs and typos in the obidms and obidmscolumn source and header

Browse Source 
files
This commit is contained in:
Celine Mercier
2015-06-17 16:51:16 +02:00
parent 9f9c20aa4a
commit ed662077b3
4 changed files with 342 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
src/obidmscolumn.c
View File

@ -10,11 +10,19 @@
*/
#include <obidmscolumn.h>
#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"
/*************************************************************************
*
@ -30,9 +38,9 @@
*
* @warning The returned pointer has to be freed by the caller.
*
* @param name the name of the column of the OBIDMS
* @param column_name the name of the OBIDMS column.
*
* @return a pointer to the filename name
* @return a pointer to the column file name
* @retvalue NULL if an error occurs
*
* ###Error values
@ -41,20 +49,20 @@
* @since May 2015
* @author Eric Coissac (eric.coissac@metabarcoding.org)
*/
static char *build_column_name(const char *name, obiversion_t version);
static char *build_column_file_name(const char *column_name, obiversion_t version_number);
/**
* @brief Internal function building the file name for a version column file.
* @brief Internal function building the file name for a column version file.
*
* The version column file indicate the latest version number for a column.
* This function returns the name of the file storing this information
* 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 name the name of the column of the OBIDMS
* @param column_name the name of the OBIDMS column.
*
* @return a pointer to the filename name
* @return a pointer to the version file name
* @retvalue NULL if an error occurs
*
* ###Error values
@ -63,7 +71,7 @@ static char *build_column_name(const char *name, obiversion_t version);
* @since May 2015
* @author Eric Coissac (eric.coissac@metabarcoding.org)
*/
static char *build_version_name(const char *name);
static char *build_version_file_name(const char *column_name);
/**
@ -71,7 +79,7 @@ static char *build_version_name(const char *name);
* in the `dms` database
*
* @param dms a pointer as returned by obi_create_dms() or obi_open_dms()
* @param name the name of the column
* @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
@ -82,7 +90,7 @@ static char *build_version_name(const char *name);
* @since May 2015
* @author Eric Coissac (eric.coissac@metabarcoding.org)
*/
static obiversion_t obi_new_version(OBIDMS_p dms,char *name, bool block);
static obiversion_t obi_get_new_version_number(OBIDMS_p dms, char *column_name, bool block);
/**
@ -92,15 +100,15 @@ static obiversion_t obi_new_version(OBIDMS_p dms,char *name, bool block);
* 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 name the name of the column
* @param column_name the name of the column
*
* @return the next usable version number for this comumn : `0`
* @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(OBIDMS_p dms,char *name);
static int create_version_file(OBIDMS_p dms, char *column_name);
/************************************************************************
@ -109,12 +117,12 @@ static int create_version(OBIDMS_p dms,char *name);
*
************************************************************************/
static char *build_column_name(const char *name,obiversion_t version) {
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",name,version) < 0)
if (asprintf(&filename,"%s@%d.odc", column_name, version_number) < 0)
{
obi_set_errno(OBIDMS_MEMORY_ERROR);
return NULL;
@ -124,12 +132,12 @@ static char *build_column_name(const char *name,obiversion_t version) {
}
static char *build_version_name(const char *name) {
static char *build_version_file_name(const char *column_name)
{
char *filename;
// Build the database directory name
if (asprintf(&filename,"%s.odv",name) < 0)
if (asprintf(&filename,"%s.odv", column_name) < 0)
{
obi_set_errno(OBIDMS_MEMORY_ERROR);
return NULL;
@ -139,46 +147,49 @@ static char *build_version_name(const char *name) {
}
static obiversion_t obi_new_version(OBIDMS_p dms,char *name, bool block) {
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;
off_t locsize=sizeof(bool) + sizeof(obiversion_t);
obiversion_t newversion=0;
char * versionfile;
int directoryfd;
int versionfd;
bool little;
int lockmode;
new_version_number = 0;
loc_size = sizeof(bool) + sizeof(obiversion_t);
// Select the correct lockf operation according to the blocking mode
if (block)
lockmode=F_LOCK;
lock_mode=F_LOCK;
else
lockmode=F_TLOCK;
lock_mode=F_TLOCK;
// build the version file name
versionfile = build_version_name(name);
if (versionfile==NULL)
version_file_name = build_version_file_name(column_name);
if (version_file_name == NULL)
return -1;
// Get the file descriptior associated to the database directory
directoryfd = dirfd(dms->directory);
if (directoryfd < 0) {
// 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(versionfile);
free(version_file_name);
return -1;
}
//open the version file
//versionfd = openat(directoryfd, versionfile, O_RDWR);
versionfd = open(versionfile, O_RDWR);
version_file_descriptor = private_openat(directory_file_descriptor, version_file_name, O_RDWR);
if (versionfd < 0) {
free(versionfile);
if (version_file_descriptor < 0)
{
free(version_file_name);
if (errno == ENOENT)
{
return create_version(dms, name);
return create_version_file(dms, column_name);
}
else
{
@ -188,283 +199,286 @@ static obiversion_t obi_new_version(OBIDMS_p dms,char *name, bool block) {
}
// Test if the version file size is ok
if (lseek(versionfd, SEEK_END, 0) < locsize)
if (lseek(version_file_descriptor, 0, SEEK_END) < loc_size)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// prepare the file for locking
if (lseek(versionfd, SEEK_SET, 0) != 0)
if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// Lock the file
if (lockf(versionfd, lockmode, locsize) < -1)
if (lockf(version_file_descriptor, lock_mode, loc_size) < -1)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// read the endianess of the file
if (read(versionfd, &little, sizeof(bool)) < sizeof(bool))
if (read(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// check if endianess is correct
if (little != obi_is_little_endian())
if (little_endian != obi_is_little_endian())
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_BAD_ENDIAN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// read the current version number
if (read(versionfd, &newversion, sizeof(obiversion_t)) < sizeof(obiversion_t))
if (read(version_file_descriptor, &new_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
newversion++;
new_version_number++;
// write the new version number
if (lseek(versionfd,SEEK_SET,sizeof(bool)) != sizeof(bool))
if (lseek(version_file_descriptor, sizeof(bool), SEEK_SET) != sizeof(bool))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (write(versionfd, &newversion, sizeof(obiversion_t)) < sizeof(obiversion_t))
if (write(version_file_descriptor, &new_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// prepare for the unlocking
if (lseek(versionfd,SEEK_SET,0) != 0)
if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// unlock the file
if (lockf(versionfd, F_ULOCK, locsize) < -1)
if (lockf(version_file_descriptor, F_ULOCK, loc_size) < -1)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
close(versionfd);
free(versionfile);
return newversion;
close(version_file_descriptor);
free(version_file_name);
return new_version_number;
}
static int create_version(OBIDMS_p dms,char *name) {
off_t locsize=sizeof(bool) + sizeof(obiversion_t);
obiversion_t version=0;
char * versionfile;
int directoryfd;
int versionfd;
bool little;
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;
versionfile = build_version_name(name);
loc_size = sizeof(bool) + sizeof(obiversion_t);
version_number = 0;
if (versionfile==NULL)
version_file_name = build_version_file_name(column_name);
if (version_file_name == NULL)
return -1;
directoryfd = dirfd(dms->directory);
if (directoryfd < 0) {
directory_file_descriptor = dirfd(dms->directory);
if (directory_file_descriptor < 0)
{
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
//versionfd = openat(directoryfd,
// versionfile,
// O_RDWR|O_CREAT|O_EXCL,
// 666);
version_file_descriptor = private_openat(directory_file_descriptor,
version_file_name,
O_RDWR | O_CREAT);
versionfd = open(versionfile,
O_RDWR|O_CREAT|O_EXCL,
666);
if (versionfd < 0) {
if (version_file_descriptor < 0)
{
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// Lock the file
if (lockf(versionfd, F_LOCK, locsize) < -1)
if (lockf(version_file_descriptor, F_LOCK, loc_size) < -1)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (ftruncate(versionfd,locsize) < 0)
if (ftruncate(version_file_descriptor, loc_size) < 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (lseek(versionfd,SEEK_SET,0) != 0)
if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
little = obi_is_little_endian();
little_endian = obi_is_little_endian();
if (write(versionfd, &little, sizeof(bool)) < sizeof(bool))
if (write(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (write(versionfd, &version, sizeof(obiversion_t)) < sizeof(obiversion_t))
if (write(version_file_descriptor, &version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// prepare for the unlocking
if (lseek(versionfd,SEEK_SET,0) != 0)
if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
// unlock the file
if (lockf(versionfd, F_ULOCK, locsize) < -1)
if (lockf(version_file_descriptor, F_ULOCK, loc_size) < -1)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
close(versionfd);
free(versionfile);
return version;
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
* 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_latest_version(OBIDMS_p dms,char *name) {
off_t locsize=sizeof(bool) + sizeof(obiversion_t);
obiversion_t version=0;
char * versionfile;
int directoryfd;
int versionfd;
bool little;
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;
versionfile = build_version_name(name);
if (versionfile==NULL)
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;
directoryfd = dirfd(dms->directory);
if (directoryfd < 0) {
directory_file_descriptor = dirfd(dms->directory);
if (directory_file_descriptor < 0) {
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
//versionfd = openat(directoryfd,versionfile,O_RDWR);
versionfd = open(versionfile,O_RDWR);
version_file_descriptor = private_openat(directory_file_descriptor, version_file_name, O_RDONLY);
if (versionfd < 0) {
if (version_file_descriptor < 0) {
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (lseek(versionfd,SEEK_END,0) < locsize)
if (lseek(version_file_descriptor, 0, SEEK_END) < loc_size)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (lseek(versionfd,SEEK_SET,0) != 0)
if (lseek(version_file_descriptor, 0, SEEK_SET) != 0)
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (read(versionfd, &little, sizeof(bool)) < sizeof(bool))
if (read(version_file_descriptor, &little_endian, sizeof(bool)) < sizeof(bool))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (little != obi_is_little_endian())
if (little_endian != obi_is_little_endian())
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_BAD_ENDIAN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
if (read(versionfd, &version, sizeof(obiversion_t)) < sizeof(obiversion_t))
if (read(version_file_descriptor, &latest_version_number, sizeof(obiversion_t)) < sizeof(obiversion_t))
{
close(versionfd);
close(version_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(versionfile);
free(version_file_name);
return -1;
}
close(versionfd);
free(versionfile);
return version;
close(version_file_descriptor);
free(version_file_name);
return latest_version_number;
}
@ -475,120 +489,116 @@ size_t obi_get_platform_header_size()
OBIDMS_column_p obi_create_column(OBIDMS_p dms,
char *name,
char *column_name,
OBIType_t type,
size_t nbelements)
size_t nb_elements)
{
OBIDMS_column_p newcolumn=NULL;
OBIDMS_column_header_p header;
size_t filesize;
obiversion_t version;
char * columnfile;
int columnfd;
int directoryfd;
size_t hsize;
size_t dsize;
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;
directoryfd = dirfd(dms->directory);
if (directoryfd < 0) {
directory_file_descriptor = dirfd(dms->directory);
if (directory_file_descriptor < 0) {
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
return NULL;
}
hsize = obi_get_platform_header_size();
dsize = obi_array_sizeof(type,nbelements);
header_size = obi_get_platform_header_size();
data_size = obi_array_sizeof(type, nb_elements);
filesize = hsize + dsize;
file_size = header_size + data_size;
version = obi_new_version(dms,name,true);
version_number = obi_get_new_version_number(dms, column_name, true);
if (version < 0)
if (version_number < 0)
{
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
return NULL;
}
columnfile = build_column_name(name,version);
column_file_name = build_column_file_name(column_name, version_number);
//columnfd = openat(directoryfd,
// columnfile,
// O_RDWR|O_CREAT|O_EXCL,
// 666);
column_file_descriptor = private_openat(directory_file_descriptor,
column_file_name,
O_RDWR | O_CREAT);
columnfd = open(columnfile,
O_RDWR|O_CREAT|O_EXCL,
666);
if (ftruncate(columnfd,filesize) < 0)
if (ftruncate(column_file_descriptor, file_size) < 0)
{
close(columnfd);
close(column_file_descriptor);
obi_set_errno(OBIDMS_UNKNOWN_ERROR);
free(columnfile);
free(column_file_name);
return NULL;
}
newcolumn = (OBIDMS_column_p) malloc(sizeof(OBIDMS_column_t));
new_column = (OBIDMS_column_p) malloc(sizeof(OBIDMS_column_t));
if (newcolumn)
if (new_column)
{
close(columnfd);
close(column_file_descriptor);
obi_set_errno(OBIDMS_MEMORY_ERROR);
free(columnfile);
free(column_file_name);
return NULL;
}
newcolumn->dms = dms;
newcolumn->header = mmap(NULL,
hsize,
new_column->dms = dms;
new_column->header = mmap(NULL,
header_size,
PROT_READ | PROT_WRITE,
MAP_SHARED,
columnfd,
column_file_descriptor,
0
);
if (newcolumn->header == MAP_FAILED)
if (new_column->header == MAP_FAILED)
{
close(columnfd);
close(column_file_descriptor);
obi_set_errno(OBIDMS_MEMORY_ERROR);
free(columnfile);
free(newcolumn);
free(column_file_name);
free(new_column);
return NULL;
}
newcolumn->data = mmap(NULL,
dsize,
new_column->data = mmap(NULL,
data_size,
PROT_READ | PROT_WRITE,
MAP_SHARED,
columnfd,
hsize
column_file_descriptor,
header_size
);
if (newcolumn->data == MAP_FAILED)
if (new_column->data == MAP_FAILED)
{
munmap(newcolumn->header,hsize);
close(columnfd);
munmap(new_column->header, header_size);
close(column_file_descriptor);
obi_set_errno(OBIDMS_MEMORY_ERROR);
free(columnfile);
free(newcolumn);
free(column_file_name);
free(new_column);
return NULL;
}
newcolumn->writable= true;
new_column->writable= true;
header = newcolumn->header;
header = new_column->header;
header->little_endian = obi_is_little_endian();
header->header_size = hsize;
header->line_count = nbelements;
header->line_used = 0;
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;
header->version = version_number;
header->comments[0] = 0x0;
strncpy(header->name,name,OBIDMS_MAX_COLNAME);
strncpy(header->name, column_name, OBIDMS_MAX_COLNAME);
free(columnfile);
return newcolumn;
free(column_file_name);
return new_column;
}