Added a basic api interface for events

Author: kateknister

api/handler.go

@@ -17,16 +17,20 @@ package api
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"path"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/golang/glog"
+	"github.com/google/cadvisor/events"
 	"github.com/google/cadvisor/info"
 	"github.com/google/cadvisor/manager"
 )
@@ -125,6 +129,7 @@ func writeResult(res interface{}, w http.ResponseWriter) error {
 	w.Header().Set("Content-Type", "application/json")
 	w.Write(out)
 	return nil
+
 }
 
 func getContainerInfoRequest(body io.ReadCloser) (*info.ContainerInfoRequest, error) {
@@ -142,6 +147,84 @@ func getContainerInfoRequest(body io.ReadCloser) (*info.ContainerInfoRequest, er
 	return &query, nil
 }
 
+// request is the rawQuery portion of the url input by the user. It should have
+// length 1, otherwise the url was ill formatted (backslashes must have
+// been inserted in the argument section of the url) and function will return an
+// error. The user can set any or none of the following arguments in any order
+// with any twice defined arguments being assigned the first value.
+// If the value type for the argument is wrong the field will be assumed to be
+// unassigned
+// bools: all_time, subcontainers, oom_events, creation_events, deletion_events
+// ints: max_events, start_time (unix timestamp), end_time (unix timestamp)
+// example request: ["oom_events=true&max_events=10"]
+func getEventRequest(request []string) (*events.Request, bool, error) {
+	if len(request) <= 0 || len(request[0]) == 0 {
+		return events.NewAllEventsRequest(), true, nil
+	} else if len(request) > 1 {
+		return nil, false, errors.New(
+			"should have received one url rawQuery but got multiple")
+	}
+	rawQuery := strings.Trim(request[0], "/ ")
+
+	query := events.NewRequest()
+	getEventsFromAllTime := false
+
+	urlMap, err := url.ParseQuery(rawQuery)
+	if err != nil {
+		glog.Errorf("url parse error of %v is %v", rawQuery, err)
+		return nil, false, err
+	}
+
+	for key, val := range urlMap {
+		if key == "all_time" {
+			newBool, err := strconv.ParseBool(val[0])
+			if err == nil {
+				getEventsFromAllTime = newBool
+			}
+		} else if key == "subcontainers" {
+			newBool, err := strconv.ParseBool(val[0])
+			if err == nil {
+				query.IncludeSubcontainers = newBool
+			}
+		} else if key == "oom_events" {
+			newBool, err := strconv.ParseBool(val[0])
+			if err == nil {
+				query.EventType[events.TypeOom] = newBool
+			}
+		} else if key == "creation_events" {
+			newBool, err := strconv.ParseBool(val[0])
+			if err == nil {
+				query.EventType[events.TypeContainerCreation] = newBool
+			}
+		} else if key == "deletion_events" {
+			newBool, err := strconv.ParseBool(val[0])
+			if err == nil {
+				query.EventType[events.TypeContainerDeletion] = newBool
+			}
+		} else if key == "max_events" {
+			newInt, err := strconv.Atoi(val[0])
+			if err == nil {
+				query.MaxEventsReturned = int(newInt)
+			}
+		} else if key == "start_time" {
+			newTime, err := time.Parse(time.RFC3339, val[0])
+			if err == nil {
+				query.StartTime = newTime
+			}
+		} else if key == "end_time" {
+			newTime, err := time.Parse(time.RFC3339, val[0])
+			if err == nil {
+				query.EndTime = newTime
+			}
+		}
+	}
+
+	glog.V(2).Infof(
+		"%v was returned in api/handler.go:getEventRequest from the url rawQuery %v",
+		query, rawQuery)
+	return query, getEventsFromAllTime, nil
+}
+
 func getContainerName(request []string) string {
 	return path.Join("/", strings.Join(request, "/"))
 }

api/versions.go

@@ -19,6 +19,7 @@ import (
 	"net/http"
 
 	"github.com/golang/glog"
+	"github.com/google/cadvisor/events"
 	"github.com/google/cadvisor/info"
 	"github.com/google/cadvisor/manager"
 )
@@ -30,6 +31,7 @@ const (
 	dockerApi        = "docker"
 	summaryApi       = "summary"
 	specApi          = "spec"
+	eventsApi        = "events"
 )
 
 // Interface for a cAdvisor API version
@@ -49,8 +51,11 @@ func getApiVersions() []ApiVersion {
 	v1_0 := &version1_0{}
 	v1_1 := newVersion1_1(v1_0)
 	v1_2 := newVersion1_2(v1_1)
-	v2_0 := newVersion2_0(v1_2)
-	return []ApiVersion{v1_0, v1_1, v1_2, v2_0}
+	v1_3 := newVersion1_3(v1_2)
+	v2_0 := newVersion2_0(v1_3)
+
+	return []ApiVersion{v1_0, v1_1, v1_2, v1_3, v2_0}
+
 }
 
 // API v1.0
@@ -227,12 +232,72 @@ func (self *version1_2) HandleRequest(requestType string, request []string, m ma
 	}
 }
 
