Golang Context.IsTrusted方法代码示例

// ConfigStatus returns status information about this Seesaw's current configuration.
func (s *SeesawEngine) ConfigStatus(ctx *ipc.Context, reply *seesaw.ConfigStatus) error {
	s.trace("ConfigStatus", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	s.engine.clusterLock.RLock()
	cluster := s.engine.cluster
	s.engine.clusterLock.RUnlock()

	if cluster == nil {
		return errors.New("no cluster configuration loaded")
	}

	cs := cluster.Status

	reply.LastUpdate = cs.LastUpdate
	reply.Attributes = make([]seesaw.ConfigMetadata, 0, len(cs.Attributes))
	for _, a := range cs.Attributes {
		reply.Attributes = append(reply.Attributes, a)
	}
	reply.Warnings = make([]string, 0, len(cs.Warnings))
	for _, warning := range cs.Warnings {
		reply.Warnings = append(reply.Warnings, warning)
	}
	return nil
}

// ClusterStatus returns status information about this Seesaw Cluster.
func (s *SeesawEngine) ClusterStatus(ctx *ipc.Context, reply *seesaw.ClusterStatus) error {
	s.trace("ClusterStatus", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	s.engine.clusterLock.RLock()
	cluster := s.engine.cluster
	s.engine.clusterLock.RUnlock()

	if cluster == nil {
		return errors.New("no cluster configuration loaded")
	}

	reply.Version = seesaw.SeesawVersion
	reply.Site = cluster.Site
	reply.Nodes = make([]*seesaw.Node, 0, len(cluster.Nodes))
	for _, node := range cluster.Nodes {
		reply.Nodes = append(reply.Nodes, node.Clone())
	}
	return nil
}

// Failover requests the Seesaw Engine to relinquish master state.
func (s *SeesawEngine) Failover(ctx *ipc.Context, reply *int) error {
	s.trace("Failover", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	return s.engine.haManager.requestFailover(false)
}

// ConfigReload requests a configuration reload.
func (s *SeesawEngine) ConfigReload(ctx *ipc.Context, reply *int) error {
	s.trace("ConfigReload", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	return s.engine.notifier.Reload()
}

// Backends returns a list of currently configured Backends.
func (s *SeesawEngine) Backends(ctx *ipc.Context, reply *int) error {
	s.trace("Backends", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	// TODO(jsing): Implement this function.
	return fmt.Errorf("Unimplemented")
}

// HAStatus returns the current HA status from the Seesaw Engine.
func (s *SeesawEngine) HAStatus(ctx *ipc.Context, status *seesaw.HAStatus) error {
	s.trace("HAStatus", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	if status != nil {
		*status = s.engine.haStatus()
	}
	return nil
}

// Healthchecks returns a list of currently configured healthchecks that
// should be performed by the Seesaw Healthcheck component.
func (s *SeesawEngine) Healthchecks(ctx *ipc.Context, reply *healthcheck.Checks) error {
	s.trace("Healthchecks", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	configs := s.engine.hcManager.configs()
	if reply != nil {
		reply.Configs = configs
	}
	return nil
}

// BGPNeighbors returns a list of the BGP neighbors that we are peering with.
func (s *SeesawEngine) BGPNeighbors(ctx *ipc.Context, reply *quagga.Neighbors) error {
	s.trace("BGPNeighbors", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	if reply == nil {
		return fmt.Errorf("Neighbors is nil")
	}
	s.engine.bgpManager.lock.RLock()
	reply.Neighbors = s.engine.bgpManager.neighbors
	s.engine.bgpManager.lock.RUnlock()
	return nil
}

// HAConfig returns the high-availability configuration for this node as
// determined by the engine.
func (s *SeesawEngine) HAConfig(ctx *ipc.Context, reply *seesaw.HAConfig) error {
	s.trace("HAConfig", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	c, err := s.engine.haConfig()
	if err != nil {
		return err
	}
	if reply != nil {
		reply.Copy(c)
	}
	return nil
}

// Vservers returns a list of currently configured vservers.
func (s *SeesawEngine) Vservers(ctx *ipc.Context, reply *seesaw.VserverMap) error {
	s.trace("Vservers", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	if reply == nil {
		return fmt.Errorf("VserverMap is nil")
	}
	reply.Vservers = make(map[string]*seesaw.Vserver)
	s.engine.vserverLock.RLock()
	for name := range s.engine.vserverSnapshots {
		reply.Vservers[name] = s.engine.vserverSnapshots[name]
	}
	s.engine.vserverLock.RUnlock()
	return nil
}

// VLANs returns a list of VLANs configured for this cluster.
func (s *SeesawEngine) VLANs(ctx *ipc.Context, reply *seesaw.VLANs) error {
	s.trace("VLANs", ctx)
	if ctx == nil {
		return errors.New("context is nil")
	}

	if !ctx.IsTrusted() {
		return errors.New("insufficient access")
	}

	if reply == nil {
		return errors.New("VLANs is nil")
	}
	reply.VLANs = make([]*seesaw.VLAN, 0)
	s.engine.vlanLock.RLock()
	for _, vlan := range s.engine.vlans {
		reply.VLANs = append(reply.VLANs, vlan)
	}
	s.engine.vlanLock.RUnlock()
	return nil
}