server/query.go

   1 //
   2 // Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions
   7 // are met:
   8 // 1. Redistributions of source code must retain the above copyright
   9 //    notice, this list of conditions and the following disclaimer.
  10 // 2. Redistributions in binary form must reproduce the above copyright
  11 //    notice, this list of conditions and the following disclaimer in the
  12 //    documentation and/or other materials provided with the distribution.
  13 //
  14 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  15 // ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  16 // TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  18 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25
  26 package server
  27
  28 // Helper functions for handling queries.
  29
  30 import (
  31         "errors"
  32         "fmt"
  33         "strings"
  34         "time"
  35         "unicode"
  36
  37         "github.com/sysdb/go/client"
  38         "github.com/sysdb/go/proto"
  39 )
  40
  41 func listAll(req request, s *Server) (*page, error) {
  42         if len(req.args) != 0 {
  43                 return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
  44         }
  45
  46         q, err := client.QueryString("LIST %s", client.Identifier(req.cmd))
  47         if err != nil {
  48                 return nil, err
  49         }
  50         res, err := s.c.Query(q)
  51         if err != nil {
  52                 return nil, err
  53         }
  54         // the template *must* exist
  55         return tmpl(s.results[req.cmd], res)
  56 }
  57
  58 func lookup(req request, s *Server) (*page, error) {
  59         if req.r.Method != "POST" {
  60                 return nil, errors.New("Method not allowed")
  61         }
  62         raw, err := parseQuery(req.r.PostForm.Get("query"))
  63         if err != nil {
  64                 return nil, err
  65         }
  66
  67         if raw.typ == "" {
  68                 raw.typ = "hosts"
  69         }
  70         var args string
  71         for name, value := range raw.args {
  72                 if len(args) > 0 {
  73                         args += " AND"
  74                 }
  75
  76                 if name == "name" {
  77                         args += fmt.Sprintf(" name =~ %s", value)
  78                 } else {
  79                         args += fmt.Sprintf(" %s = %s", name, value)
  80                 }
  81         }
  82
  83         q, err := client.QueryString("LOOKUP %s MATCHING"+args, client.Identifier(raw.typ))
  84         if err != nil {
  85                 return nil, err
  86         }
  87         res, err := s.c.Query(q)
  88         if err != nil {
  89                 return nil, err
  90         }
  91         if t, ok := s.results[raw.typ]; ok {
  92                 return tmpl(t, res)
  93         }
  94         return nil, fmt.Errorf("Unsupported type %s", raw.typ)
  95 }
  96
  97 func fetch(req request, s *Server) (*page, error) {
  98         if len(req.args) == 0 {
  99                 return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
 100         }
 101
 102         var q string
 103         var err error
 104         switch req.cmd {
 105         case "host":
 106                 if len(req.args) != 1 {
 107                         return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
 108                 }
 109                 q, err = client.QueryString("FETCH host %s", req.args[0])
 110         case "service", "metric":
 111                 if len(req.args) != 2 {
 112                         return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
 113                 }
 114                 q, err = client.QueryString("FETCH %s %s.%s", client.Identifier(req.cmd), req.args[0], req.args[1])
 115         default:
 116                 panic("Unknown request: fetch(" + req.cmd + ")")
 117         }
 118         if err != nil {
 119                 return nil, err
 120         }
 121
 122         res, err := s.c.Query(q)
 123         if err != nil {
 124                 return nil, err
 125         }
 126         if req.cmd == "metric" {
 127                 return metric(req, res, s)
 128         }
 129         return tmpl(s.results[req.cmd], res)
 130 }
 131
 132 func graphs(req request, s *Server) (*page, error) {
 133         p := struct {
 134                 Query, Metrics string
 135         }{
 136                 Query: req.r.PostForm.Get("metrics-query"),
 137         }
 138
 139         if req.r.Method == "POST" {
 140                 p.Metrics = p.Query
 141         }
 142         return tmpl(s.results["graphs"], &p)
 143 }
 144
 145 var datetime = "2006-01-02 15:04:05"
 146
 147 func metric(req request, res interface{}, s *Server) (*page, error) {
 148         start := time.Now().Add(-24 * time.Hour)
 149         end := time.Now()
 150         if req.r.Method == "POST" {
 151                 var err error
 152                 // Parse the values first to verify their format.
 153                 if s := req.r.PostForm.Get("start_date"); s != "" {
 154                         if start, err = time.Parse(datetime, s); err != nil {
 155                                 return nil, fmt.Errorf("Invalid start time %q", s)
 156                         }
 157                 }
 158                 if e := req.r.PostForm.Get("end_date"); e != "" {
 159                         if end, err = time.Parse(datetime, e); err != nil {
 160                                 return nil, fmt.Errorf("Invalid end time %q", e)
 161                         }
 162                 }
 163         }
 164
 165         p := struct {
 166                 StartTime string
 167                 EndTime   string
 168                 URLStart  string
 169                 URLEnd    string
 170                 Data      interface{}
 171         }{
 172                 start.Format(datetime),
 173                 end.Format(datetime),
 174                 start.Format(urldate),
 175                 end.Format(urldate),
 176                 res,
 177         }
 178         return tmpl(s.results["metric"], &p)
 179 }
 180
 181 type query struct {
 182         typ  string
 183         args map[string]string
 184 }
 185
 186 func (q *query) arg(name, value string) error {
 187         if _, ok := q.args[name]; ok {
 188                 return fmt.Errorf("Duplicate key %q", name)
 189         }
 190         q.args[name] = proto.EscapeString(value)
 191         return nil
 192 }
 193
 194 func (q *query) attr(parent, name, value string) error {
 195         var k string
 196         if parent != "" {
 197                 k = fmt.Sprintf("%s.attribute[%s]", parent, proto.EscapeString(name))
 198         } else {
 199                 k = fmt.Sprintf("attribute[%s]", proto.EscapeString(name))
 200         }
 201
 202         return q.arg(k, value)
 203 }
 204
 205 func parseQuery(s string) (*query, error) {
 206         tokens, err := tokenize(s)
 207         if err != nil {
 208                 return nil, err
 209         }
 210         if len(tokens) == 0 {
 211                 return nil, errors.New("Empty query")
 212         }
 213
 214         q := &query{args: make(map[string]string)}
 215         for i, tok := range tokens {
 216                 if fields := strings.SplitN(tok, ":", 2); len(fields) == 2 {
 217                         // Query: [<type>:] [<sibling-type>.]<attribute>:<value> ...
 218                         if i == 0 && fields[1] == "" {
 219                                 q.typ = fields[0]
 220                         } else if elems := strings.Split(fields[0], "."); len(elems) > 1 {
 221                                 objs := elems[:len(elems)-1]
 222                                 for _, o := range objs {
 223                                         if o != "host" && o != "service" && o != "metric" {
 224                                                 return nil, fmt.Errorf("Invalid object type %q", o)
 225                                         }
 226                                 }
 227                                 if err := q.attr(strings.Join(objs, "."), elems[len(elems)-1], fields[1]); err != nil {
 228                                         return nil, err
 229                                 }
 230                         } else {
 231                                 if err := q.attr("", fields[0], fields[1]); err != nil {
 232                                         return nil, err
 233                                 }
 234                         }
 235                 } else {
 236                         if err := q.arg("name", tok); err != nil {
 237                                 return nil, err
 238                         }
 239                 }
 240         }
 241         return q, nil
 242 }
 243
 244 // tokenize split the string s into its tokens where a token is either a quoted
 245 // string or surrounded by one or more consecutive whitespace characters.
 246 func tokenize(s string) ([]string, error) {
 247         scan := scanner{}
 248         tokens := []string{}
 249         start := -1
 250         for i, r := range s {
 251                 if !scan.inField(r) {
 252                         if start == -1 {
 253                                 // Skip leading and consecutive whitespace.
 254                                 continue
 255                         }
 256                         tok, err := unescape(s[start:i])
 257                         if err != nil {
 258                                 return nil, err
 259                         }
 260                         tokens = append(tokens, tok)
 261                         start = -1
 262                 } else if start == -1 {
 263                         // Found a new field.
 264                         start = i
 265                 }
 266         }
 267         if start >= 0 {
 268                 // Last (or possibly only) field.
 269                 tok, err := unescape(s[start:])
 270                 if err != nil {
 271                         return nil, err
 272                 }
 273                 tokens = append(tokens, tok)
 274         }
 275
 276         if scan.inQuotes {
 277                 return nil, errors.New("quoted string not terminated")
 278         }
 279         if scan.escaped {
 280                 return nil, errors.New("illegal character escape at end of string")
 281         }
 282         return tokens, nil
 283 }
 284
 285 func unescape(s string) (string, error) {
 286         var unescaped []byte
 287         var i, n int
 288         for i = 0; i < len(s); i++ {
 289                 if s[i] != '\\' {
 290                         n++
 291                         continue
 292                 }
 293
 294                 if i >= len(s) {
 295                         return "", errors.New("illegal character escape at end of string")
 296                 }
 297                 if s[i+1] != ' ' && s[i+1] != '"' && s[i+1] != '\\' {
 298                         // Allow simple escapes only for now.
 299                         return "", fmt.Errorf("illegal character escape \\%c", s[i+1])
 300                 }
 301                 if unescaped == nil {
 302                         unescaped = []byte(s)
 303                 }
 304                 copy(unescaped[n:], s[i+1:])
 305         }
 306
 307         if unescaped != nil {
 308                 return string(unescaped[:n]), nil
 309         }
 310         return s, nil
 311 }
 312
 313 type scanner struct {
 314         inQuotes bool
 315         escaped  bool
 316 }
 317
 318 func (s *scanner) inField(r rune) bool {
 319         if s.escaped {
 320                 s.escaped = false
 321                 return true
 322         }
 323         if r == '\\' {
 324                 s.escaped = true
 325                 return true
 326         }
 327         if s.inQuotes {
 328                 if r == '"' {
 329                         s.inQuotes = false
 330                         return false
 331                 }
 332                 return true
 333         }
 334         if r == '"' {
 335                 s.inQuotes = true
 336                 return false
 337         }
 338         return !unicode.IsSpace(r)
 339 }
 340
 341 // vim: set tw=78 sw=4 sw=4 noexpandtab :