-// v2.0 builds on v1.2
-type version2_0 struct {
+// API v1.3
+
+type version1_3 struct {
 	baseVersion *version1_2
 }
 
-func newVersion2_0(v *version1_2) *version2_0 {
+// v1.3 builds on v1.2.
+func newVersion1_3(v *version1_2) *version1_3 {
+	return &version1_3{
+		baseVersion: v,
+	}
+}
+
+func (self *version1_3) Version() string {
+	return "v1.3"
+}
+
+func (self *version1_3) SupportedRequestTypes() []string {
+	return append(self.baseVersion.SupportedRequestTypes(), eventsApi)
+}
+
+func (self *version1_3) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error {
+	switch requestType {
+	case eventsApi:
+		query, eventsFromAllTime, err := getEventRequest(request)
+		if err != nil {
+			return err
+		}
+		glog.V(2).Infof("Api - Events(%v)", query)
+
+		if eventsFromAllTime {
+			allEvents, err := m.GetPastEvents(query)
+			if err != nil {
+				return err
+			}
+			return writeResult(allEvents, w)
+		} else {
+			// every time URL is entered to watch, a channel is created here
+			eventChannel := make(chan *events.Event, 10)
+			err = m.WatchForEvents(query, eventChannel)
+
+			defer close(eventChannel)
+			currentEventSet := make(events.EventSlice, 0)
+			for ev := range eventChannel {
+				// todo: implement write-as-received writeResult method
+				currentEventSet = append(currentEventSet, ev)
+				err = writeResult(currentEventSet, w)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	default:
+		return self.baseVersion.HandleRequest(requestType, request, m, w, r)
+	}
+}
+
+// API v2.0
+
+// v2.0 builds on v1.3
+type version2_0 struct {
+	baseVersion *version1_3
+}
+
+func newVersion2_0(v *version1_3) *version2_0 {
 	return &version2_0{
 		baseVersion: v,
 	}

api/versions_test.go

@@ -0,0 +1,91 @@
+// Copyright 2015 Google Inc. 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 api
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/google/cadvisor/events"
+)
+
+func TestGetEventRequestBasicRequest(t *testing.T) {
+	var request = []string{"all_time=true&oom_events=true&max_events=10"}
+	expectedQuery := &events.Request{
+		EventType: map[events.EventType]bool{
+			events.TypeOom: true,
+		},
+		MaxEventsReturned: 10,
+	}
+	receivedQuery, shouldGetAllEvents, err := getEventRequest(request)
+	if !reflect.DeepEqual(expectedQuery, receivedQuery) {
+		t.Errorf("expected %v but received %v", expectedQuery, receivedQuery)
+	}
+	if !shouldGetAllEvents {
+		t.Errorf("expected to call GetEvents rather than WatchEvents")
+	}
+	if err != nil {
+		t.Errorf("got error when parsing event request url: %v", err)
+	}
+}
+
+func TestGetEventEmptyRequest(t *testing.T) {
+	var request = []string{}
+	expectedQuery := events.NewAllEventsRequest()
+	receivedQuery, shouldGetAllEvents, err := getEventRequest(request)
+	if !reflect.DeepEqual(expectedQuery, receivedQuery) {
+		t.Errorf("expected %v but received %v", expectedQuery, receivedQuery)
+	}
+	if !shouldGetAllEvents {
+		t.Errorf("expected to call GetEvents rather than WatchEvents")
+	}
+	if err != nil {
+		t.Errorf("got error when parsing event request url: %v", err)
+	}
+}
+
+func TestGetEventEmptyStringRequest(t *testing.T) {
+	var request = []string{""}
+	expectedQuery := events.NewAllEventsRequest()
+	receivedQuery, shouldGetAllEvents, err := getEventRequest(request)
+	if !reflect.DeepEqual(expectedQuery, receivedQuery) {
+		t.Errorf("expected %v but received %v", expectedQuery, receivedQuery)
+	}
+	if !shouldGetAllEvents {
+		t.Errorf("expected to call GetEvents rather than WatchEvents")
+	}
+	if err != nil {
+		t.Errorf("got error when parsing event request url: %v", err)
+	}
+}
+
+func TestGetEventRequestDoubleArgument(t *testing.T) {
+	var request = []string{"all_time=true&oom_events=true&oom_events=false"}
+	expectedQuery := &events.Request{
+		EventType: map[events.EventType]bool{
+			events.TypeOom: true,
+		},
+	}
+	receivedQuery, shouldGetAllEvents, err := getEventRequest(request)
+	if !reflect.DeepEqual(expectedQuery, receivedQuery) {
+		t.Errorf("expected %v but received %v", expectedQuery, receivedQuery)
+	}
+	if !shouldGetAllEvents {
+		t.Errorf("expected to call GetEvents rather than WatchEvents")
+	}
+	if err != nil {
+		t.Errorf("got error when parsing event request url: %v", err)
+	}
+}

events/handler.go

@@ -103,7 +103,7 @@ type Request struct {
 	// allows the caller to put a limit on how many
 	// events they receive. If there are more events than MaxEventsReturned
 	// then the most chronologically recent events in the time period
-	// specified are returned
+	// specified are returned. Must be >= 1
 	MaxEventsReturned int
 	// the absolute container name for which the event occurred
 	ContainerName string
@@ -143,6 +143,18 @@ func NewRequest() *Request {
 	}
 }
 
+// returns a pointer to an initialized Request object
+func NewAllEventsRequest() *Request {
+	return &Request{
+		EventType: map[EventType]bool{
+			TypeOom:               true,
+			TypeContainerDeletion: true,
+			TypeContainerCreation: true,
+		},
+		IncludeSubcontainers: true,
+	}
+}
+
 // returns a pointer to an initialized watch object
 func newWatch(request *Request, outChannel chan *Event) *watch {
 	return &watch{

manager/manager.go

@@ -74,6 +74,9 @@ type Manager interface {
 
 	// Get events streamed through passedChannel that fit the request.
 	WatchForEvents(request *events.Request, passedChannel chan *events.Event) error
+
+	// Get past events that have been detected and that fit the request.
+	GetPastEvents(request *events.Request) (events.EventSlice, error)
 }
 
 // New takes a memory storage and returns a new manager.
@@ -668,3 +671,8 @@ func (self *manager) watchForNewOoms() error {
 func (self *manager) WatchForEvents(request *events.Request, passedChannel chan *events.Event) error {
 	return self.eventHandler.WatchEvents(passedChannel, request)
 }
+
+// can be called by the api which will return all events satisfying the request
+func (self *manager) GetPastEvents(request *events.Request) (events.EventSlice, error) {
+	return self.eventHandler.GetEvents(request)
+}