void replication_options::read_meta_servers()
{
// read meta_servers from machine list file
meta_servers.clear();
const char* server_ss[10];
int capacity = 10, need_count;
need_count = dsn_config_get_all_keys("replication.meta_servers", server_ss, &capacity);
dassert(need_count <= capacity, "too many meta servers specified");
std::ostringstream oss;
for (int i = 0; i < capacity; i++)
{
std::string s(server_ss[i]);
// name:port
auto pos1 = s.find_first_of(':');
if (pos1 != std::string::npos)
{
::dsn::rpc_address ep(s.substr(0, pos1).c_str(), atoi(s.substr(pos1 + 1).c_str()));
meta_servers.push_back(ep);
oss << "[" << ep.to_string() << "] ";
}
}
ddebug("read meta servers from config: %s", oss.str().c_str());
}
void replica_helper::load_meta_servers(
/*out*/ std::vector<dsn::rpc_address>& servers,
const char* section)
{
// read meta_servers from machine list file
servers.clear();
const char* server_ss[10];
int capacity = 10, need_count;
need_count = dsn_config_get_all_keys(section, server_ss, &capacity);
dassert(need_count <= capacity, "too many meta servers specified in config [%s]", section);
for (int i = 0; i < capacity; i++)
{
std::string s(server_ss[i]);
// name:port
auto pos1 = s.find_first_of(':');
if (pos1 != std::string::npos)
{
::dsn::rpc_address ep(s.substr(0, pos1).c_str(), atoi(s.substr(pos1 + 1).c_str()));
servers.push_back(ep);
}
}
dassert(servers.size() > 0, "no meta server specified in config [%s]", section);
}
static bool build_client_network_confs(
const char* section,
/*out*/ network_client_configs& nss,
network_client_configs* default_spec)
{
nss.clear();
const char* keys[128];
int kcapacity = 128;
int kcount = dsn_config_get_all_keys(section, keys, &kcapacity);
dassert(kcount <= 128, "");
for (int i = 0; i < kcapacity; i++)
{
std::string k = keys[i];
if (k.length() <= strlen("network.client."))
continue;
if (k.substr(0, strlen("network.client.")) != std::string("network.client."))
continue;
auto k2 = k.substr(strlen("network.client."));
if (rpc_channel::is_exist(k2.c_str()))
{
/*
;channel = network_provider_name,buffer_block_size
network.client.RPC_CHANNEL_TCP = dsn::tools::asio_network_provider,65536
network.client.RPC_CHANNEL_UDP = dsn::tools::asio_network_provider,65536
*/
rpc_channel ch = rpc_channel::from_string(k2.c_str(), RPC_CHANNEL_TCP);
// dsn::tools::asio_network_provider,65536
std::list<std::string> vs;
std::string v = dsn_config_get_value_string(section, k.c_str(), "",
"network channel configuration, e.g., dsn::tools::asio_network_provider,65536");
utils::split_args(v.c_str(), vs, ',');
if (vs.size() != 2)
{
printf("invalid client network specification '%s', should be '$network-factory,$msg-buffer-size'\n",
v.c_str()
);
return false;
}
network_client_config ns;
ns.factory_name = vs.begin()->c_str();
ns.message_buffer_block_size = atoi(vs.rbegin()->c_str());
if (ns.message_buffer_block_size == 0)
{
printf("invalid message buffer size specified: '%s'\n", vs.rbegin()->c_str());
return false;
}
nss[ch] = ns;
}
else
{
printf("invalid rpc channel type: %s\n", k2.c_str());
return false;
}
}
if (default_spec)
{
for (auto& kv : *default_spec)
{
if (nss.find(kv.first) == nss.end())
{
nss[kv.first] = kv.second;
}
}
}
return true;
}
error_code deploy_svc_service_impl::start()
{
std::string pdir = utils::filesystem::path_combine(dsn_get_current_app_data_dir(), "services");
_service_dir = dsn_config_get_value_string("deploy.service",
"deploy_dir",
pdir.c_str(),
"where to put temporal deployment resources"
);
// load clusters
const char* clusters[100];
int sz = 100;
int count = dsn_config_get_all_keys("deploy.service.clusters", clusters, &sz);
dassert(count <= 100, "too many clusters");
for (int i = 0; i < count; i++)
{
std::string cluster_name = dsn_config_get_value_string(
clusters[i],
"name",
"",
"cluster name"
);
if (nullptr != get_cluster(cluster_name))
{
derror("cluster %s already defined", cluster_name.c_str());
return ERR_CLUSTER_ALREADY_EXIST;
}
std::string cluster_factory_type = dsn_config_get_value_string(
clusters[i],
"factory",
"",
"factory name to create the target cluster scheduler"
);
auto cluster = ::dsn::utils::factory_store<cluster_scheduler>::create(
cluster_factory_type.c_str(),
PROVIDER_TYPE_MAIN
);
if (nullptr == cluster)
{
derror("cluster type %s is not defined", cluster_factory_type.c_str());
return ERR_OBJECT_NOT_FOUND;
}
std::shared_ptr<cluster_ex> ce(new cluster_ex);
ce->scheduler.reset(cluster);
ce->cluster.name = cluster_name;
ce->cluster.type = cluster->type();
_clusters[cluster_name] = ce;
}
_cli_deploy = dsn_cli_app_register(
"deploy",
"deploy deploy_request(in json format)",
"deploy an app via our deployment service",
(void*)this,
[](void *context, int argc, const char **argv, dsn_cli_reply *reply)
{
auto this_ = (deploy_svc_service_impl*)context;
this_->on_deploy_cli(context, argc, argv, reply);
},
__svc_cli_freeer__
);
_cli_undeploy = dsn_cli_app_register(
"undeploy",
"undeploy service_name(in json format)",
"undeploy an app via our deployment service",
(void*)this,
[](void *context, int argc, const char **argv, dsn_cli_reply *reply)
{
auto this_ = (deploy_svc_service_impl*)context;
this_->on_undeploy_cli(context, argc, argv, reply);
},
__svc_cli_freeer__
);
_cli_get_service_list = dsn_cli_app_register(
"service_list",
"service_list package_id(in json format)",
"get service list of a package via our deployment service",
(void*)this,
[](void *context, int argc, const char **argv, dsn_cli_reply *reply)
{
auto this_ = (deploy_svc_service_impl*)context;
this_->on_get_service_list_cli(context, argc, argv, reply);
},
__svc_cli_freeer__
);
_cli_get_service_info = dsn_cli_app_register(
"service_info",
"service_info service_name(in json format)",
"get service info of a service via our deployment service",
(void*)this,
[](void *context, int argc, const char **argv, dsn_cli_reply *reply)
{
auto this_ = (deploy_svc_service_impl*)context;
this_->on_get_service_info_cli(context, argc, argv, reply);
},
__svc_cli_freeer__
);
_cli_get_cluster_list = dsn_cli_app_register(
"cluster_list",
"cluster_list format(in json format)",
"get cluster list with a specific format via our deployment service",
(void*)this,
[](void *context, int argc, const char **argv, dsn_cli_reply *reply)
{
auto this_ = (deploy_svc_service_impl*)context;
this_->on_get_cluster_list_cli(context, argc, argv, reply);
},
__svc_cli_freeer__
);
return ERR_OK;
}
static bool build_server_network_confs(
const char* section,
/*out*/ network_server_configs& nss,
network_server_configs* default_spec,
const std::vector<int>& ports,
bool is_template)
{
nss.clear();
const char* keys[128];
int kcapacity = 128;
int kcount = dsn_config_get_all_keys(section, keys, &kcapacity);
dassert(kcount <= 128, "");
for (int i = 0; i < kcapacity; i++)
{
std::string k = keys[i];
if (k.length() <= strlen("network.server."))
continue;
if (k.substr(0, strlen("network.server.")) != std::string("network.server."))
continue;
auto k2 = k.substr(strlen("network.server."));
std::list<std::string> ks;
utils::split_args(k2.c_str(), ks, '.');
if (ks.size() != 2)
{
printf("invalid network server config '%s', should be like 'network.server.12345.RPC_CHANNEL_TCP' instead\n", k.c_str());
return false;
}
int port = atoi(ks.begin()->c_str());
auto k3 = *ks.rbegin();
if (is_template)
{
if (port != 0)
{
printf("invalid network server configuration '%s'\n", k.c_str());
printf("port must be zero in [apps..default]\n");
printf(" e.g., network.server.0.RPC_CHANNEL_TCP = NET_HDR_DSN, dsn::tools::asio_network_provider,65536\n");
return false;
}
}
else
{
if (std::find(ports.begin(), ports.end(), port) == ports.end())
{
continue;
}
}
if (rpc_channel::is_exist(k3.c_str()))
{
/*
port = 0 for default setting in [apps..default]
port.channel = header_format, network_provider_name,buffer_block_size
network.server.port().RPC_CHANNEL_TCP = NET_HDR_DSN, dsn::tools::asio_network_provider,65536
network.server.port().RPC_CHANNEL_UDP = NET_HDR_DSN, dsn::tools::asio_network_provider,65536
*/
rpc_channel ch = rpc_channel::from_string(k3.c_str(), RPC_CHANNEL_TCP);
network_server_config ns(port, ch);
// NET_HDR_DSN, dsn::tools::asio_network_provider,65536
std::list<std::string> vs;
std::string v = dsn_config_get_value_string(section, k.c_str(), "",
"network channel configuration, e.g., NET_HDR_DSN, dsn::tools::asio_network_provider,65536");
utils::split_args(v.c_str(), vs, ',');
if (vs.size() != 3)
{
printf("invalid network specification '%s', should be '$message-format, $network-factory,$msg-buffer-size'\n",
v.c_str()
);
return false;
}
if (!network_header_format::is_exist(vs.begin()->c_str()))
{
printf("invalid network specification, unkown message header format '%s'\n",
vs.begin()->c_str()
);
return false;
}
ns.hdr_format = network_header_format(vs.begin()->c_str());
ns.factory_name = *(++vs.begin());
ns.message_buffer_block_size = atoi(vs.rbegin()->c_str());
if (ns.message_buffer_block_size == 0)
{
printf("invalid message buffer size specified: '%s'\n", vs.rbegin()->c_str());
return false;
}
nss[ns] = ns;
}
else
{
printf("invalid rpc channel type: %s\n", k3.c_str());
return false;
}
}
if (default_spec)
{
for (auto& kv : *default_spec)
{
network_server_config cs = kv.second;
for (auto& port : ports)
{
cs.port = port;
if (nss.find(cs) == nss.end())
{
nss[cs] = cs;
}
}
if (is_template)
{
cs.port = 0;
if (nss.find(cs) == nss.end())
{
nss[cs] = cs;
}
}
}
}
return true;
}
