func setupAPIDatastore(app *server.App) {
var API = app.API()
if lib.IsOnLocalGAE() {
API.GET("/datastore/cleanup/:kind.json",
server.Handler(func(req *wcg.Request) response.Response {
k := entities.FindKind(req.Param("kind"), req.Query("ns"))
if k == nil {
return response.NotFound(req)
}
num := k.DeleteQuery().MustCommit(req)
return response.NewJSONResponse(map[string]int{
"entities": num,
})
}),
)
}
API.GET("/datastore/export/:kind.json",
middleware.APITokenOnly(),
server.Handler(func(req *wcg.Request) response.Response {
k := entities.FindKind(req.Param("kind"), req.Query("ns"))
if k == nil {
return response.NotFound(req)
}
// TODO: export with gzip
return middleware.EntityStreaming(
k.Query().Order(fmt.Sprintf("-%s", k.TimestampFieldName)).Limit(
wcg.ParseInt(req.Query("limit"), 100, -1, math.MaxInt32),
),
true,
).Handle(req)
}))
API.POST("/datastore/import/:kind.json",
middleware.APITokenOnly(),
server.Handler(func(req *wcg.Request) response.Response {
k := entities.FindKind(req.Param("kind"), req.Query("ns"))
if k == nil {
return response.NotFound(req)
}
var line = 0
var total = 0
var errors = make([]*entityImportError, 0)
var list = make([]interface{}, 0, 100)
var keys = make([]*datastore.Key, 0, 100)
var buff []byte
var err error
reader := bufio.NewReaderSize(req.HTTPRequest().Body, 4096)
for err != io.EOF {
buff, err = reader.ReadBytes('\n')
line += 1
if err != nil && err != io.EOF {
return response.InternalServerError(req, err)
}
buff = bytes.TrimSpace(buff)
if len(buff) == 0 { // skip empty row
continue
}
var row entityImportRow
if err2 := json.Unmarshal(buff, &row); err2 != nil {
errors = append(errors, &entityImportError{
Line: line,
Error: fmt.Sprintf("%v - (row: %q)", err2, buff),
})
continue
}
ent, err2 := k.NewEntityFromJSON([]byte(row.Entity))
if err2 != nil {
}
total = total + 1
keys = append(keys, buildKey(req, row.Key))
list = append(list, ent)
if len(list) == 100 {
k.PutMulti().DatastoreKeys(keys...).DoNotUpdateTimestamp(true).MustUpdate(req, list)
list = make([]interface{}, 0, 100)
keys = make([]*datastore.Key, 0, 100)
}
}
if len(list) > 0 {
k.PutMulti().DatastoreKeys(keys...).DoNotUpdateTimestamp(true).MustUpdate(req, list)
}
return response.NewJSONResponse(&entityImportResult{
Total: total,
Lines: line - 1,
Errors: errors,
})
}))
}
func setupAPIStats(app *server.App) {
var API = app.API()
API.GET("/stats/servers/",
middleware.EntityAll(Server.Query()))
API.GET("/stats/nasdisks/",
middleware.EntityAll(NASDisk.Query()))
API.GET("/stats/servers/:server/:stats/",
server.Handler(
func(req *wcg.Request) response.Response {
key, _ := Server.Get().Key(req.Param("server")).Cache(true).MustOne(req)
if key == nil {
req.Logger.Debugf("server %q is not found.", req.Param("server"))
return response.NotFound(req)
}
var kind *entities.Kind
switch req.Param("stats") {
case "system":
kind = SystemStats
break
case "cpu":
kind = CPUStats
break
case "memory":
kind = MemoryStats
break
case "disk":
kind = DiskStats
break
case "filesystem":
kind = FileSystemStats
break
case "network":
kind = NetworkStats
break
default:
req.Logger.Debugf("metric %q is invalid.", req.Param("stats"))
return response.NotFound(req)
}
return execStatsQuery(req, kind.Query().Ancestor(key))
},
))
API.POST("/stats/metrics/",
middleware.APITokenOnly(),
server.Handler(
func(req *wcg.Request) response.Response {
ent, err := SystemMetric.CreateEntitiesFromJSON(req.HTTPRequest().Body)
if err != nil {
return response.BadRequest(req, err)
}
collection := home.NewStatsFromMetrics(ent.([]*home.SystemMetric))
if len(collection) == 0 {
return response.BadRequest(req, fmt.Errorf("No stats are collected."))
}
if collection[0].System.ServerName == "" {
return response.BadRequest(req, fmt.Errorf("server_name is missing"))
}
for _, stats := range collection {
key := getServerKey(req, stats.System.ServerName)
id := fmt.Sprintf("%s.%d", key.StringID(), stats.Timestamp.Unix())
stats.System.ID = id
stats.CPU.ID = id
stats.Memory.ID = id
for _, v := range stats.Disks {
v.ID = fmt.Sprintf("%s.%s.%d", key.StringID(), v.DeviceName, stats.Timestamp.Unix())
}
for _, v := range stats.Networks {
v.ID = fmt.Sprintf("%s.%s.%d", key.StringID(), v.DeviceName, stats.Timestamp.Unix())
}
SystemStats.Put().Parent(key).MustUpdate(req, stats.System)
CPUStats.Put().Parent(key).MustUpdate(req, stats.CPU)
MemoryStats.Put().Parent(key).MustUpdate(req, stats.Memory)
DiskStats.PutMulti().Parent(key).MustUpdate(req, stats.Disks)
NetworkStats.PutMulti().Parent(key).MustUpdate(req, stats.Networks)
}
return response.NewJSONResponse(true)
},
))
API.POST("/stats/filesystem/",
middleware.APITokenOnly(),
server.Handler(
func(req *wcg.Request) response.Response {
ent, err := FileSystemStats.CreateEntitiesFromJSON(req.HTTPRequest().Body)
if err != nil {
return response.BadRequest(req, err)
}
filesystems := ent.([]*home.FileSystemStats)
if filesystems[0].ServerName == "" {
return response.BadRequest(req, fmt.Errorf("server_name is missing"))
}
key := getServerKey(req, filesystems[0].ServerName)
for _, fs := range filesystems {
fs.ID = fmt.Sprintf("%s.%s.%d", fs.ServerName, fs.Name, fs.Timestamp.Unix())
}
FileSystemStats.PutMulti().Parent(key).MustUpdate(req, filesystems)
return response.NewJSONResponse(true)
},
))
API.POST("/stats/smart/",
middleware.APITokenOnly(),
server.Handler(
func(req *wcg.Request) response.Response {
ent, err := SMARTStats.CreateEntitiesFromJSON(req.HTTPRequest().Body)
if err != nil {
return response.BadRequest(req, err)
}
smartstats := ent.([]*home.SMARTStats)
if smartstats[0].Serial == "" {
return response.BadRequest(req, fmt.Errorf("serial is missing"))
}
key := getNASDiskKey(req, smartstats[0].Serial)
for _, smart := range smartstats {
smart.ID = fmt.Sprintf("%s.%d", smart.Serial, smart.Timestamp.Unix())
}
SMARTStats.PutMulti().Parent(key).MustUpdate(req, smartstats)
return response.NewJSONResponse(true)
},
))
}