pdxx
/
libfastcommon
mirror of https://github.com/happyfish100/libfastcommon.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
libfastcommon/src/server_id_func.c

1816 lines
56 KiB
C
Raw Blame History

/*
* Copyright (c) 2020 YuQing <384681@qq.com>
*
* This program is free software: you can use, redistribute, and/or modify
* it under the terms of the Lesser GNU General Public License, version 3
* or later ("LGPL"), as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.
*
* You should have received a copy of the Lesser GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <netdb.h>
#include "logger.h"
#include "shared_func.h"
#include "sockopt.h"
#include "server_id_func.h"
#define GROUP_SECTION_PREFIX_STR "group-"
#define GROUP_SECTION_PREFIX_LEN (sizeof(GROUP_SECTION_PREFIX_STR) - 1)
#define SERVER_SECTION_PREFIX_STR "server-"
#define SERVER_SECTION_PREFIX_LEN (sizeof(SERVER_SECTION_PREFIX_STR) - 1)
#define SERVER_ITEM_PORT_STR "port"
#define SERVER_ITEM_PORT_LEN (sizeof(SERVER_ITEM_PORT_STR) - 1)
#define SERVER_ITEM_HOST_STR "host"
#define SERVER_ITEM_HOST_LEN (sizeof(SERVER_ITEM_HOST_STR) - 1)
#define SERVER_ITEM_HOST_AFFIX_STR "-host"
#define SERVER_ITEM_HOST_AFFIX_LEN (sizeof(SERVER_ITEM_HOST_AFFIX_STR) - 1)
#define SERVER_ITEM_PORT_AFFIX_STR "-port"
#define SERVER_ITEM_PORT_AFFIX_LEN (sizeof(SERVER_ITEM_PORT_AFFIX_STR) - 1)
#define IP_PORT_MAP_COUNT(ctx) ctx->sorted_server_arrays.by_ip_port.count
#define IP_PORT_MAPS(ctx) ctx->sorted_server_arrays.by_ip_port.maps
#define FC_SERVER_GROUP_PORT(group) \
(group->server_port > 0 ? group->server_port : group->port)
static int fc_server_cmp_server_id(const void *p1, const void *p2)
{
return ((FCServerInfo *)p1)->id - ((FCServerInfo *)p2)->id;
}
static int fc_server_cmp_ip_and_port(const void *p1, const void *p2)
{
FCServerMap *m1;
FCServerMap *m2;
int result;
int sub;
int min;
m1 = (FCServerMap *)p1;
m2 = (FCServerMap *)p2;
sub = m1->ip_addr.len - m2->ip_addr.len;
if (sub < 0) {
min = m1->ip_addr.len;
} else {
min = m2->ip_addr.len;
}
if (min > 0) {
result = memcmp(m1->ip_addr.str, m2->ip_addr.str, min);
if (result != 0) {
return result;
}
}
if (sub != 0) {
return sub;
}
return m1->port - m2->port;
}
static int fc_server_cmp_address_ptr(const void *p1, const void *p2)
{
FCAddressInfo **addr1;
FCAddressInfo **addr2;
int result;
addr1 = (FCAddressInfo **)p1;
addr2 = (FCAddressInfo **)p2;
if ((result=strcmp((*addr1)->conn.ip_addr, (*addr2)->conn.ip_addr)) != 0) {
return result;
}
return (*addr1)->conn.port - (*addr2)->conn.port;
}
FCServerInfo *fc_server_get_by_id(FCServerConfig *ctx,
const int server_id)
{
FCServerInfo target;
target.id = server_id;
return (FCServerInfo *)bsearch(&target, FC_SID_SERVERS(*ctx),
FC_SID_SERVER_COUNT(*ctx), sizeof(FCServerInfo),
fc_server_cmp_server_id);
}
static int fc_server_calc_ip_port_count(FCServerConfig *ctx)
{
FCServerInfo *server;
FCServerInfo *send;
int count;
count = 0;
send = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
for (server=FC_SID_SERVERS(*ctx); server<send; server++) {
count += server->uniq_addresses.count;
}
return count;
}
static int fc_server_check_alloc_group_addresses(FCAddressPtrArray *array)
{
int new_alloc;
int bytes;
FCAddressInfo **new_addrs;
if (array->count < array->alloc) {
return 0;
}
new_alloc = array->alloc > 0 ? 2 * array->alloc : 2;
bytes = sizeof(FCAddressInfo *) * new_alloc;
new_addrs = (FCAddressInfo **)fc_malloc(bytes);
if (new_addrs == NULL) {
return ENOMEM;
}
memset(new_addrs, 0, bytes);
if (array->addrs != NULL) {
memcpy(new_addrs, array->addrs, sizeof(FCAddressInfo *) * array->count);
free(array->addrs);
}
array->addrs = new_addrs;
array->alloc = new_alloc;
return 0;
}
static FCAddressInfo *fc_server_add_to_uniq_addresses(
FCAddressPtrArray *addr_ptr_array, const FCAddressInfo *addr)
{
FCAddressInfo *p;
FCAddressInfo **pp;
FCAddressInfo **end;
end = addr_ptr_array->addrs + addr_ptr_array->count;
for (pp=addr_ptr_array->addrs; pp<end; pp++) {
if (FC_CONNECTION_SERVER_EQUAL1(addr->conn, (*pp)->conn)) {
return *pp;
}
}
if (fc_server_check_alloc_group_addresses(addr_ptr_array) != 0) {
return NULL;
}
p = (FCAddressInfo *)fc_malloc(sizeof(FCAddressInfo));
if (p == NULL) {
return NULL;
}
*p = *addr;
addr_ptr_array->addrs[addr_ptr_array->count++] = p;
return p;
}
static int fc_server_init_ip_port_array(FCServerConfig *ctx)
{
int count;
int bytes;
FCServerMapArray *map_array;
FCServerMap *map;
FCServerInfo *server;
FCServerInfo *send;
FCAddressInfo **paddr;
FCAddressInfo **pend;
map_array = &ctx->sorted_server_arrays.by_ip_port;
count = fc_server_calc_ip_port_count(ctx);
bytes = sizeof(FCServerMap) * count;
map_array->maps = (FCServerMap *)fc_malloc(bytes);
if (map_array->maps == NULL) {
return ENOMEM;
}
memset(map_array->maps, 0, bytes);
send = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
map = map_array->maps;
for (server=FC_SID_SERVERS(*ctx); server<send; server++) {
pend = server->uniq_addresses.addrs + server->uniq_addresses.count;
for (paddr=server->uniq_addresses.addrs; paddr<pend; paddr++) {
map->server = server;
FC_SET_STRING(map->ip_addr, (*paddr)->conn.ip_addr);
map->port = (*paddr)->conn.port;
map++;
}
}
map_array->count = map - map_array->maps;
qsort(map_array->maps, map_array->count, sizeof(FCServerMap),
fc_server_cmp_ip_and_port);
return 0;
}
static int fc_server_check_id_duplicated(FCServerConfig *ctx,
const char *config_filename)
{
FCServerInfo *previous;
FCServerInfo *current;
FCServerInfo *send;
previous = FC_SID_SERVERS(*ctx) + 0;
send = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
for (current=FC_SID_SERVERS(*ctx) + 1; current<send; current++) {
if (current->id == previous->id) {
logError("file: "__FILE__", line: %d, "
"config file: %s, duplicate server id: %d",
__LINE__, config_filename, current->id);
return EEXIST;
}
previous = current;
}
return 0;
}
static int fc_server_check_ip_port(FCServerConfig *ctx,
const char *config_filename)
{
FCServerMap *previous;
FCServerMap *current;
FCServerMap *end;
char formatted_ip[FORMATTED_IP_SIZE];
int id1;
int id2;
previous = IP_PORT_MAPS(ctx) + 0;
end = IP_PORT_MAPS(ctx) + IP_PORT_MAP_COUNT(ctx);
for (current=IP_PORT_MAPS(ctx)+1; current<end; current++) {
if (fc_server_cmp_ip_and_port(current, previous) == 0) {
if (previous->server->id < current->server->id) {
id1 = previous->server->id;
id2 = current->server->id;
} else {
id1 = current->server->id;
id2 = previous->server->id;
}
logError("file: "__FILE__", line: %d, "
"config file: %s, duplicate ip:port %s:%u, "
"the server ids: %d, %d", __LINE__,
config_filename, format_ip_address(previous->ip_addr.str,
formatted_ip), previous->port, id1, id2);
return EEXIST;
}
previous = current;
}
return 0;
}
FCServerInfo *fc_server_get_by_ip_port_ex(FCServerConfig *ctx,
const string_t *ip_addr, const int port)
{
FCServerMap target;
FCServerMap *found;
target.ip_addr = *ip_addr;
target.port = port;
found = (FCServerMap *)bsearch(&target, IP_PORT_MAPS(ctx),
IP_PORT_MAP_COUNT(ctx), sizeof(FCServerMap),
fc_server_cmp_ip_and_port);
if (found != NULL) {
return found->server;
}
return NULL;
}
static inline void fc_server_set_group_ptr_name(FCServerGroupInfo *ginfo,
const char *group_name)
{
ginfo->group_name.str = ginfo->name_buff;
ginfo->group_name.len = snprintf(ginfo->name_buff,
sizeof(ginfo->name_buff) - 1, "%s", group_name);
if (ginfo->group_name.len == 0) {
return;
}
fc_trim(ginfo->group_name.str);
ginfo->group_name.len = strlen(ginfo->group_name.str);
}
static inline void fc_server_set_ip_prefix(FCServerGroupInfo *ginfo,
const char *ip_prefix)
{
ginfo->filter.ip_prefix.str = ginfo->filter.prefix_buff;
if (ip_prefix != NULL) {
ginfo->filter.ip_prefix.len = snprintf(ginfo->filter.prefix_buff,
sizeof(ginfo->filter.prefix_buff) - 1, "%s", ip_prefix);
}
}
static inline int fc_server_set_comm_type(FCCommunicationType *comm_type,
const char *config_filename, const char *section_name,
const char *comm_type_str, const FCCommunicationType default_comm_type)
{
if (comm_type_str == NULL) {
*comm_type = default_comm_type;
return 0;
} else if (strcasecmp(comm_type_str, "socket") == 0) {
*comm_type = fc_comm_type_sock;
return 0;
} else if (strcasecmp(comm_type_str, "rdma") == 0) {
*comm_type = fc_comm_type_rdma;
return 0;
} else {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"invalid communication: %s!", __LINE__,
config_filename, section_name, comm_type_str);
return EINVAL;
}
}
static int load_comm_type_and_smart_polling(IniFullContext *ini_ctx,
FCCommunicationType *comm_type, FCSmartPollingConfig *smart_polling,
const FCCommunicationType default_comm_type,
const FCSmartPollingConfig *default_smart_polling)
{
int result;
char *comm_type_str;
comm_type_str = iniGetStrValue(ini_ctx->section_name,
"communication", ini_ctx->context);
if (comm_type_str == NULL) {
comm_type_str = iniGetStrValue(ini_ctx->section_name,
"comm_type", ini_ctx->context);
}
if ((result=fc_server_set_comm_type(comm_type, ini_ctx->filename,
ini_ctx->section_name, comm_type_str,
default_comm_type)) != 0)
{
return result;
}
if (*comm_type == fc_comm_type_sock) {
smart_polling->enabled = false;
smart_polling->switch_on_iops = 0;
smart_polling->switch_on_count = 0;
} else {
smart_polling->enabled = iniGetBoolValue(ini_ctx->section_name,
"smart_polling", ini_ctx->context,
default_smart_polling->enabled);
smart_polling->switch_on_iops = iniGetIntValue(ini_ctx->section_name,
"polling_switch_on_iops", ini_ctx->context,
default_smart_polling->switch_on_iops);
smart_polling->switch_on_count = iniGetIntValue(ini_ctx->section_name,
"polling_switch_on_count", ini_ctx->context,
default_smart_polling->switch_on_count);
}
return 0;
}
static inline int load_buffer_size(IniFullContext *ini_ctx,
const int default_buffer_size)
{
int buffer_size;
buffer_size = iniGetByteValue(ini_ctx->section_name, "buffer_size",
ini_ctx->context, default_buffer_size);
return iniCheckAndCorrectIntValue(ini_ctx, "buffer_size",
buffer_size, 8 * 1024, 8 * 1024 * 1024);
}
static int fc_server_load_one_group(FCServerConfig *ctx,
IniFullContext *ini_ctx, const int group_count)
{
int result;
FCServerGroupInfo *group;
char new_name[FAST_INI_ITEM_NAME_SIZE];
char *port_str;
char *net_type;
char *ip_prefix;
strcpy(new_name, ini_ctx->section_name);
group = ctx->group_array.groups + ctx->group_array.count;
fc_server_set_group_ptr_name(group, new_name + GROUP_SECTION_PREFIX_LEN);
if (group->group_name.len == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, no group name!",
__LINE__, ini_ctx->filename, ini_ctx->section_name);
return EINVAL;
}
port_str = iniGetStrValue(ini_ctx->section_name,
SERVER_ITEM_PORT_STR, ini_ctx->context);
if (port_str == NULL) {
if (group_count == 1) {
group->port = ctx->default_port;
} else {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, no item: %s!",
__LINE__, ini_ctx->filename, ini_ctx->section_name,
SERVER_ITEM_PORT_STR);
return ENOENT;
}
} else {
char *endptr = NULL;
group->port = strtol(port_str, &endptr, 10);
if (group->port <= 0 || (endptr != NULL && *endptr != '\0')) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, item: %s, "
"invalid port: %s", __LINE__, ini_ctx->filename,
ini_ctx->section_name, SERVER_ITEM_PORT_STR, port_str);
return EINVAL;
}
}
net_type = iniGetStrValue(ini_ctx->section_name,
"net_type", ini_ctx->context);
group->filter.net_type = fc_get_net_type_by_name(net_type);
if (group->filter.net_type == FC_NET_TYPE_NONE) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, invalid net_type: %s",
__LINE__, ini_ctx->filename, group->group_name.str, net_type);
return EINVAL;
}
ip_prefix = iniGetStrValue(ini_ctx->section_name,
"ip_prefix", ini_ctx->context);
fc_server_set_ip_prefix(group, ip_prefix);
if ((result=load_comm_type_and_smart_polling(ini_ctx,
&group->comm_type, &group->smart_polling,
ctx->comm_type, &ctx->smart_polling)) != 0)
{
return result;
}
if (group->comm_type == fc_comm_type_sock) {
group->buffer_size = 0;
} else {
group->buffer_size = load_buffer_size(ini_ctx, ctx->buffer_size);
}
ctx->group_array.count++;
return 0;
}
static int check_group_ports_duplicate(FCServerConfig *ctx,
const char *config_filename)
{
FCServerGroupInfo *g1;
FCServerGroupInfo *g2;
FCServerGroupInfo *end;
int port1;
int port2;
end = ctx->group_array.groups + ctx->group_array.count;
for (g1=ctx->group_array.groups; g1<end; g1++) {
port1 = FC_SERVER_GROUP_PORT(g1);
for (g2=g1+1; g2<end; g2++) {
port2 = FC_SERVER_GROUP_PORT(g2);
if (port1 == port2) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, the port: %d of group: %.*s "
"is same to group: %.*s", __LINE__, config_filename,
port1, g1->group_name.len, g1->group_name.str,
g2->group_name.len, g2->group_name.str);
return EEXIST;
}
}
}
return 0;
}
static int fc_server_cmp_group_info(const void *p1, const void *p2)
{
return strcmp(((FCServerGroupInfo *)p1)->name_buff,
((FCServerGroupInfo *)p2)->name_buff);
}
static void fc_server_sort_groups(FCServerConfig *ctx)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
if (ctx->group_array.count <= 1) {
return;
}
qsort(ctx->group_array.groups, ctx->group_array.count,
sizeof(FCServerGroupInfo), fc_server_cmp_group_info);
//must reset stirng_t pointer
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
group->group_name.str = group->name_buff;
group->filter.ip_prefix.str = group->filter.prefix_buff;
}
}
static int fc_server_load_groups(FCServerConfig *ctx,
IniFullContext *ini_ctx)
{
int result;
int count;
IniSectionInfo sections[FC_MAX_GROUP_COUNT];
IniSectionInfo *section;
IniSectionInfo *end;
if ((result=iniGetSectionNamesByPrefix(ini_ctx->context,
GROUP_SECTION_PREFIX_STR, sections,
FC_MAX_GROUP_COUNT, &count)) != 0)
{
logError("file: "__FILE__", line: %d, "
"config filename: %s, get sections by prefix %s fail, "
"errno: %d, error info: %s", __LINE__, ini_ctx->filename,
GROUP_SECTION_PREFIX_STR, result, STRERROR(result));
return result;
}
if (count == 0) {
ctx->group_array.count = 1;
memset(ctx->group_array.groups, 0, sizeof(FCServerGroupInfo));
fc_server_set_group_ptr_name(ctx->group_array.groups + 0, "");
ctx->group_array.groups[0].port = iniGetIntValue(NULL, "port",
ini_ctx->context, ctx->default_port);
return 0;
}
end = sections + count;
for (section=sections; section<end; section++) {
ini_ctx->section_name = section->section_name;
if ((result=fc_server_load_one_group(ctx, ini_ctx, count)) != 0) {
return result;
}
}
fc_server_sort_groups(ctx);
return 0;
}
static int fc_server_alloc_servers(FCServerInfoArray *array,
const int target_count)
{
int bytes;
bytes = sizeof(FCServerInfo) * target_count;
array->servers = (FCServerInfo *)fc_malloc(bytes);
if (array->servers == NULL) {
return ENOMEM;
}
memset(array->servers, 0, bytes);
array->alloc = target_count;
return 0;
}
static int fc_server_check_alloc_group_address_ptrs(FCAddressPtrArray *array)
{
int new_alloc;
int bytes;
FCAddressInfo **new_addrs;
if (array->count < array->alloc) {
return 0;
}
new_alloc = array->alloc > 0 ? 2 * array->alloc : 1;
bytes = sizeof(FCAddressInfo *) * new_alloc;
new_addrs = (FCAddressInfo **)fc_malloc(bytes);
if (new_addrs == NULL) {
return ENOMEM;
}
memset(new_addrs, 0, bytes);
if (array->addrs != NULL) {
memcpy(new_addrs, array->addrs, sizeof(FCAddressInfo *) * array->count);
free(array->addrs);
}
array->addrs = new_addrs;
array->alloc = new_alloc;
return 0;
}
static inline void fc_server_clear_server_port(FCServerGroupArray *array)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
end = array->groups + array->count;
for (group=array->groups; group<end; group++) {
group->server_port = 0;
}
}
FCServerGroupInfo *fc_server_get_group_by_name(FCServerConfig *ctx,
const string_t *group_name)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
if (fc_string_equal(&group->group_name, group_name)) {
return group;
}
}
return NULL;
}
static int fc_server_load_group_port(FCServerConfig *ctx,
const char *config_filename, const char *section_name,
const string_t *group_name, IniItem *port_item)
{
FCServerGroupInfo *group;
char *endptr;
if ((group=fc_server_get_group_by_name(ctx, group_name)) == NULL) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, group: %.*s "
"in item: %s not found!", __LINE__, config_filename,
section_name, group_name->len, group_name->str,
port_item->name);
return ENOENT;
}
endptr = NULL;
group->server_port = strtol(port_item->value, &endptr, 10);
if (group->server_port <= 0 || (endptr != NULL && *endptr != '\0')) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, item: %s, "
"invalid port: %s", __LINE__, config_filename,
section_name, port_item->name, port_item->value);
return EINVAL;
}
return 0;
}
static int check_server_addresses_duplicate(FCServerConfig *ctx,
const char *config_filename, const char *section_name,
FCAddressInfo *addresses, const int count)
{
FCAddressInfo *addr1;
FCAddressInfo *addr2;
FCAddressInfo *end;
char port_caption[32];
char port_prompt[16];
if (count <= 1) {
return 0;
}
end = addresses + count;
for (addr1=addresses; addr1<end; addr1++) {
for (addr2=addr1+1; addr2<end; addr2++) {
if (FC_CONNECTION_SERVER_EQUAL1(addr1->conn, addr2->conn)) {
if (addr1->conn.port > 0) {
strcpy(port_caption, " and port");
sprintf(port_prompt, ":%d", addr1->conn.port);
} else {
*port_caption = *port_prompt = '\0';
}
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, duplicate ip%s %s%s",
__LINE__, config_filename, section_name, port_caption,
addr1->conn.ip_addr, port_prompt);
return EEXIST;
}
}
}
return 0;
}
static int check_addresses_duplicate(FCServerConfig *ctx,
const char *config_filename, const char *section_name,
FCGroupAddresses *group_addr)
{
FCAddressInfo **ppaddr;
FCAddressInfo **ppend;
FCAddressInfo **pprevious;
char formatted_ip[FORMATTED_IP_SIZE];
if (group_addr->address_array.count <= 1) {
return 0;
}
qsort(group_addr->address_array.addrs, group_addr->address_array.count,
sizeof(FCAddressInfo *), fc_server_cmp_address_ptr);
pprevious = group_addr->address_array.addrs;
ppend = group_addr->address_array.addrs + group_addr->address_array.count;
for (ppaddr=group_addr->address_array.addrs+1; ppaddr<ppend; ppaddr++) {
if (fc_server_cmp_address_ptr(ppaddr, pprevious) == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, group: %.*s, "
"duplicate ip and port: %s:%u", __LINE__,
config_filename, section_name,
group_addr->server_group->group_name.len,
group_addr->server_group->group_name.str,
format_ip_address((*ppaddr)->conn.ip_addr, formatted_ip),
(*ppaddr)->conn.port);
return EEXIST;
}
pprevious = ppaddr;
}
return 0;
}
static int check_server_group_addresses_duplicate(FCServerConfig *ctx,
FCServerInfo *server, const char *config_filename,
const char *section_name)
{
int result;
FCGroupAddresses *gaddr;
FCGroupAddresses *end;
end = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
if ((result=check_addresses_duplicate(ctx, config_filename,
section_name, gaddr)) != 0)
{
return result;
}
}
return 0;
}
static int check_server_group_min_hosts(FCServerConfig *ctx,
FCServerInfo *server, const char *config_filename,
const char *section_name)
{
FCGroupAddresses *gaddr;
FCGroupAddresses *end;
end = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
if (gaddr->address_array.count < ctx->min_hosts_each_group) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, group: %.*s, "
"host count: %d < %d!", __LINE__, config_filename,
section_name, gaddr->server_group->group_name.len,
gaddr->server_group->group_name.str,
gaddr->address_array.count,
ctx->min_hosts_each_group);
return ENOENT;
}
}
return 0;
}
static bool fc_server_group_match(const FCServerGroupInfo *group,
const FCAddressInfo *addr)
{
int ip_len;
if ((addr->conn.port > 0) && (addr->conn.port !=
FC_SERVER_GROUP_PORT(group)))
{
return false;
}
if ((group->filter.net_type != FC_NET_TYPE_ANY) &&
((addr->net_type & group->filter.net_type) !=
group->filter.net_type))
{
return false;
}
if (group->filter.ip_prefix.len > 0) {
ip_len = strlen(addr->conn.ip_addr);
if (!(ip_len >= group->filter.ip_prefix.len &&
memcmp(addr->conn.ip_addr,
group->filter.ip_prefix.str,
group->filter.ip_prefix.len) == 0))
{
return false;
}
}
return true;
}
static int fc_server_set_address(FCServerConfig *ctx,
FCAddressInfo *addr, const char *config_filename,
const char *section_name, const char *item_name,
const char *host, const int default_port)
{
int result;
if ((result=conn_pool_parse_server_info(host, &addr->conn,
default_port)) != 0)
{
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"item: %s, invalid host: %s", __LINE__,
config_filename, section_name, item_name, host);
return result;
}
addr->net_type = fc_get_net_type_by_ip(addr->conn.ip_addr);
return 0;
}
static int fc_server_set_group_server_address(FCServerInfo *server,
FCGroupAddresses *group_addr, const FCAddressInfo *address)
{
FCAddressInfo *addr;
int result;
addr = fc_server_add_to_uniq_addresses(&server->uniq_addresses, address);
if (addr == NULL) {
return ENOMEM;
}
if ((result=fc_server_check_alloc_group_address_ptrs(
&group_addr->address_array)) != 0)
{
return result;
}
group_addr->address_array.addrs[group_addr->address_array.count++] = addr;
return 0;
}
static int fc_server_load_group_server(FCServerConfig *ctx,
FCServerInfo *server, const char *config_filename,
const char *section_name, const string_t *group_name,
IniItem *host_item)
{
FCServerGroupInfo *group;
FCGroupAddresses *group_addr;
FCAddressInfo address;
int result;
int group_index;
if ((group=fc_server_get_group_by_name(ctx, group_name)) == NULL) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, group: %.*s "
"in item: %s not found!", __LINE__, config_filename,
section_name, group_name->len, group_name->str,
host_item->name);
return ENOENT;
}
group_index = group - ctx->group_array.groups;
group_addr = server->group_addrs + group_index;
if (group_addr->address_array.count >= FC_MAX_SERVER_IP_COUNT) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"too many %s items exceeds %d", __LINE__,
config_filename, section_name,
host_item->name, FC_MAX_SERVER_IP_COUNT);
return ENOSPC;
}
if ((result=fc_server_set_address(ctx, &address, config_filename,
section_name, host_item->name, host_item->value,
FC_SERVER_GROUP_PORT(group))) != 0)
{
return result;
}
address.conn.comm_type = group->comm_type;
if ((result=fc_server_set_group_server_address(server,
group_addr, &address)) != 0)
{
return result;
}
return 0;
}
static int fc_server_set_host(FCServerConfig *ctx, FCServerInfo *server,
const char *config_filename, const char *section_name,
const FCAddressInfo *addr)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
FCGroupAddresses *group_addr;
const FCAddressInfo *new_addr;
FCAddressInfo addr_holder;
char formatted_ip[FORMATTED_IP_SIZE];
int result;
int count;
int group_index;
count = 0;
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
if (fc_server_group_match(group, addr)) {
group_index = group - ctx->group_array.groups;
group_addr = server->group_addrs + group_index;
if (group_addr->address_array.count >= FC_MAX_SERVER_IP_COUNT) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"too many %s items for group %.*s exceeds %d",
__LINE__, config_filename, section_name,
SERVER_ITEM_HOST_STR, group->group_name.len,
group->group_name.str, FC_MAX_SERVER_IP_COUNT);
return ENOSPC;
}
if (addr->conn.port == 0) {
addr_holder = *addr;
addr_holder.conn.port = FC_SERVER_GROUP_PORT(group);
addr_holder.conn.comm_type = group->comm_type;
new_addr = &addr_holder;
} else {
if (addr->conn.comm_type == group->comm_type) {
new_addr = addr;
} else {
addr_holder = *addr;
addr_holder.conn.comm_type = group->comm_type;
new_addr = &addr_holder;
}
}
if ((result=fc_server_set_group_server_address(server,
group_addr, new_addr)) != 0)
{
return result;
}
count++;
}
}
if (count == 0) {
char port_prompt[16];
if (addr->conn.port > 0) {
sprintf(port_prompt, ":%d", addr->conn.port);
} else {
*port_prompt = '\0';
}
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"host %s%s not belong to any group",
__LINE__, config_filename, section_name,
addr->conn.ip_addr, port_prompt);
return ENOENT;
}
if (!ctx->share_between_groups && (count > 1 && addr->conn.port > 0)) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"host %s:%u belongs to %d groups",
__LINE__, config_filename, section_name,
format_ip_address(addr->conn.ip_addr, formatted_ip),
addr->conn.port, count);
return EEXIST;
}
return 0;
}
static int fc_server_set_hosts(FCServerConfig *ctx, FCServerInfo *server,
const char *config_filename, const char *section_name,
char **hosts, const int host_count)
{
int result;
FCAddressInfo addresses[FC_MAX_SERVER_IP_COUNT];
FCAddressInfo *addr;
FCAddressInfo *addr_end;
char **host;
char **hend;
int no_port_count;
no_port_count = 0;
addr = addresses;
hend = hosts + host_count;
for (host=hosts; host<hend; host++) {
if ((result=fc_server_set_address(ctx, addr, config_filename,
section_name, SERVER_ITEM_HOST_STR, *host, 0)) != 0)
{
return result;
}
if (addr->conn.port == 0) {
no_port_count++;
}
addr++;
}
if ((result=check_server_addresses_duplicate(ctx, config_filename,
section_name, addresses, host_count)) != 0)
{
return result;
}
if (no_port_count > 0 && !ctx->share_between_groups) {
if ((result=check_group_ports_duplicate(ctx, config_filename)) != 0) {
return result;
}
}
addr_end = addresses + host_count;
for (addr=addresses; addr<addr_end; addr++) {
if ((result=fc_server_set_host(ctx, server, config_filename,
section_name, addr)) != 0)
{
return result;
}
}
return 0;
}
static int fc_server_load_hosts(FCServerConfig *ctx, FCServerInfo *server,
const char *config_filename, IniContext *ini_context,
const char *section_name)
{
IniItem *items;
IniItem *it;
IniItem *end;
char *hosts[FC_MAX_SERVER_IP_COUNT];
int item_count;
int host_count;
int group_host_count;
int name_len;
int result;
string_t group_name;
items = iniGetSectionItems(section_name, ini_context, &item_count);
if (item_count == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, no items!",
__LINE__, config_filename, section_name);
return EINVAL;
}
fc_server_clear_server_port(&ctx->group_array);
host_count = group_host_count = 0;
end = items + item_count;
for (it=items; it<end; it++) {
name_len = strlen(it->name);
if (name_len > SERVER_ITEM_PORT_AFFIX_LEN &&
memcmp(it->name + name_len - SERVER_ITEM_PORT_AFFIX_LEN,
SERVER_ITEM_PORT_AFFIX_STR, SERVER_ITEM_PORT_AFFIX_LEN) == 0)
{
group_name.str = it->name;
group_name.len = name_len - SERVER_ITEM_PORT_AFFIX_LEN;
if ((result=fc_server_load_group_port(ctx, config_filename,
section_name, &group_name, it)) != 0)
{
return result;
}
} else if (name_len > SERVER_ITEM_HOST_AFFIX_LEN &&
memcmp(it->name + name_len - SERVER_ITEM_HOST_AFFIX_LEN,
SERVER_ITEM_HOST_AFFIX_STR, SERVER_ITEM_HOST_AFFIX_LEN) == 0)
{
group_name.str = it->name;
group_name.len = name_len - SERVER_ITEM_HOST_AFFIX_LEN;
if ((result=fc_server_load_group_server(ctx, server,
config_filename, section_name,
&group_name, it)) != 0)
{
return result;
}
group_host_count++;
} else if (name_len == SERVER_ITEM_HOST_LEN && memcmp(it->name,
SERVER_ITEM_HOST_STR, SERVER_ITEM_HOST_LEN) == 0)
{
if (host_count >= FC_MAX_SERVER_IP_COUNT) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, "
"too many %s items exceeds %d", __LINE__,
config_filename, section_name,
SERVER_ITEM_HOST_STR, FC_MAX_SERVER_IP_COUNT);
return ENOSPC;
}
hosts[host_count++] = it->value;
} else {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, unkown item name: %s",
__LINE__, config_filename, section_name, it->name);
return EINVAL;
}
}
if (host_count == 0 && group_host_count == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, no item: %s or *%s!",
__LINE__, config_filename, section_name,
SERVER_ITEM_HOST_STR, SERVER_ITEM_HOST_AFFIX_STR);
return ENOENT;
}
if (host_count > 0) {
if ((result=fc_server_set_hosts(ctx, server, config_filename,
section_name, hosts, host_count)) != 0)
{
return result;
}
}
if ((result=check_server_group_addresses_duplicate(ctx, server,
config_filename, section_name)) != 0)
{
return result;
}
if (ctx->min_hosts_each_group > 0) {
if ((result=check_server_group_min_hosts(ctx, server,
config_filename, section_name)) != 0)
{
return result;
}
}
return 0;
}
static void fc_server_set_group_ptr(FCServerConfig *ctx, FCServerInfo *server)
{
FCGroupAddresses *gaddr;
FCGroupAddresses *end;
end = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
gaddr->server_group = ctx->group_array.groups + (gaddr -
server->group_addrs);
}
}
static int fc_server_load_one_server(FCServerConfig *ctx,
const char *config_filename, IniContext *ini_context,
const char *section_name)
{
FCServerInfo *server;
char *endptr;
int result;
server = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
endptr = NULL;
server->id = strtol(section_name + SERVER_SECTION_PREFIX_LEN,
&endptr, 10);
if (server->id <= 0 || (endptr != NULL && *endptr != '\0')) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, section: %s, invalid server id! "
"server section format is [%s$id]",
__LINE__, config_filename, section_name,
SERVER_SECTION_PREFIX_STR);
return EINVAL;
}
fc_server_set_group_ptr(ctx, server);
if ((result=fc_server_load_hosts(ctx, server, config_filename,
ini_context, section_name)) != 0)
{
return result;
}
FC_SID_SERVER_COUNT(*ctx)++;
return 0;
}
static int fc_server_load_servers(FCServerConfig *ctx,
const char *config_filename, IniContext *ini_context)
{
#define FIXED_SECTION_COUNT 16
int result;
int section_count;
int server_count;
IniSectionInfo *sections;
IniSectionInfo fixed[FIXED_SECTION_COUNT];
IniSectionInfo *section;
IniSectionInfo *end;
int alloc_bytes;
section_count = iniGetSectionCountByPrefix(ini_context,
SERVER_SECTION_PREFIX_STR);
if (section_count == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, no server section such as [%s$id]",
__LINE__, config_filename, SERVER_SECTION_PREFIX_STR);
return ENOENT;
}
if (section_count < FIXED_SECTION_COUNT) {
sections = fixed;
} else {
alloc_bytes = sizeof(IniSectionInfo) * section_count;
sections = (IniSectionInfo *)fc_malloc(alloc_bytes);
if (sections == NULL) {
return ENOMEM;
}
}
do {
if ((result=iniGetSectionNamesByPrefix(ini_context,
SERVER_SECTION_PREFIX_STR, sections,
section_count, &section_count)) != 0)
{
logError("file: "__FILE__", line: %d, "
"config filename: %s, get sections by prefix %s fail, "
"errno: %d, error info: %s", __LINE__, config_filename,
SERVER_SECTION_PREFIX_STR, result, STRERROR(result));
break;
}
end = sections + section_count;
server_count = 0;
for (section=sections; section<end; section++) {
if (is_digital_string(section->section_name +
SERVER_SECTION_PREFIX_LEN))
{
++server_count;
}
}
if (server_count == 0) {
logError("file: "__FILE__", line: %d, "
"config filename: %s, no server section such as [%s$id]",
__LINE__, config_filename, SERVER_SECTION_PREFIX_STR);
return ENOENT;
}
if ((result=fc_server_alloc_servers(&ctx->sorted_server_arrays.
by_id, server_count)) != 0)
{
return result;
}
for (section=sections; section<end; section++) {
if (!is_digital_string(section->section_name +
SERVER_SECTION_PREFIX_LEN))
{
continue;
}
if ((result=fc_server_load_one_server(ctx, config_filename,
ini_context, section->section_name)) != 0)
{
break;
}
}
} while (0);
if (sections != fixed) {
free(sections);
}
return result;
}
static void load_connection_thread_local(FCServerConfig *ctx,
IniContext *ini_context, const char *config_filename)
{
char *connection_thread_local;
connection_thread_local = iniGetStrValue(NULL,
"connection_thread_local", ini_context);
if (connection_thread_local == NULL || *connection_thread_local == '\0') {
ctx->connection_thread_local = fc_connection_thread_local_auto;
} else if (strcasecmp(connection_thread_local, "auto") == 0) {
ctx->connection_thread_local = fc_connection_thread_local_auto;
} else if (strcasecmp(connection_thread_local, "yes") == 0) {
ctx->connection_thread_local = fc_connection_thread_local_yes;
} else if (strcasecmp(connection_thread_local, "no") == 0) {
ctx->connection_thread_local = fc_connection_thread_local_no;
} else {
logWarning("file: "__FILE__", line: %d, "
"config file: %s, invalid connection_thread_local: %s, "
"set to auto!", __LINE__, config_filename,
connection_thread_local);
ctx->connection_thread_local = fc_connection_thread_local_auto;
}
}
static int fc_server_load_data(FCServerConfig *ctx,
IniContext *ini_context, const char *config_filename)
{
int result;
bool have_rdma;
IniFullContext full_ini_ctx;
FCSmartPollingConfig default_smart_polling;
FCServerGroupInfo *group;
FCServerGroupInfo *end;
FAST_INI_SET_FULL_CTX_EX(full_ini_ctx,
config_filename, NULL, ini_context);
default_smart_polling.enabled = true;
default_smart_polling.switch_on_iops = 10240;
default_smart_polling.switch_on_count = 3;
if ((result=load_comm_type_and_smart_polling(&full_ini_ctx,
&ctx->comm_type, &ctx->smart_polling,
fc_comm_type_sock, &default_smart_polling)) != 0)
{
return result;
}
ctx->buffer_size = load_buffer_size(&full_ini_ctx, 256 * 1024);
if ((result=fc_server_load_groups(ctx, &full_ini_ctx)) != 0) {
return result;
}
have_rdma = false;
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
if (group->comm_type != fc_comm_type_sock) {
have_rdma = true;
break;
}
}
if (!have_rdma) {
ctx->buffer_size = 0;
}
load_connection_thread_local(ctx, ini_context, config_filename);
if ((result=fc_server_load_servers(ctx, config_filename,
ini_context)) != 0)
{
return result;
}
qsort(FC_SID_SERVERS(*ctx), FC_SID_SERVER_COUNT(*ctx),
sizeof(FCServerInfo), fc_server_cmp_server_id);
if ((result=fc_server_check_id_duplicated(ctx, config_filename)) != 0) {
return result;
}
if ((result=fc_server_init_ip_port_array(ctx)) != 0) {
return result;
}
return fc_server_check_ip_port(ctx, config_filename);
}
#define FC_SERVER_INIT_CONTEXT(ctx, port, min_hosts, shared) \
do { \
memset(ctx, 0, sizeof(FCServerConfig)); \
ctx->default_port = port; \
ctx->min_hosts_each_group = min_hosts; \
ctx->share_between_groups = shared; \
} while (0)
int fc_server_load_from_file_ex(FCServerConfig *ctx,
const char *config_filename, const int default_port,
const int min_hosts_each_group, const bool share_between_groups)
{
IniContext ini_context;
int result;
FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
share_between_groups);
if ((result=iniLoadFromFile1(config_filename, &ini_context,
FAST_INI_FLAGS_DISABLE_SAME_SECTION_MERGE)) != 0)
{
return result;
}
result = fc_server_load_data(ctx, &ini_context, config_filename);
iniFreeContext(&ini_context);
return result;
}
int fc_server_load_from_buffer_ex(FCServerConfig *ctx, char *content,
const char *caption, const int default_port,
const int min_hosts_each_group, const bool share_between_groups)
{
IniContext ini_context;
int result;
FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
share_between_groups);
if ((result=iniLoadFromBuffer1(content, &ini_context,
FAST_INI_FLAGS_DISABLE_SAME_SECTION_MERGE)) != 0)
{
return result;
}
result = fc_server_load_data(ctx, &ini_context, caption);
iniFreeContext(&ini_context);
return result;
}
int fc_server_load_from_ini_context_ex(FCServerConfig *ctx,
IniContext *ini_context, const char *config_filename,
const int default_port, const int min_hosts_each_group,
const bool share_between_groups)
{
FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
share_between_groups);
return fc_server_load_data(ctx, ini_context, config_filename);
}
static void fc_server_free_addresses(FCServerConfig *ctx)
{
FCServerInfo *server;
FCServerInfo *send;
FCGroupAddresses *gaddr;
FCGroupAddresses *gend;
send = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
for (server=FC_SID_SERVERS(*ctx); server<send; server++) {
gend = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<gend; gaddr++) {
if (gaddr->address_array.addrs != NULL) {
free(gaddr->address_array.addrs);
gaddr->address_array.addrs = NULL;
gaddr->address_array.count = gaddr->address_array.alloc = 0;
}
}
if (server->uniq_addresses.addrs != NULL) {
free(server->uniq_addresses.addrs);
server->uniq_addresses.addrs = NULL;
server->uniq_addresses.count = server->uniq_addresses.alloc = 0;
}
}
}
void fc_server_destroy(FCServerConfig *ctx)
{
if (IP_PORT_MAPS(ctx) != NULL) {
free(IP_PORT_MAPS(ctx));
IP_PORT_MAPS(ctx) = NULL;
IP_PORT_MAP_COUNT(ctx) = 0;
}
if (FC_SID_SERVERS(*ctx) != NULL) {
fc_server_free_addresses(ctx);
free(FC_SID_SERVERS(*ctx));
FC_SID_SERVERS(*ctx) = NULL;
FC_SID_SERVER_COUNT(*ctx) = 0;
}
}
static FCServerGroupInfo *address_uniq_match_group(FCServerConfig *ctx,
const FCAddressInfo *addr)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
FCServerGroupInfo *matched;
matched = NULL;
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
if (fc_server_group_match(group, addr)) {
if (matched != NULL) {
return NULL;
} else {
matched = group;
}
}
}
return matched;
}
static int fc_groups_to_string(FCServerConfig *ctx, FastBuffer *buffer)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
const char *net_type_caption;
int result;
if ((result=fast_buffer_check(buffer, FC_MAX_GROUP_COUNT * 256)) != 0) {
return result;
}
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
net_type_caption = get_net_type_caption(group->filter.net_type);
if (strcmp(net_type_caption, NET_TYPE_ANY_STR) == 0) {
net_type_caption = "";
}
fast_buffer_append(buffer,
"[%s%.*s]\n"
"port = %d\n",
GROUP_SECTION_PREFIX_STR,
group->group_name.len, group->group_name.str,
group->port);
if (group->comm_type != fc_comm_type_sock) {
fast_buffer_append(buffer,
"communication = %s\n"
"smart_polling = %d\n"
"polling_switch_on_iops = %d\n"
"polling_switch_on_count = %d\n",
fc_comm_type_str(group->comm_type),
group->smart_polling.enabled,
group->smart_polling.switch_on_iops,
group->smart_polling.switch_on_count);
if (group->buffer_size != ctx->buffer_size) {
fast_buffer_append(buffer, "buffer_size = %d KB\n",
group->buffer_size / 1024);
}
}
fast_buffer_append(buffer,
"net_type = %s\n"
"ip_prefix = %.*s\n\n",
net_type_caption, group->filter.ip_prefix.len,
group->filter.ip_prefix.str);
}
return 0;
}
static void fc_group_servers_to_string(FCServerConfig *ctx,
FCGroupAddresses *gaddr, FastBuffer *buffer)
{
FCAddressInfo **addr;
FCAddressInfo **end;
char formatted_ip[FORMATTED_IP_SIZE];
end = gaddr->address_array.addrs + gaddr->address_array.count;
for (addr=gaddr->address_array.addrs; addr<end; addr++) {
if (address_uniq_match_group(ctx, *addr) == gaddr->server_group) {
fast_buffer_append_buff(buffer, SERVER_ITEM_HOST_STR,
SERVER_ITEM_HOST_LEN);
} else {
fast_buffer_append(buffer, "%.*s%s",
gaddr->server_group->group_name.len,
gaddr->server_group->group_name.str,
SERVER_ITEM_HOST_AFFIX_STR);
}
fast_buffer_append(buffer, " = %s:%u\n",
format_ip_address((*addr)->conn.ip_addr, formatted_ip),
(*addr)->conn.port);
}
}
static int fc_one_server_to_string(FCServerConfig *ctx,
FCServerInfo *server, FastBuffer *buffer)
{
FCGroupAddresses *gaddr;
FCGroupAddresses *end;
int bytes;
int result;
bytes = 32;
end = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
bytes += (IP_ADDRESS_SIZE + 128) * gaddr->address_array.count;
}
if ((result=fast_buffer_check(buffer, bytes)) != 0) {
return result;
}
fast_buffer_append(buffer, "[%s%d]\n",
SERVER_SECTION_PREFIX_STR, server->id);
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
fc_group_servers_to_string(ctx, gaddr, buffer);
}
fast_buffer_append_buff(buffer, "\n", 1);
return 0;
}
static int fc_servers_to_string(FCServerConfig *ctx, FastBuffer *buffer)
{
FCServerInfo *server;
FCServerInfo *end;
int result;
end = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
for (server=FC_SID_SERVERS(*ctx); server<end; server++) {
if ((result=fc_one_server_to_string(ctx, server, buffer)) != 0) {
return result;
}
}
return 0;
}
int fc_server_to_config_string(FCServerConfig *ctx, FastBuffer *buffer)
{
int result;
if (ctx->buffer_size > 0) {
if ((result=fast_buffer_check(buffer, 1024)) != 0) {
return result;
}
fast_buffer_append(buffer, "buffer_size = %d KB\n",
ctx->buffer_size / 1024);
}
fc_server_clear_server_port(&ctx->group_array);
if ((result=fc_groups_to_string(ctx, buffer)) != 0) {
return result;
}
return fc_servers_to_string(ctx, buffer);
}
static void fc_server_log_groups(FCServerConfig *ctx)
{
FCServerGroupInfo *group;
FCServerGroupInfo *end;
char buff[1024];
char *p;
end = ctx->group_array.groups + ctx->group_array.count;
for (group=ctx->group_array.groups; group<end; group++) {
p = buff + sprintf(buff, "group_name: %.*s, port: %d",
group->group_name.len, group->group_name.str,
group->port);
if (group->comm_type != fc_comm_type_sock) {
p += sprintf(p, ", communication: %s, smart_polling: %d, "
"polling_switch_on_iops: %d, polling_switch_on_count: %d",
fc_comm_type_str(group->comm_type),
group->smart_polling.enabled,
group->smart_polling.switch_on_iops,
group->smart_polling.switch_on_count);
if (group->buffer_size != ctx->buffer_size) {
p += sprintf(p, ", buffer_size = %d KB",
group->buffer_size / 1024);
}
}
p += sprintf(p, ", net_type: %s, ip_prefix: %.*s",
get_net_type_caption(group->filter.net_type),
group->filter.ip_prefix.len, group->filter.ip_prefix.str);
log_it1(LOG_INFO, buff, p - buff);
}
}
static void fc_server_log_group_servers(FCGroupAddresses *gaddr)
{
FCAddressInfo **addr;
FCAddressInfo **end;
char formatted_ip[FORMATTED_IP_SIZE];
end = gaddr->address_array.addrs + gaddr->address_array.count;
for (addr=gaddr->address_array.addrs; addr<end; addr++) {
logInfo(" %d. %s:%u", (int)(addr - gaddr->address_array.addrs + 1),
format_ip_address((*addr)->conn.ip_addr, formatted_ip),
(*addr)->conn.port);
}
}
static void fc_server_log_one_server(FCServerConfig *ctx, FCServerInfo *server)
{
FCGroupAddresses *gaddr;
FCGroupAddresses *end;
logInfo("server id: %d", server->id);
end = server->group_addrs + ctx->group_array.count;
for (gaddr=server->group_addrs; gaddr<end; gaddr++) {
logInfo("[group-%.*s] ip count: %d", FC_PRINTF_STAR_STRING_PARAMS(
gaddr->server_group->group_name),
gaddr->address_array.count);
fc_server_log_group_servers(gaddr);
}
logInfo(" ");
}
static void fc_server_log_servers(FCServerConfig *ctx)
{
FCServerInfo *server;
FCServerInfo *end;
logInfo("server count: %d, unique ip and port count: %d",
FC_SID_SERVER_COUNT(*ctx),
IP_PORT_MAP_COUNT(ctx));
end = FC_SID_SERVERS(*ctx) + FC_SID_SERVER_COUNT(*ctx);
for (server=FC_SID_SERVERS(*ctx); server<end; server++) {
fc_server_log_one_server(ctx, server);
}
}
void fc_server_to_log(FCServerConfig *ctx)
{
char buff[256];
char *p;
p = buff + sprintf(buff, "connection_thread_local: %s",
fc_connection_thread_local_str(ctx->connection_thread_local));
if (ctx->buffer_size > 0) {
p += sprintf(p, ", buffer_size: %d KB", ctx->buffer_size / 1024);
}
log_it1(LOG_INFO, buff, p - buff);
fc_server_log_groups(ctx);
fc_server_log_servers(ctx);
}
int fc_server_make_connection_ex(FCAddressPtrArray *addr_array,
ConnectionInfo *conn, const char *service_name,
const int connect_timeout, const char *bind_ipaddr,
const bool log_connect_error)
{
FCAddressInfo **current;
FCAddressInfo **addr;
FCAddressInfo **end;
int result;
if (addr_array->count <= 0) {
return ENOENT;
}
current = addr_array->addrs + addr_array->index;
conn_pool_set_server_info(conn, (*current)->conn.ip_addr,
(*current)->conn.port);
conn->comm_type = (*current)->conn.comm_type;
if ((result=G_COMMON_CONNECTION_CALLBACKS[conn->comm_type].
make_connection(conn, service_name, connect_timeout * 1000,
bind_ipaddr, log_connect_error)) == 0)
{
return 0;
}
if (addr_array->count == 1) {
return result;
}
end = addr_array->addrs + addr_array->count;
for (addr=addr_array->addrs; addr<end; addr++) {
if (addr == current) {
continue;
}
conn_pool_set_server_info(conn, (*addr)->conn.ip_addr,
(*addr)->conn.port);
conn->comm_type = (*addr)->conn.comm_type;
if ((result=G_COMMON_CONNECTION_CALLBACKS[conn->comm_type].
make_connection(conn, service_name, connect_timeout * 1000,
bind_ipaddr, log_connect_error)) == 0)
{
addr_array->index = addr - addr_array->addrs;
return 0;
}
}
return result;
}
const FCAddressInfo *fc_server_get_address_by_peer(
FCAddressPtrArray *addr_array, const char *peer_ip)
{
FCAddressInfo **addr;
FCAddressInfo **end;
int net_type;
if (addr_array->count == 1) {
return *(addr_array->addrs);
}
if (addr_array->count == 0) {
return NULL;
}
net_type = fc_get_net_type_by_ip(peer_ip);
end = addr_array->addrs + addr_array->count;
for (addr=addr_array->addrs; addr<end; addr++) {
if ((*addr)->net_type == net_type) {
return *addr;
}
}
return *(addr_array->addrs);
}
struct ibv_pd *fc_alloc_rdma_pd(fc_alloc_pd_callback alloc_pd,
FCAddressPtrArray *address_array, int *result)
{
char *ip_addrs[FC_MAX_SERVER_IP_COUNT];
char **ip_addr;
FCAddressInfo **addr;
FCAddressInfo **end;
struct ibv_pd *pd;
int port;
if (address_array->count == 0) {
port = 0;
} else {
port = address_array->addrs[0]->conn.port;
}
end = address_array->addrs + address_array->count;
for (addr=address_array->addrs, ip_addr=ip_addrs;
addr<end; addr++, ip_addr++)
{
*ip_addr = (*addr)->conn.ip_addr;
}
if ((pd=alloc_pd((const char **)ip_addrs, address_array->
count, port)) != NULL)
{
*result = 0;
} else {
*result = ENODEV;
}
return pd;
}
Reference in New Issue View Git Blame Copy Permalink