void
galera::Certification::register_params(gu::Config& cnf)
{
cnf.add(CERT_PARAM_LOG_CONFLICTS, CERT_PARAM_LOG_CONFLICTS_DEFAULT);
/* The defaults below are deliberately not reflected in conf: people
* should not know about these dangerous setting unless they read RTFM. */
cnf.add(CERT_PARAM_MAX_LENGTH);
cnf.add(CERT_PARAM_LENGTH_CHECK);
}
gcomm::AsioProtonet::AsioProtonet(gu::Config& conf, int version)
:
gcomm::Protonet(conf, "asio", version),
mutex_(),
poll_until_(gu::datetime::Date::max()),
io_service_(),
timer_(io_service_),
#ifdef HAVE_ASIO_SSL_HPP
ssl_context_(io_service_, asio::ssl::context::sslv23),
#endif // HAVE_ASIO_SSL_HPP
mtu_(1 << 15),
checksum_(NetHeader::checksum_type(
conf.get<int>(gcomm::Conf::SocketChecksum,
NetHeader::CS_CRC32C)))
{
conf.set(gcomm::Conf::SocketChecksum, checksum_);
#ifdef HAVE_ASIO_SSL_HPP
// use ssl if either private key or cert file is specified
bool use_ssl(conf_.is_set(gu::conf::ssl_key) == true ||
conf_.is_set(gu::conf::ssl_cert) == true);
try
{
// overrides use_ssl if set explicitly
use_ssl = conf_.get<bool>(gu::conf::use_ssl);
}
catch (gu::NotSet& nf) {}
if (use_ssl == true)
{
conf_.set(gu::conf::use_ssl, true);
log_info << "initializing ssl context";
gu::ssl_prepare_context(conf_, ssl_context_);
}
#endif // HAVE_ASIO_SSL_HPP
}
/* a function to get around unset defaults in ctor initialization list */
static int
length_check(const gu::Config& conf)
{
if (conf.is_set(CERT_PARAM_LENGTH_CHECK))
return conf.get<int>(CERT_PARAM_LENGTH_CHECK);
else
return gu::Config::from_config<int>(CERT_PARAM_LENGTH_CHECK_DEFAULT);
}
/* a function to get around unset defaults in ctor initialization list */
static int
max_length(const gu::Config& conf)
{
if (conf.is_set(CERT_PARAM_MAX_LENGTH))
return conf.get<int>(CERT_PARAM_MAX_LENGTH);
else
return gu::Config::from_config<int>(CERT_PARAM_MAX_LENGTH_DEFAULT);
}
Proto(gu::Config& conf,
const UUID& uuid,
SegmentId segment,
const gu::URI& uri = gu::URI("pc://"),
View* rst_view = NULL)
:
Protolay(conf),
my_uuid_ (uuid),
start_prim_ (),
npvo_ (param<bool>(conf, uri, Conf::PcNpvo, Defaults::PcNpvo)),
ignore_quorum_ (param<bool>(conf, uri, Conf::PcIgnoreQuorum,
Defaults::PcIgnoreQuorum)),
ignore_sb_ (param<bool>(conf, uri, Conf::PcIgnoreSb,
gu::to_string(ignore_quorum_))),
closing_ (false),
state_ (S_CLOSED),
last_sent_seq_ (0),
checksum_ (param<bool>(conf, uri, Conf::PcChecksum,
Defaults::PcChecksum)),
instances_ (),
self_i_ (instances_.insert_unique(std::make_pair(uuid, Node()))),
state_msgs_ (),
current_view_ (0, V_NONE),
pc_view_ (0, V_NON_PRIM),
views_ (),
mtu_ (std::numeric_limits<int32_t>::max()),
weight_ (check_range(Conf::PcWeight,
param<int>(conf, uri, Conf::PcWeight,
Defaults::PcWeight),
0, 0xff)),
rst_view_ ()
{
set_weight(weight_);
NodeMap::value(self_i_).set_segment(segment);
if (rst_view) {
set_restored_view(rst_view);
}
conf.set(Conf::PcNpvo, gu::to_string(npvo_));
conf.set(Conf::PcIgnoreQuorum, gu::to_string(ignore_quorum_));
conf.set(Conf::PcIgnoreSb, gu::to_string(ignore_sb_));
conf.set(Conf::PcChecksum, gu::to_string(checksum_));
conf.set(Conf::PcWeight, gu::to_string(weight_));
}
galera::ReplicatorSMM::InitConfig::InitConfig(gu::Config& conf,
const char* const node_address)
{
Replicator::register_params(conf);
std::map<std::string, std::string>::const_iterator i;
for (i = defaults.map_.begin(); i != defaults.map_.end(); ++i)
{
if (i->second.empty())
conf.add(i->first);
else
conf.add(i->first, i->second);
}
// what is would be a better protection?
int const pv(gu::from_string<int>(conf.get(Param::proto_max)));
if (pv > MAX_PROTO_VER)
{
log_warn << "Can't set '" << Param::proto_max << "' to " << pv
<< ": maximum supported value is " << MAX_PROTO_VER;
conf.add(Param::proto_max, gu::to_string(MAX_PROTO_VER));
}
conf.add(COMMON_BASE_HOST_KEY);
conf.add(COMMON_BASE_PORT_KEY);
if (node_address && strlen(node_address) > 0)
{
gu::URI na(node_address, false);
try
{
std::string const host = na.get_host();
if (host == "0.0.0.0" || host == "0:0:0:0:0:0:0:0" || host == "::")
{
gu_throw_error(EINVAL) << "Bad value for 'node_address': '"
<< host << '\'';
}
conf.set(BASE_HOST_KEY, host);
}
catch (gu::NotSet& e) {}
try
{
conf.set(BASE_PORT_KEY, na.get_port());
}
catch (gu::NotSet& e) {}
}
/* register variables and defaults from other modules */
gcache::GCache::register_params(conf);
gcs_register_params(reinterpret_cast<gu_config_t*>(&conf));
Certification::register_params(conf);
ist::register_params(conf);
}
gcache::GCache::Params::Params (gu::Config& cfg, const std::string& data_dir)
throw (gu::Exception)
:
rb_name (name_value (cfg, data_dir)),
dir_name (cfg.get(GCACHE_PARAMS_DIR)),
mem_size (size_value (cfg,
GCACHE_PARAMS_MEM_SIZE, GCACHE_DEFAULT_MEM_SIZE)),
rb_size (size_value (cfg,
GCACHE_PARAMS_RB_SIZE, GCACHE_DEFAULT_RB_SIZE)),
page_size (size_value (cfg,
GCACHE_PARAMS_PAGE_SIZE, GCACHE_DEFAULT_PAGE_SIZE)),
keep_pages_size (size_value (cfg, GCACHE_PARAMS_KEEP_PAGES_SIZE,
GCACHE_DEFAULT_KEEP_PAGES_SIZE))
{}
int main(int argc, char* argv[])
{
if (argc != 4)
{
std::cerr << "usage: " << argv[0] << " <-s|-c> <conf> <uri>"
<< std::endl;
return 1;
}
gu::Config conf;
gcomm::Conf::register_params(conf);
conf.parse(argv[2]);
std::auto_ptr<gcomm::Protonet> pnet(gcomm::Protonet::create(conf));
if (std::string("-s") == argv[1])
{
Server server(*pnet, argv[3]);
server.listen();
while (true)
{
pnet->event_loop(gu::datetime::Period(1 * gu::datetime::Sec));
}
}
else if (std::string("-c") == argv[1])
{
Client client(*pnet, argv[3]);
client.connect();
while (true)
{
pnet->event_loop(gu::datetime::Period(1*gu::datetime::MSec));
std::string msg(client.msg());
if (msg != "")
{
std::cout << "read message from server: '" << msg << "'" << std::endl;
break;
}
}
}
return 0;
}
static std::string
IST_determine_recv_addr (gu::Config& conf)
{
std::string recv_addr;
try
{
recv_addr = conf.get(galera::ist::Receiver::RECV_ADDR);
}
catch (gu::NotFound&)
{
try
{
recv_addr = conf.get(galera::BASE_HOST_KEY);
}
catch (gu::NotSet&)
{
gu_throw_error(EINVAL)
<< "Could not determine IST receinve address: '"
<< galera::ist::Receiver::RECV_ADDR << "' not set.";
}
}
/* check if explicit scheme is present */
if (recv_addr.find("://") == std::string::npos)
{
bool ssl(false);
try
{
std::string ssl_key = conf.get(CONF_SSL_KEY);
if (ssl_key.length() != 0) ssl = true;
}
catch (gu::NotFound&) {}
if (ssl)
recv_addr.insert(0, "ssl://");
else
recv_addr.insert(0, "tcp://");
}
gu::URI ra_uri(recv_addr);
if (!conf.has(galera::BASE_HOST_KEY))
conf.set(galera::BASE_HOST_KEY, ra_uri.get_host());
try /* check for explicit port,
TODO: make it possible to use any free port (explicit 0?) */
{
ra_uri.get_port();
}
catch (gu::NotSet&) /* use gmcast listen port + 1 */
{
int port(0);
try
{
port = gu::from_string<uint16_t>(
// gu::URI(conf.get("gmcast.listen_addr")).get_port()
conf.get(galera::BASE_PORT_KEY)
);
}
catch (...)
{
port = gu::from_string<uint16_t>(galera::BASE_PORT_DEFAULT);
}
port += 1;
recv_addr += ":" + gu::to_string(port);
}
return recv_addr;
}
galera::ReplicatorSMM::ParseOptions::ParseOptions(gu::Config& conf,
const char* const opts)
{
conf.parse(opts);
}
