233 lines
7.6 KiB
C
233 lines
7.6 KiB
C
/**
|
|
* Copyright (C) 2008 Happy Fish / YuQing
|
|
*
|
|
* FastDFS may be copied only under the terms of the GNU General
|
|
* Public License V3, which may be found in the FastDFS source kit.
|
|
* Please visit the FastDFS Home Page http://www.fastken.com/ for more detail.
|
|
**/
|
|
|
|
//fdht_client.h
|
|
|
|
#ifndef _FDHT_CLIENT_H
|
|
#define _FDHT_CLIENT_H
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "fdht_define.h"
|
|
#include "fdht_types.h"
|
|
#include "fdht_proto.h"
|
|
#include "fdht_func.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern GroupArray g_group_array; //group info, including server list
|
|
extern bool g_keep_alive; //persistent connection flag
|
|
|
|
/*
|
|
init function
|
|
param:
|
|
filename: client config filename
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_client_init(const char *filename);
|
|
|
|
|
|
/*
|
|
init function
|
|
param:
|
|
filename: client config filename
|
|
pGroupArray: return server list
|
|
bKeepAlive: return keep alive flag
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_load_conf(const char *filename, GroupArray *pGroupArray, \
|
|
bool *bKeepAlive);
|
|
|
|
|
|
int fdht_connect_all_servers(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
int *success_count, int *fail_count);
|
|
|
|
void fdht_disconnect_all_servers(GroupArray *pGroupArray);
|
|
|
|
/*
|
|
destroy function, free resource
|
|
param:
|
|
return: none
|
|
*/
|
|
void fdht_client_destroy();
|
|
|
|
#define fdht_get(pKeyInfo, ppValue, value_len) \
|
|
fdht_get_ex1((&g_group_array), g_keep_alive, pKeyInfo, \
|
|
FDHT_EXPIRES_NONE, ppValue, value_len, malloc)
|
|
|
|
#define fdht_get_ex(pKeyInfo, expires, ppValue, value_len) \
|
|
fdht_get_ex1((&g_group_array), g_keep_alive, pKeyInfo, expires, \
|
|
ppValue, value_len, malloc)
|
|
|
|
#define fdht_batch_get(pObjectInfo, key_list, key_count, success_count) \
|
|
fdht_batch_get_ex1((&g_group_array), g_keep_alive, pObjectInfo, \
|
|
key_list, key_count, FDHT_EXPIRES_NONE, \
|
|
malloc, success_count)
|
|
|
|
#define fdht_batch_get_ex(pObjectInfo, key_list, key_count, \
|
|
expires, success_count) \
|
|
fdht_batch_get_ex1((&g_group_array), g_keep_alive, pObjectInfo, \
|
|
key_list, key_count, expires, malloc, success_count)
|
|
|
|
#define fdht_set(pKeyInfo, expires, pValue, value_len) \
|
|
fdht_set_ex((&g_group_array), g_keep_alive, pKeyInfo, expires, \
|
|
pValue, value_len)
|
|
|
|
#define fdht_batch_set(pObjectInfo, key_list, key_count, \
|
|
expires, success_count) \
|
|
fdht_batch_set_ex((&g_group_array), g_keep_alive, pObjectInfo, \
|
|
key_list, key_count, expires, success_count)
|
|
|
|
#define fdht_inc(pKeyInfo, expires, increase, pValue, value_len) \
|
|
fdht_inc_ex((&g_group_array), g_keep_alive, pKeyInfo, expires, \
|
|
increase, pValue, value_len)
|
|
|
|
#define fdht_delete(pKeyInfo) \
|
|
fdht_delete_ex((&g_group_array), g_keep_alive, pKeyInfo)
|
|
|
|
#define fdht_batch_delete(pObjectInfo, key_list, key_count, success_count) \
|
|
fdht_batch_delete_ex((&g_group_array), g_keep_alive, pObjectInfo, \
|
|
key_list, key_count, success_count)
|
|
|
|
#define fdht_stat(server_index, buff, size) \
|
|
fdht_stat_ex((&g_group_array), g_keep_alive, server_index, buff, size)
|
|
|
|
/*
|
|
get value of the key
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pKeyInfo: the key to fetch
|
|
expires: expire time (unix timestamp)
|
|
FDHT_EXPIRES_NONE - do not change the expire time of the key
|
|
FDHT_EXPIRES_NEVER- set the expire time to forever(never expired)
|
|
ppValue: return the value of the key
|
|
value_len: return the length of the value (bytes)
|
|
malloc_func: malloc function, can be standard function named malloc
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_get_ex1(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTKeyInfo *pKeyInfo, const time_t expires, \
|
|
char **ppValue, int *value_len, MallocFunc malloc_func);
|
|
|
|
/*
|
|
get values of the key list
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pObjectInfo: the object to fetch, namespace and object id can't be empty
|
|
key_list: key list, return the value of the key
|
|
key_count: key count
|
|
expires: expire time (unix timestamp)
|
|
FDHT_EXPIRES_NONE - do not change the expire time of the keys
|
|
FDHT_EXPIRES_NEVER- set the expire time to forever(never expired)
|
|
malloc_func: malloc function, can be standard function named malloc
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_batch_get_ex1(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTObjectInfo *pObjectInfo, FDHTKeyValuePair *key_list, \
|
|
const int key_count, const time_t expires, \
|
|
MallocFunc malloc_func, int *success_count);
|
|
|
|
/*
|
|
set value of the key
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pKeyInfo: the key to set
|
|
expires: expire time (unix timestamp)
|
|
FDHT_EXPIRES_NEVER- set the expire time to forever(never expired)
|
|
pValue: the value of the key
|
|
value_len: the length of the value (bytes)
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_set_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTKeyInfo *pKeyInfo, const time_t expires, \
|
|
const char *pValue, const int value_len);
|
|
|
|
/*
|
|
set values of the key list
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pObjectInfo: the object to fetch, namespace and object id can't be empty
|
|
key_list: key list, return the value of the key
|
|
key_count: key count
|
|
expires: expire time (unix timestamp)
|
|
FDHT_EXPIRES_NEVER- set the expire time to forever(never expired)
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_batch_set_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTObjectInfo *pObjectInfo, FDHTKeyValuePair *key_list, \
|
|
const int key_count, const time_t expires, int *success_count);
|
|
|
|
/*
|
|
increase value of the key, if the key does not exist,
|
|
set the value to increment value (param named "increase")
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pKeyInfo: the key to increase
|
|
expires: expire time (unix timestamp)
|
|
FDHT_EXPIRES_NEVER- set the expire time to forever(never expired)
|
|
increase: the increment value, can be negative, eg. 1 or -1
|
|
pValue: return the value after increment
|
|
value_len: return the length of the value (bytes)
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_inc_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTKeyInfo *pKeyInfo, const time_t expires, \
|
|
const int increase, char *pValue, int *value_len);
|
|
|
|
/*
|
|
delete the key
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pKeyInfo: the key to delete
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_delete_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTKeyInfo *pKeyInfo);
|
|
|
|
/*
|
|
delete key list
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
bKeepAlive: persistent connection flag, true for persistent connection
|
|
pObjectInfo: the object to fetch, namespace and object id can't be empty
|
|
key_list: key list, return the value of the key
|
|
key_count: key count
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_batch_delete_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
FDHTObjectInfo *pObjectInfo, FDHTKeyValuePair *key_list, \
|
|
const int key_count, int *success_count);
|
|
|
|
/*
|
|
query stat of server
|
|
param:
|
|
pGroupArray: group info, can use &g_group_array
|
|
server_index: index of server, based 0
|
|
buff: return stat buff, key value pair as key=value, row seperated by \n
|
|
size: buff size
|
|
return: 0 for success, != 0 for fail (errno)
|
|
*/
|
|
int fdht_stat_ex(GroupArray *pGroupArray, const bool bKeepAlive, \
|
|
const int server_index, char *buff, const int size);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|