// ReloadOptions parses the config options and initializes the Bee.
540661
func (mod *AnelPowerCtrlBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	options.Bind("address", &mod.addr)
	options.Bind("user", &mod.user)
	options.Bind("password", &mod.password)
}
607375
func (remote *RemoteDebugger) Reload() error {
	_, err := remote.SendRequest("Page.reload", Params{
		"ignoreCache": true,
	})

	return err
}
438127
func (fs *FSObjects) ReloadFormat(ctx context.Context, dryRun bool) error {
	logger.LogIf(ctx, NotImplemented{})
	return NotImplemented{}
}
632692
func (s *Server) Reload(config *ddaemon.Config) {
	debugEnabled := utils.IsDebugEnabled()
	switch {
	case debugEnabled && !config.Debug: // disable debug
		utils.DisableDebug()
		s.routerSwapper.Swap(s.createMux())
	case config.Debug && !debugEnabled: // enable debug
		utils.EnableDebug()
		s.routerSwapper.Swap(s.createMux())
	}
}
227525
func (mod *IrcBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	options.Bind("address", &mod.server)
	options.Bind("nick", &mod.nick)
	options.Bind("password", &mod.password)
	options.Bind("ssl", &mod.ssl)
	options.Bind("channels", &mod.channels)

	mod.ContextSet("channels", &mod.channels)
}
711159
func (r *Router) HandleOPTIONS(newValue bool) (oldValue bool) {
	r.initRouter()
	oldValue = r.router.HandleOPTIONS
	r.router.HandleOPTIONS = newValue
	return
}
893067
func Reload(configFile string, flags *pflag.FlagSet, reload func(*Config)) error {
	logrus.Infof("Got signal to reload configuration, reloading from: %s", configFile)
	newConfig, err := getConflictFreeConfiguration(configFile, flags)
	if err != nil {
		if flags.Changed("config-file") || !os.IsNotExist(err) {
			return errors.Wrapf(err, "unable to configure the Docker daemon with file %s", configFile)
		}
		newConfig = New()
	}

	if err := Validate(newConfig); err != nil {
		return errors.Wrap(err, "file configuration validation failed")
	}

	// Check if duplicate label-keys with different values are found
	newLabels, err := GetConflictFreeLabels(newConfig.Labels)
	if err != nil {
		return err
	}
	newConfig.Labels = newLabels

	reload(newConfig)
	return nil
}
1298582
func (p *Phosphor) reloadConfig() error {
	c := p.configProvider.Config()

	// Skip reloading if the config is the same
	h := fmt.Sprintf("%x", deephash.Hash(c))
	if p.compareConfigHash(h) {
		return nil
	}

	// keep reference to the old channel so we can drain this in parallel with
	// new traces the transport receives
	oldChan := p.traceChan

	// init new channel for traces, ensure this *isn't* zero
	bufLen := c.BufferSize
	if bufLen == 0 {
		bufLen = defaultTraceBufferSize
	}
	newChan := make(chan []byte, bufLen)

	// Get a new transport and keep a reference to the old one
	p.trMtx.Lock()
	defer p.trMtx.Unlock()
	oldTr := p.tr
	endpoint := fmt.Sprintf("%s:%v", c.Host, c.Port)
	newTr := newUDPTransport(endpoint)

	// start new transport by passing both channels to this
	// therefore it starts consuming from the new one (with nothing)
	// and also the old one (still current) in parallel to the previous transport
	// If this somehow fails, abort until next attempt
	if err := newTr.Consume(oldChan, newChan); err != nil {
		newTr.Stop()
		return err
	}

	// swap the client reference of the trace channel from old to new, so
	// new clients start using the new resized channel
	// TODO atomically swap this
	p.traceChan = newChan

	// gracefully shut down old transport, so just the new one is running
	if oldTr != nil {
		if err := oldTr.Stop(); err != nil {
			return err
		}
	}

	// set the config hash & swap the transport as we're finished
	p.updateConfigHash(h)
	p.tr = newTr

	return nil
}
648978
func (mod *TelegramBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	apiKey := getAPIKey(&options)
	mod.apiKey = apiKey
}
324540
func (mod *HueBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	options.Bind("address", &mod.bridge)
	options.Bind("key", &mod.key)

	mod.client = hue.NewBridge(mod.bridge, mod.key)
}
1341335
func (mod *SpaceAPIBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	options.Bind("url", &mod.url)
}
1229241
func (mod *CronBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)

	options.Bind("second", &mod.input[0])
	options.Bind("minute", &mod.input[1])
	options.Bind("hour", &mod.input[2])
	options.Bind("day_of_week", &mod.input[3])
	options.Bind("day_of_month", &mod.input[4])
	options.Bind("month", &mod.input[5])
}
817497
func (r *Pod) Reload() (*Pod, error) {
	return r.collection.Get(r.Metadata.Name)
}
200392
func LoadOptions(ops Options) {
	options = ops

	// Check option boundaries
	if options.ESStartupTimeout < minTimeout {
		log.WithFields(logrus.Fields{
			"mintimeout": minTimeout,
		}).Debug("Overriding Elastic startup timeout")
		options.ESStartupTimeout = minTimeout
	}

	if options.ZKReconnectStartDelay < 1 {
		log.WithFields(logrus.Fields{
			"reconnectstartdelay": options.ZKReconnectStartDelay,
		}).Debug("ZK_RECONNECT_START_DELAY too low; Resetting to 1 second")
		options.ZKReconnectStartDelay = 1
	}
	if options.ZKReconnectMaxDelay < 1 {
		log.WithFields(logrus.Fields{
			"reconnectmaxdelay": options.ZKReconnectMaxDelay,
		}).Debug("ZK_RECONNECT_MAX_DELAY too low; Resetting to 1 second")
		options.ZKReconnectMaxDelay = 1
	}
	if options.ZKReconnectStartDelay > options.ZKReconnectMaxDelay {
		log.WithFields(logrus.Fields{
			"reconnectstartdelay": options.ZKReconnectStartDelay,
			"reconnectmaxdelay":   options.ZKReconnectMaxDelay,
		}).Debug("ZK_RECONNECT_START_DELAY too large; Resetting to ZK_RECONNECT_MAX_DELAY")
		options.ZKReconnectStartDelay = options.ZKReconnectMaxDelay
	}
}
863169
func (r *Event) Reload() (*Event, error) {
	return r.collection.Get(r.Metadata.Name)
}
597227
func (mod *CricketBee) ReloadOptions(options bees.BeeOptions) {
	mod.SetOptions(options)
	options.Bind("favourite_team", &mod.favTeam)
}
406135
func DefaultOptions() *Options {
	return &Options{
		Retry: func() retry.Iterator {
			return &retry.ExponentialBackoff{
				Limited: retry.Limited{
					Delay:   time.Second,
					Retries: 5,
				},
			}
		},
	}
}