external-dns/controller/controller.go
Martin Linkhorst 99371a1e83 implementation of basic control loop (#40)
* feat(google): add ability to apply changes generated from a plan

* feat(controller): first implementation of controller

* feat: allow to configure in-cluster and kubeconfig

* fix(controller): call RunOnce at the right time and in a loop

* feat(google): add dryRun attribute to Google DNS provider

* fix: use hosted zone id instead of DNS name

* fix(google): stupidly filter by A records for now

* feat: allow specifying the google project and zone

* feat: provide a dry-run flag which defaults to false

* chore: vendor new dependencies

* fix(config): fix failing tests for config object

* ref(controller): return plain value of ApplyChanges

* ref: simplify how to get a valid kubernetes client
2017-03-01 16:17:47 +01:00

80 lines
2.0 KiB
Go

/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package controller
import (
"time"
log "github.com/Sirupsen/logrus"
"github.com/kubernetes-incubator/external-dns/dnsprovider"
"github.com/kubernetes-incubator/external-dns/plan"
"github.com/kubernetes-incubator/external-dns/source"
)
// Controller is responsible for orchestrating the different components.
// It works in the following way:
// * Ask the DNS provider for current list of endpoints.
// * Ask the Source for the desired list of endpoints.
// * Take both lists and calculate a Plan to move current towards desired state.
// * Tell the DNS provider to apply the changes calucated by the Plan.
type Controller struct {
Zone string
Source source.Source
DNSProvider dnsprovider.DNSProvider
}
// RunOnce runs a single iteration of a reconciliation loop.
func (c *Controller) RunOnce() error {
records, err := c.DNSProvider.Records(c.Zone)
if err != nil {
return err
}
endpoints, err := c.Source.Endpoints()
if err != nil {
return err
}
plan := &plan.Plan{
Current: records,
Desired: endpoints,
}
plan = plan.Calculate()
return c.DNSProvider.ApplyChanges(c.Zone, &plan.Changes)
}
// Run runs RunOnce in a loop with a delay until stopChan receives a value.
func (c *Controller) Run(stopChan <-chan struct{}) {
for {
err := c.RunOnce()
if err != nil {
log.Fatal(err)
}
select {
case <-time.After(time.Minute):
case <-stopChan:
log.Infoln("terminating main controller loop")
return
}
}
}