func mergeDefaultOptions(opts *Options) *Options {
def := defaultOptions()
if opts == nil {
return def
}
opts.SuspicionTimeout = util.SelectDuration(opts.SuspicionTimeout,
def.SuspicionTimeout)
opts.MinProtocolPeriod = util.SelectDuration(opts.MinProtocolPeriod,
def.MinProtocolPeriod)
opts.RollupMaxUpdates = util.SelectInt(opts.RollupMaxUpdates,
def.RollupMaxUpdates)
opts.RollupFlushInterval = util.SelectDuration(opts.RollupFlushInterval,
def.RollupFlushInterval)
opts.JoinTimeout = util.SelectDuration(opts.JoinTimeout, def.JoinTimeout)
opts.PingTimeout = util.SelectDuration(opts.PingTimeout, def.PingTimeout)
opts.PingRequestTimeout = util.SelectDuration(opts.PingRequestTimeout,
def.PingRequestTimeout)
opts.PingRequestSize = util.SelectInt(opts.PingRequestSize,
def.PingRequestSize)
if opts.Clock == nil {
opts.Clock = def.Clock
}
return opts
}
func mergeDefaultOptions(opts *Options, def *Options) *Options {
if opts == nil {
return def
}
var merged Options
merged.NValue = util.SelectInt(opts.NValue, def.NValue)
merged.RValue = util.SelectInt(opts.RValue, def.RValue)
merged.WValue = util.SelectInt(opts.WValue, def.WValue)
merged.FanoutMode = selectFanoutMode(opts.FanoutMode)
return &merged
}
// newJoinSender returns a new JoinSender to join a cluster with
func newJoinSender(node *Node, opts *joinOpts) (*joinSender, error) {
if opts == nil {
opts = &joinOpts{}
}
if opts.discoverProvider == nil {
return nil, errors.New("missing host provider in join options")
}
// Resolve/retrieve bootstrap hosts from the provider specified in the
// join options.
bootstrapHosts, err := opts.discoverProvider.Hosts()
if err != nil {
return nil, err
}
if len(bootstrapHosts) == 0 {
return nil, errors.New("bootstrap hosts cannot be empty")
}
js := &joinSender{
node: node,
logger: logging.Logger("join").WithField("local", node.Address()),
}
// Parse bootstrap hosts into a map
js.parseHosts(bootstrapHosts)
js.potentialNodes = js.CollectPotentialNodes(nil)
js.timeout = util.SelectDuration(opts.timeout, defaultJoinTimeout)
js.maxJoinDuration = util.SelectDuration(opts.maxJoinDuration, defaultMaxJoinDuration)
js.parallelismFactor = util.SelectInt(opts.parallelismFactor, defaultParallelismFactor)
js.size = util.SelectInt(opts.size, defaultJoinSize)
js.size = util.Min(js.size, len(js.potentialNodes))
js.delayer = opts.delayer
if js.delayer == nil {
// Create and use exponential delayer as the delay mechanism. Create it
// with nil opts which uses default delayOpts.
js.delayer, err = newExponentialDelayer(js.node.address, nil)
if err != nil {
return nil, err
}
}
return js, nil
}
func (f *Forwarder) mergeDefaultOptions(opts *Options) *Options {
def := f.defaultOptions()
if opts == nil {
return def
}
var merged Options
merged.MaxRetries = util.SelectInt(opts.MaxRetries, def.MaxRetries)
merged.Timeout = util.SelectDuration(opts.Timeout, def.Timeout)
merged.RerouteRetries = opts.RerouteRetries
merged.RetrySchedule = opts.RetrySchedule
if opts.RetrySchedule == nil {
merged.RetrySchedule = def.RetrySchedule
}
return &merged
}