Added a basic api interface for events

Author: kateknister

api/handler.go

@@ -17,20 +17,29 @@ 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"
 )
 
+type urlData struct {
+	boolVal bool
+	intVal  int
+}
+
 const (
 	apiResource = "/api/"
 )
@@ -125,6 +134,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 +152,57 @@ func getContainerInfoRequest(body io.ReadCloser) (*info.ContainerInfoRequest, er
 	return &query, nil
 }
 
+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
+	}
+
+	valueMap := make(map[string]urlData)
+	for key, val := range urlMap {
+		// if a variable is assigned twice, ex. &TypeOom=true&TypeOom=false
+		// then only the first will be taken
+		newInt, err := strconv.ParseInt(val[0], 0, 0)
+		if err == nil {
+			valueMap[key] = urlData{intVal: int(newInt)}
+			continue
+		}
+		newBool, err := strconv.ParseBool(val[0])
+		if err == nil {
+			valueMap[key] = urlData{boolVal: newBool}
+		}
+	}
+
+	getEventsFromAllTime = valueMap["allTime"].boolVal
+	query.IncludeSubcontainers = valueMap["IncludeSubcontainers"].boolVal
+	query.EventType[events.TypeOom] = valueMap["TypeOom"].boolVal
+	query.EventType[events.TypeContainerCreation] = valueMap["TypeContainerCreation"].boolVal
+	query.EventType[events.TypeContainerDeletion] = valueMap["TypeContainerDeletion"].boolVal
+	query.MaxEventsReturned = valueMap["MaxEventsReturned"].intVal
+
+	if mapVal, ok := valueMap["StartTime"]; ok {
+		query.StartTime = time.Now().Add(time.Duration(-1 * mapVal.intVal))
+	}
+	if mapVal, ok := valueMap["EndTime"]; ok {
+		query.EndTime = time.Now().Add(time.Duration(-1 * mapVal.intVal))
+	}
+
+	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
@@ -50,7 +52,9 @@ func getApiVersions() []ApiVersion {
 	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)
+	return []ApiVersion{v1_0, v1_1, v1_2, v2_0, v1_3}
+
 }
 
 // API v1.0
@@ -270,3 +274,63 @@ func (self *version2_0) HandleRequest(requestType string, request []string, m ma
 		return self.baseVersion.HandleRequest(requestType, request, m, w, r)
 	}
 }
+
+// API v1.3
+
+type version1_3 struct {
+	baseVersion *version1_2
+}
+
+// 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 {
+	case requestType == 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)
+			err = m.WatchForEvents(query, eventChannel)
+
+			go func() {
+				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 {
+						glog.Errorf("Error writing result %v was %v", currentEventSet, err)
+					}
+				}
+			}()
+		}
+		return nil
+	default:
+		return self.baseVersion.HandleRequest(requestType, request, m, w, r)
+	}
+}

api/versions_test.go

@@ -0,0 +1,95 @@
+// 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{"allTime=true&TypeOom=true&MaxEventsReturned=10"}
+	expectedQuery := &events.Request{
+		EventType: map[events.EventType]bool{
+			events.TypeOom:               true,
+			events.TypeContainerCreation: false,
+			events.TypeContainerDeletion: false,
+		},
+		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{"allTime=true&TypeOom=true&TypeOom=false"}
+	expectedQuery := &events.Request{
+		EventType: map[events.EventType]bool{
+			events.TypeOom:               true,
+			events.TypeContainerCreation: false,
+			events.TypeContainerDeletion: false,
+		},
+	}
+	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)
+}