mirror of https://github.com/k3s-io/k3s
Mike Danese
commit
6129d3d4eb
|
|
@ -0,0 +1,8 @@
|
||||||
|
FROM busybox
|
||||||
|
MAINTAINER Muhammed Uluyol "uluyol@google.com"
|
||||||
|
|
||||||
|
ADD dc /diurnal
|
||||||
|
|
||||||
|
RUN chown root:users /diurnal && chmod 755 /diurnal
|
||||||
|
|
||||||
|
ENTRYPOINT ["/diurnal"]
|
||||||
|
|
@ -0,0 +1,24 @@
|
||||||
|
.PHONY: build push vet test clean
|
||||||
|
|
||||||
|
TAG = 0.5
|
||||||
|
REPO = uluyol/kube-diurnal
|
||||||
|
|
||||||
|
BIN = dc
|
||||||
|
|
||||||
|
dc: dc.go time.go
|
||||||
|
CGO_ENABLED=0 godep go build -a -installsuffix cgo -o dc dc.go time.go
|
||||||
|
|
||||||
|
vet:
|
||||||
|
godep go vet .
|
||||||
|
|
||||||
|
test:
|
||||||
|
godep go test .
|
||||||
|
|
||||||
|
build: $(BIN)
|
||||||
|
docker build -t $(REPO):$(TAG) .
|
||||||
|
|
||||||
|
push:
|
||||||
|
docker push $(REPO):$(TAG)
|
||||||
|
|
||||||
|
clean:
|
||||||
|
rm -f $(BIN)
|
||||||
|
|
@ -0,0 +1,44 @@
|
||||||
|
## Diurnal Controller
|
||||||
|
This controller manipulates the number of replicas maintained by a replication controller throughout the day based on a provided list of times of day (according to ISO 8601) and replica counts. It should be run under a replication controller that is in the same namespace as the replication controller that it is manipulating.
|
||||||
|
|
||||||
|
For example, to set the replica counts of the pods with the labels "tier=backend,track=canary" to 10 at noon UTC and 6 at midnight UTC, we can use `-labels tier=backend,track=canary -times 00:00Z,12:00Z -counts 6,10`. An example replication controller config can be found [here](example-diurnal-controller.yaml).
|
||||||
|
|
||||||
|
Instead of providing replica counts and times of day directly, you may use a script like the one below to generate them using mathematical functions.
|
||||||
|
|
||||||
|
```python
|
||||||
|
from math import *
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
def _day_to_2pi(t):
|
||||||
|
return float(t) * 2 * pi / (24*3600)
|
||||||
|
|
||||||
|
def main(args):
|
||||||
|
if len(args) < 3:
|
||||||
|
print "Usage: %s sample_interval func" % (args[0],)
|
||||||
|
print "func should be a function of the variable t, where t will range from 0"
|
||||||
|
print "to 2pi over the course of the day"
|
||||||
|
sys.exit(1)
|
||||||
|
sampling_interval = int(args[1])
|
||||||
|
exec "def f(t): return " + args[2]
|
||||||
|
i = 0
|
||||||
|
times = []
|
||||||
|
counts = []
|
||||||
|
while i < 24*60*60:
|
||||||
|
hours = i / 3600
|
||||||
|
left = i - hours*3600
|
||||||
|
min = left / 60
|
||||||
|
sec = left - min*60
|
||||||
|
times.append("%dh%dm%ds" % (hours, min, sec))
|
||||||
|
count = int(round(f(_day_to_2pi(i))))
|
||||||
|
counts.append(str(count))
|
||||||
|
i += sampling_interval
|
||||||
|
print "-times %s -counts %s" % (",".join(times), ",".join(counts))
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main(sys.argv)
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
[]()
|
||||||
|
|
@ -0,0 +1,283 @@
|
||||||
|
/*
|
||||||
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
||||||
|
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
// An external diurnal controller for kubernetes. With this, it's possible to manage
|
||||||
|
// known replica counts that vary throughout the day.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"flag"
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
"os/signal"
|
||||||
|
"sort"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"syscall"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
kclient "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
|
||||||
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
|
||||||
|
|
||||||
|
"github.com/golang/glog"
|
||||||
|
)
|
||||||
|
|
||||||
|
const dayPeriod = 24 * time.Hour
|
||||||
|
|
||||||
|
type timeCount struct {
|
||||||
|
time time.Duration
|
||||||
|
count int
|
||||||
|
}
|
||||||
|
|
||||||
|
func (tc timeCount) String() string {
|
||||||
|
h := tc.time / time.Hour
|
||||||
|
m := (tc.time % time.Hour) / time.Minute
|
||||||
|
s := (tc.time % time.Minute) / time.Second
|
||||||
|
if m == 0 && s == 0 {
|
||||||
|
return fmt.Sprintf("(%02dZ, %d)", h, tc.count)
|
||||||
|
} else if s == 0 {
|
||||||
|
return fmt.Sprintf("(%02d:%02dZ, %d)", h, m, tc.count)
|
||||||
|
}
|
||||||
|
return fmt.Sprintf("(%02d:%02d:%02dZ, %d)", h, m, s, tc.count)
|
||||||
|
}
|
||||||
|
|
||||||
|
type byTime []timeCount
|
||||||
|
|
||||||
|
func (tc byTime) Len() int { return len(tc) }
|
||||||
|
func (tc byTime) Swap(i, j int) { tc[i], tc[j] = tc[j], tc[i] }
|
||||||
|
func (tc byTime) Less(i, j int) bool { return tc[i].time < tc[j].time }
|
||||||
|
|
||||||
|
func timeMustParse(layout, s string) time.Time {
|
||||||
|
t, err := time.Parse(layout, s)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
return t
|
||||||
|
}
|
||||||
|
|
||||||
|
// first argument is a format string equivalent to HHMMSS. See time.Parse for details.
|
||||||
|
var epoch = timeMustParse("150405", "000000")
|
||||||
|
|
||||||
|
func parseTimeRelative(s string) (time.Duration, error) {
|
||||||
|
t, err := parseTimeISO8601(s)
|
||||||
|
if err != nil {
|
||||||
|
return 0, fmt.Errorf("unable to parse %s: %v", s, err)
|
||||||
|
}
|
||||||
|
return (t.Sub(epoch) + dayPeriod) % dayPeriod, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseTimeCounts(times string, counts string) ([]timeCount, error) {
|
||||||
|
ts := strings.Split(times, ",")
|
||||||
|
cs := strings.Split(counts, ",")
|
||||||
|
if len(ts) != len(cs) {
|
||||||
|
return nil, fmt.Errorf("provided %d times but %d replica counts", len(ts), len(cs))
|
||||||
|
}
|
||||||
|
var tc []timeCount
|
||||||
|
for i := range ts {
|
||||||
|
t, err := parseTimeRelative(ts[i])
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
c, err := strconv.ParseInt(cs[i], 10, 64)
|
||||||
|
if c < 0 {
|
||||||
|
return nil, errors.New("counts must be non-negative")
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
tc = append(tc, timeCount{t, int(c)})
|
||||||
|
}
|
||||||
|
sort.Sort(byTime(tc))
|
||||||
|
return tc, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type Scaler struct {
|
||||||
|
timeCounts []timeCount
|
||||||
|
selector labels.Selector
|
||||||
|
start time.Time
|
||||||
|
pos int
|
||||||
|
done chan struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
var posError = errors.New("could not find position")
|
||||||
|
|
||||||
|
func findPos(tc []timeCount, cur int, offset time.Duration) int {
|
||||||
|
first := true
|
||||||
|
for i := cur; i != cur || first; i = (i + 1) % len(tc) {
|
||||||
|
if tc[i].time > offset {
|
||||||
|
return i
|
||||||
|
}
|
||||||
|
first = false
|
||||||
|
}
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) setCount(c int) {
|
||||||
|
glog.Infof("scaling to %d replicas", c)
|
||||||
|
rcList, err := client.ReplicationControllers(namespace).List(s.selector)
|
||||||
|
if err != nil {
|
||||||
|
glog.Errorf("could not get replication controllers: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
for _, rc := range rcList.Items {
|
||||||
|
rc.Spec.Replicas = c
|
||||||
|
if _, err = client.ReplicationControllers(namespace).Update(&rc); err != nil {
|
||||||
|
glog.Errorf("unable to scale replication controller: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) timeOffset() time.Duration {
|
||||||
|
return time.Since(s.start) % dayPeriod
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) curpos(offset time.Duration) int {
|
||||||
|
return findPos(s.timeCounts, s.pos, offset)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) scale() {
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-s.done:
|
||||||
|
return
|
||||||
|
default:
|
||||||
|
offset := s.timeOffset()
|
||||||
|
s.pos = s.curpos(offset)
|
||||||
|
if s.timeCounts[s.pos].time < offset {
|
||||||
|
time.Sleep(dayPeriod - offset)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
time.Sleep(s.timeCounts[s.pos].time - offset)
|
||||||
|
s.setCount(s.timeCounts[s.pos].count)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) Start() error {
|
||||||
|
now := time.Now().UTC()
|
||||||
|
s.start = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
||||||
|
if *startNow {
|
||||||
|
s.start = now
|
||||||
|
}
|
||||||
|
|
||||||
|
// set initial count
|
||||||
|
pos := s.curpos(s.timeOffset())
|
||||||
|
// add the len to avoid getting a negative index
|
||||||
|
pos = (pos - 1 + len(s.timeCounts)) % len(s.timeCounts)
|
||||||
|
s.setCount(s.timeCounts[pos].count)
|
||||||
|
|
||||||
|
s.done = make(chan struct{})
|
||||||
|
go s.scale()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func safeclose(c chan<- struct{}) (err error) {
|
||||||
|
defer func() {
|
||||||
|
if e := recover(); e != nil {
|
||||||
|
err = e.(error)
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
close(c)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Scaler) Stop() error {
|
||||||
|
if err := safeclose(s.done); err != nil {
|
||||||
|
return errors.New("already stopped scaling")
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
var (
|
||||||
|
counts = flag.String("counts", "", "replica counts, must have at least one (csv)")
|
||||||
|
times = flag.String("times", "", "times to set replica counts relative to UTC following ISO 8601 (csv)")
|
||||||
|
userLabels = flag.String("labels", "", "replication controller labels, syntax should follow https://godoc.org/github.com/GoogleCloudPlatform/kubernetes/pkg/labels#Parse")
|
||||||
|
startNow = flag.Bool("now", false, "times are relative to now not 0:00 UTC (for demos)")
|
||||||
|
local = flag.Bool("local", false, "set to true if running on local machine not within cluster")
|
||||||
|
localPort = flag.Int("localport", 8001, "port that kubectl proxy is running on (local must be true)")
|
||||||
|
|
||||||
|
namespace string = os.Getenv("POD_NAMESPACE")
|
||||||
|
|
||||||
|
client *kclient.Client
|
||||||
|
)
|
||||||
|
|
||||||
|
const usageNotes = `
|
||||||
|
counts and times must both be set and be of equal length. Example usage:
|
||||||
|
diurnal -labels name=redis-slave -times 00:00:00Z,06:00:00Z -counts 3,9
|
||||||
|
diurnal -labels name=redis-slave -times 0600-0500,0900-0500,1700-0500,2200-0500 -counts 15,20,13,6
|
||||||
|
`
|
||||||
|
|
||||||
|
func usage() {
|
||||||
|
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
|
||||||
|
flag.PrintDefaults()
|
||||||
|
fmt.Fprint(os.Stderr, usageNotes)
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
flag.Usage = usage
|
||||||
|
flag.Parse()
|
||||||
|
|
||||||
|
var (
|
||||||
|
cfg *kclient.Config
|
||||||
|
err error
|
||||||
|
)
|
||||||
|
if *local {
|
||||||
|
cfg = &kclient.Config{Host: fmt.Sprintf("http://localhost:%d", *localPort)}
|
||||||
|
} else {
|
||||||
|
cfg, err = kclient.InClusterConfig()
|
||||||
|
if err != nil {
|
||||||
|
glog.Errorf("failed to load config: %v", err)
|
||||||
|
flag.Usage()
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
client, err = kclient.New(cfg)
|
||||||
|
|
||||||
|
selector, err := labels.Parse(*userLabels)
|
||||||
|
if err != nil {
|
||||||
|
glog.Fatal(err)
|
||||||
|
}
|
||||||
|
tc, err := parseTimeCounts(*times, *counts)
|
||||||
|
if err != nil {
|
||||||
|
glog.Fatal(err)
|
||||||
|
}
|
||||||
|
if namespace == "" {
|
||||||
|
glog.Fatal("POD_NAMESPACE is not set. Set to the namespace of the replication controller if running locally.")
|
||||||
|
}
|
||||||
|
scaler := Scaler{timeCounts: tc, selector: selector}
|
||||||
|
if err != nil {
|
||||||
|
glog.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
sigChan := make(chan os.Signal, 1)
|
||||||
|
signal.Notify(sigChan,
|
||||||
|
syscall.SIGHUP,
|
||||||
|
syscall.SIGINT,
|
||||||
|
syscall.SIGQUIT,
|
||||||
|
syscall.SIGTERM)
|
||||||
|
|
||||||
|
glog.Info("starting scaling")
|
||||||
|
if err := scaler.Start(); err != nil {
|
||||||
|
glog.Fatal(err)
|
||||||
|
}
|
||||||
|
<-sigChan
|
||||||
|
glog.Info("stopping scaling")
|
||||||
|
if err := scaler.Stop(); err != nil {
|
||||||
|
glog.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,100 @@
|
||||||
|
/*
|
||||||
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
||||||
|
|
||||||
|
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 main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
func equalsTimeCounts(a, b []timeCount) bool {
|
||||||
|
if len(a) != len(b) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
for i := range a {
|
||||||
|
if a[i].time != b[i].time || a[i].count != b[i].count {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseTimeCounts(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
times string
|
||||||
|
counts string
|
||||||
|
out []timeCount
|
||||||
|
err bool
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
"00:00:01Z,00:02Z,03:00Z,04:00Z", "1,4,1,8", []timeCount{
|
||||||
|
{time.Second, 1},
|
||||||
|
{2 * time.Minute, 4},
|
||||||
|
{3 * time.Hour, 1},
|
||||||
|
{4 * time.Hour, 8},
|
||||||
|
}, false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"00:01Z,00:02Z,00:05Z,00:03Z", "1,2,3,4", []timeCount{
|
||||||
|
{1 * time.Minute, 1},
|
||||||
|
{2 * time.Minute, 2},
|
||||||
|
{3 * time.Minute, 4},
|
||||||
|
{5 * time.Minute, 3},
|
||||||
|
}, false,
|
||||||
|
},
|
||||||
|
{"00:00Z,00:01Z", "1,0", []timeCount{{0, 1}, {1 * time.Minute, 0}}, false},
|
||||||
|
{"00:00+00,00:01+00:00,01:00Z", "0,-1,0", nil, true},
|
||||||
|
{"-00:01Z,01:00Z", "0,1", nil, true},
|
||||||
|
{"00:00Z", "1,2,3", nil, true},
|
||||||
|
}
|
||||||
|
for i, test := range cases {
|
||||||
|
out, err := parseTimeCounts(test.times, test.counts)
|
||||||
|
if test.err && err == nil {
|
||||||
|
t.Errorf("case %d: expected error", i)
|
||||||
|
} else if !test.err && err != nil {
|
||||||
|
t.Errorf("case %d: unexpected error: %v", i, err)
|
||||||
|
}
|
||||||
|
if !test.err {
|
||||||
|
if !equalsTimeCounts(test.out, out) {
|
||||||
|
t.Errorf("case %d: expected timeCounts: %v got %v", i, test.out, out)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestFindPos(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
tc []timeCount
|
||||||
|
cur int
|
||||||
|
offset time.Duration
|
||||||
|
expected int
|
||||||
|
}{
|
||||||
|
{[]timeCount{{0, 1}, {4, 0}}, 1, 1, 1},
|
||||||
|
{[]timeCount{{0, 1}, {4, 0}}, 0, 1, 1},
|
||||||
|
{[]timeCount{{0, 1}, {4, 0}}, 1, 70, 0},
|
||||||
|
{[]timeCount{{5, 1}, {100, 9000}, {4000, 2}, {10000, 4}}, 0, 0, 0},
|
||||||
|
{[]timeCount{{5, 1}, {100, 9000}, {4000, 2}, {10000, 4}}, 1, 5000, 3},
|
||||||
|
{[]timeCount{{5, 1}, {100, 9000}, {4000, 2}, {10000, 4}}, 2, 10000000, 0},
|
||||||
|
{[]timeCount{{5, 1}, {100, 9000}, {4000, 2}, {10000, 4}}, 0, 50, 1},
|
||||||
|
}
|
||||||
|
for i, test := range cases {
|
||||||
|
pos := findPos(test.tc, test.cur, test.offset)
|
||||||
|
if pos != test.expected {
|
||||||
|
t.Errorf("case %d: expected %d got %d", i, test.expected, pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,27 @@
|
||||||
|
apiVersion: v1
|
||||||
|
kind: ReplicationController
|
||||||
|
metadata:
|
||||||
|
labels:
|
||||||
|
name: diurnal-controller
|
||||||
|
name: diurnal-controller
|
||||||
|
spec:
|
||||||
|
replicas: 1
|
||||||
|
selector:
|
||||||
|
name: diurnal-controller
|
||||||
|
template:
|
||||||
|
metadata:
|
||||||
|
labels:
|
||||||
|
name: diurnal-controller
|
||||||
|
spec:
|
||||||
|
containers:
|
||||||
|
- args: ["-labels", "name=redis-slave", "-times", "00:00Z,00:02Z,01:00Z,02:30Z", "-counts", "3,7,6,9"]
|
||||||
|
resources:
|
||||||
|
limits:
|
||||||
|
cpu: 0.1
|
||||||
|
env:
|
||||||
|
- name: POD_NAMESPACE
|
||||||
|
valueFrom:
|
||||||
|
fieldRef:
|
||||||
|
fieldPath: metadata.namespace
|
||||||
|
image: uluyol/kube-diurnal:0.5
|
||||||
|
name: diurnal-controller
|
||||||
|
|
@ -0,0 +1,226 @@
|
||||||
|
/*
|
||||||
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
||||||
|
|
||||||
|
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 main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type parseTimeState int
|
||||||
|
|
||||||
|
const (
|
||||||
|
sHour parseTimeState = iota + 1
|
||||||
|
sMinute
|
||||||
|
sSecond
|
||||||
|
sUTC
|
||||||
|
sOffHour
|
||||||
|
sOffMinute
|
||||||
|
)
|
||||||
|
|
||||||
|
var parseTimeStateString = map[parseTimeState]string{
|
||||||
|
sHour: "hour",
|
||||||
|
sMinute: "minute",
|
||||||
|
sSecond: "second",
|
||||||
|
sUTC: "UTC",
|
||||||
|
sOffHour: "offset hour",
|
||||||
|
sOffMinute: "offset minute",
|
||||||
|
}
|
||||||
|
|
||||||
|
type timeParseErr struct {
|
||||||
|
state parseTimeState
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t timeParseErr) Error() string {
|
||||||
|
return "expected two digits for " + parseTimeStateString[t.state]
|
||||||
|
}
|
||||||
|
|
||||||
|
func getTwoDigits(s string) (int, bool) {
|
||||||
|
if len(s) >= 2 && '0' <= s[0] && s[0] <= '9' && '0' <= s[1] && s[1] <= '9' {
|
||||||
|
return int(s[0]-'0')*10 + int(s[1]-'0'), true
|
||||||
|
}
|
||||||
|
return 0, false
|
||||||
|
}
|
||||||
|
|
||||||
|
func zoneChar(b byte) bool {
|
||||||
|
return b == 'Z' || b == '+' || b == '-'
|
||||||
|
}
|
||||||
|
|
||||||
|
func validate(x, min, max int, name string) error {
|
||||||
|
if x < min || max < x {
|
||||||
|
return fmt.Errorf("the %s must be within the range %d...%d", name, min, max)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type triState int
|
||||||
|
|
||||||
|
const (
|
||||||
|
unset triState = iota
|
||||||
|
setFalse
|
||||||
|
setTrue
|
||||||
|
)
|
||||||
|
|
||||||
|
// parseTimeISO8601 parses times (without dates) according to the ISO 8601
|
||||||
|
// standard. The standard time package can understand layouts which accept
|
||||||
|
// valid ISO 8601 input. However, these layouts also accept input which is
|
||||||
|
// not valid ISO 8601 (in particular, negative zero time offset or "-00").
|
||||||
|
// Furthermore, there are a number of acceptable layouts, and to handle
|
||||||
|
// all of them using the time package requires trying them one at a time.
|
||||||
|
// This is error-prone, slow, not obviously correct, and again, allows
|
||||||
|
// a wider range of input to be accepted than is desirable. For these
|
||||||
|
// reasons, we implement ISO 8601 parsing without the use of the time
|
||||||
|
// package.
|
||||||
|
func parseTimeISO8601(s string) (time.Time, error) {
|
||||||
|
theTime := struct {
|
||||||
|
hour int
|
||||||
|
minute int
|
||||||
|
second int
|
||||||
|
utc triState
|
||||||
|
offNeg bool
|
||||||
|
offHour int
|
||||||
|
offMinute int
|
||||||
|
}{}
|
||||||
|
state := sHour
|
||||||
|
isExtended := false
|
||||||
|
for s != "" {
|
||||||
|
switch state {
|
||||||
|
case sHour:
|
||||||
|
v, ok := getTwoDigits(s)
|
||||||
|
if !ok {
|
||||||
|
return time.Time{}, timeParseErr{state}
|
||||||
|
}
|
||||||
|
theTime.hour = v
|
||||||
|
s = s[2:]
|
||||||
|
case sMinute:
|
||||||
|
if !zoneChar(s[0]) {
|
||||||
|
if s[0] == ':' {
|
||||||
|
isExtended = true
|
||||||
|
s = s[1:]
|
||||||
|
}
|
||||||
|
v, ok := getTwoDigits(s)
|
||||||
|
if !ok {
|
||||||
|
return time.Time{}, timeParseErr{state}
|
||||||
|
}
|
||||||
|
theTime.minute = v
|
||||||
|
s = s[2:]
|
||||||
|
}
|
||||||
|
case sSecond:
|
||||||
|
if !zoneChar(s[0]) {
|
||||||
|
if s[0] == ':' {
|
||||||
|
if isExtended {
|
||||||
|
s = s[1:]
|
||||||
|
} else {
|
||||||
|
return time.Time{}, errors.New("unexpected ':' before 'second' value")
|
||||||
|
}
|
||||||
|
} else if isExtended {
|
||||||
|
return time.Time{}, errors.New("expected ':' before 'second' value")
|
||||||
|
}
|
||||||
|
v, ok := getTwoDigits(s)
|
||||||
|
if !ok {
|
||||||
|
return time.Time{}, timeParseErr{state}
|
||||||
|
}
|
||||||
|
theTime.second = v
|
||||||
|
s = s[2:]
|
||||||
|
}
|
||||||
|
case sUTC:
|
||||||
|
if s[0] == 'Z' {
|
||||||
|
theTime.utc = setTrue
|
||||||
|
s = s[1:]
|
||||||
|
} else {
|
||||||
|
theTime.utc = setFalse
|
||||||
|
}
|
||||||
|
case sOffHour:
|
||||||
|
if theTime.utc == setTrue {
|
||||||
|
return time.Time{}, errors.New("unexpected offset, already specified UTC")
|
||||||
|
}
|
||||||
|
var sign int
|
||||||
|
if s[0] == '+' {
|
||||||
|
sign = 1
|
||||||
|
} else if s[0] == '-' {
|
||||||
|
sign = -1
|
||||||
|
theTime.offNeg = true
|
||||||
|
} else {
|
||||||
|
return time.Time{}, errors.New("offset must begin with '+' or '-'")
|
||||||
|
}
|
||||||
|
s = s[1:]
|
||||||
|
v, ok := getTwoDigits(s)
|
||||||
|
if !ok {
|
||||||
|
return time.Time{}, timeParseErr{state}
|
||||||
|
}
|
||||||
|
theTime.offHour = sign * v
|
||||||
|
s = s[2:]
|
||||||
|
case sOffMinute:
|
||||||
|
if s[0] == ':' {
|
||||||
|
if isExtended {
|
||||||
|
s = s[1:]
|
||||||
|
} else {
|
||||||
|
return time.Time{}, errors.New("unexpected ':' before 'minute' value")
|
||||||
|
}
|
||||||
|
} else if isExtended {
|
||||||
|
return time.Time{}, errors.New("expected ':' before 'second' value")
|
||||||
|
}
|
||||||
|
v, ok := getTwoDigits(s)
|
||||||
|
if !ok {
|
||||||
|
return time.Time{}, timeParseErr{state}
|
||||||
|
}
|
||||||
|
theTime.offMinute = v
|
||||||
|
s = s[2:]
|
||||||
|
default:
|
||||||
|
return time.Time{}, errors.New("an unknown error occured")
|
||||||
|
}
|
||||||
|
state++
|
||||||
|
}
|
||||||
|
if err := validate(theTime.hour, 0, 23, "hour"); err != nil {
|
||||||
|
return time.Time{}, err
|
||||||
|
}
|
||||||
|
if err := validate(theTime.minute, 0, 59, "minute"); err != nil {
|
||||||
|
return time.Time{}, err
|
||||||
|
}
|
||||||
|
if err := validate(theTime.second, 0, 59, "second"); err != nil {
|
||||||
|
return time.Time{}, err
|
||||||
|
}
|
||||||
|
if err := validate(theTime.offHour, -12, 14, "offset hour"); err != nil {
|
||||||
|
return time.Time{}, err
|
||||||
|
}
|
||||||
|
if err := validate(theTime.offMinute, 0, 59, "offset minute"); err != nil {
|
||||||
|
return time.Time{}, err
|
||||||
|
}
|
||||||
|
if theTime.offNeg && theTime.offHour == 0 && theTime.offMinute == 0 {
|
||||||
|
return time.Time{}, errors.New("an offset of -00 may not be used, must use +00")
|
||||||
|
}
|
||||||
|
var (
|
||||||
|
loc *time.Location
|
||||||
|
err error
|
||||||
|
)
|
||||||
|
if theTime.utc == setTrue {
|
||||||
|
loc, err = time.LoadLocation("UTC")
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
} else if theTime.utc == setFalse {
|
||||||
|
loc = time.FixedZone("Zone", theTime.offMinute*60+theTime.offHour*3600)
|
||||||
|
} else {
|
||||||
|
loc, err = time.LoadLocation("Local")
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
t := time.Date(1, time.January, 1, theTime.hour, theTime.minute, theTime.second, 0, loc)
|
||||||
|
return t, nil
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,104 @@
|
||||||
|
/*
|
||||||
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
||||||
|
|
||||||
|
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 main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestParseTimeISO8601(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
input string
|
||||||
|
expected time.Time
|
||||||
|
err bool
|
||||||
|
}{
|
||||||
|
{"00", timeMustParse("15", "00"), false},
|
||||||
|
{"49", time.Time{}, true},
|
||||||
|
{"-2", time.Time{}, true},
|
||||||
|
{"12:34:56", timeMustParse("15:04:05", "12:34:56"), false},
|
||||||
|
{"123456", timeMustParse("15:04:05", "12:34:56"), false},
|
||||||
|
{"12:34", timeMustParse("15:04:05", "12:34:00"), false},
|
||||||
|
{"1234", timeMustParse("15:04:05", "12:34:00"), false},
|
||||||
|
{"1234:56", time.Time{}, true},
|
||||||
|
{"12:3456", time.Time{}, true},
|
||||||
|
{"12:34:96", time.Time{}, true},
|
||||||
|
{"12:34:-00", time.Time{}, true},
|
||||||
|
{"123476", time.Time{}, true},
|
||||||
|
{"12:-34", time.Time{}, true},
|
||||||
|
{"12104", time.Time{}, true},
|
||||||
|
|
||||||
|
{"00Z", timeMustParse("15 MST", "00 UTC"), false},
|
||||||
|
{"-2Z", time.Time{}, true},
|
||||||
|
{"12:34:56Z", timeMustParse("15:04:05 MST", "12:34:56 UTC"), false},
|
||||||
|
{"12:34Z", timeMustParse("15:04:05 MST", "12:34:00 UTC"), false},
|
||||||
|
{"12:34:-00Z", time.Time{}, true},
|
||||||
|
{"12104Z", time.Time{}, true},
|
||||||
|
|
||||||
|
{"00+00", timeMustParse("15 MST", "00 UTC"), false},
|
||||||
|
{"-2+03", time.Time{}, true},
|
||||||
|
{"11:34:56+12", timeMustParse("15:04:05 MST", "23:34:56 UTC"), false},
|
||||||
|
{"12:34:14+10:30", timeMustParse("15:04:05 MST", "23:04:00 UTC"), false},
|
||||||
|
{"12:34:-00+10", time.Time{}, true},
|
||||||
|
{"1210+00:00", time.Time{}, true},
|
||||||
|
{"12:10+0000", time.Time{}, true},
|
||||||
|
{"1210Z+00", time.Time{}, true},
|
||||||
|
|
||||||
|
{"00-00", time.Time{}, true},
|
||||||
|
{"-2-03", time.Time{}, true},
|
||||||
|
{"11:34:56-11", timeMustParse("15:04:05 MST", "00:34:56 UTC"), false},
|
||||||
|
{"12:34:14-10:30", timeMustParse("15:04:05 MST", "02:04:00 UTC"), false},
|
||||||
|
{"12:34:-00-10", time.Time{}, true},
|
||||||
|
{"1210-00:00", time.Time{}, true},
|
||||||
|
{"12:10-0000", time.Time{}, true},
|
||||||
|
{"1210Z-00", time.Time{}, true},
|
||||||
|
|
||||||
|
// boundary cases
|
||||||
|
{"-01", time.Time{}, true},
|
||||||
|
{"00", timeMustParse("15", "00"), false},
|
||||||
|
{"23", timeMustParse("15", "23"), false},
|
||||||
|
{"24", time.Time{}, true},
|
||||||
|
{"00:-01", time.Time{}, true},
|
||||||
|
{"00:00", timeMustParse("15:04", "00:00"), false},
|
||||||
|
{"00:59", timeMustParse("15:04", "00:59"), false},
|
||||||
|
{"00:60", time.Time{}, true},
|
||||||
|
{"01:02:-01", time.Time{}, true},
|
||||||
|
{"01:02:00", timeMustParse("15:04:05", "01:02:00"), false},
|
||||||
|
{"01:02:59", timeMustParse("15:04:05", "01:02:59"), false},
|
||||||
|
{"01:02:60", time.Time{}, true},
|
||||||
|
{"01:02:03-13", time.Time{}, true},
|
||||||
|
{"01:02:03-12", timeMustParse("15:04:05 MST", "01:02:03 UTC").Add(-12 * time.Hour), false},
|
||||||
|
{"01:02:03+14", timeMustParse("15:04:05 MST", "15:02:03 UTC"), false},
|
||||||
|
{"01:02:03+15", time.Time{}, true},
|
||||||
|
}
|
||||||
|
for i, test := range cases {
|
||||||
|
curTime, err := parseTimeISO8601(test.input)
|
||||||
|
if test.err {
|
||||||
|
if err == nil {
|
||||||
|
t.Errorf("case %d [%s]: expected error, got: %v", i, test.input, curTime)
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
t.Errorf("case %d [%s]: unexpected error: %v", i, test.input, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if test.expected.Equal(curTime) {
|
||||||
|
t.Errorf("case %d [%s]: expected: %v got: %v", i, test.input, test.expected, curTime)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue