// 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
}