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         var args string
  68         for name, value := range raw.args {
  69                 if len(args) > 0 {
  70                         args += " AND"
  71                 }
  72
  73                 if name == "name" {
  74                         args += fmt.Sprintf(" name =~ %s", value)
  75                 } else {
  76                         args += fmt.Sprintf(" %s = %s", name, value)
  77                 }
  78         }
  79
  80         q, err := client.QueryString("LOOKUP %s MATCHING"+args, client.Identifier(raw.typ))
  81         if err != nil {
  82                 return nil, err
  83         }
  84         res, err := s.c.Query(q)
  85         if err != nil {
  86                 return nil, err
  87         }
  88         if t, ok := s.results[raw.typ]; ok {
  89                 return tmpl(t, res)
  90         }
  91         return nil, fmt.Errorf("Unsupported type %s", raw.typ)
  92 }
  93
  94 func fetch(req request, s *Server) (*page, error) {
  95         if len(req.args) == 0 {
  96                 return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
  97         }
  98
  99         var q string
 100         var err error
 101         switch req.cmd {
 102         case "host":
 103                 if len(req.args) != 1 {
 104                         return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
 105                 }
 106                 q, err = client.QueryString("FETCH host %s", req.args[0])
 107         case "service", "metric":
 108                 if len(req.args) != 2 {
 109                         return nil, fmt.Errorf("%s not found", strings.Title(req.cmd))
 110                 }
 111                 q, err = client.QueryString("FETCH %s %s.%s", client.Identifier(req.cmd), req.args[0], req.args[1])
 112         default:
 113                 panic("Unknown request: fetch(" + req.cmd + ")")
 114         }
 115         if err != nil {
 116                 return nil, err
 117         }
 118
 119         res, err := s.c.Query(q)
 120         if err != nil {
 121                 return nil, err
 122         }
 123         if req.cmd == "metric" {
 124                 return metric(req, res, s)
 125         }
 126         return tmpl(s.results[req.cmd], res)
 127 }
 128
 129 var datetime = "2006-01-02 15:04:05"
 130
 131 func metric(req request, res interface{}, s *Server) (*page, error) {
 132         start := time.Now().Add(-24 * time.Hour)
 133         end := time.Now()
 134         if req.r.Method == "POST" {
 135                 var err error
 136                 // Parse the values first to verify their format.
 137                 if s := req.r.PostForm.Get("start_date"); s != "" {
 138                         if start, err = time.Parse(datetime, s); err != nil {
 139                                 return nil, fmt.Errorf("Invalid start time %q", s)
 140                         }
 141                 }
 142                 if e := req.r.PostForm.Get("end_date"); e != "" {
 143                         if end, err = time.Parse(datetime, e); err != nil {
 144                                 return nil, fmt.Errorf("Invalid end time %q", e)
 145                         }
 146                 }
 147         }
 148
 149         p := struct {
 150                 StartTime string
 151                 EndTime   string
 152                 URLStart  string
 153                 URLEnd    string
 154                 Data      interface{}
 155         }{
 156                 start.Format(datetime),
 157                 end.Format(datetime),
 158                 start.Format(urldate),
 159                 end.Format(urldate),
 160                 res,
 161         }
 162         return tmpl(s.results["metric"], &p)
 163 }
 164
 165 type query struct {
 166         typ  string
 167         args map[string]string
 168 }
 169
 170 func (q *query) arg(name, value string) error {
 171         if _, ok := q.args[name]; ok {
 172                 return fmt.Errorf("Duplicate key %q", name)
 173         }
 174         q.args[name] = proto.EscapeString(value)
 175         return nil
 176 }
 177
 178 func (q *query) attr(parent, name, value string) error {
 179         var k string
 180         if parent != "" {
 181                 k = fmt.Sprintf("%s.attribute[%s]", parent, proto.EscapeString(name))
 182         } else {
 183                 k = fmt.Sprintf("attribute[%s]", proto.EscapeString(name))
 184         }
 185
 186         return q.arg(k, value)
 187 }
 188
 189 func parseQuery(s string) (*query, error) {
 190         tokens, err := tokenize(s)
 191         if err != nil {
 192                 return nil, err
 193         }
 194         if len(tokens) == 0 {
 195                 return nil, errors.New("Empty query")
 196         }
 197
 198         q := &query{typ: "hosts", args: make(map[string]string)}
 199         for i, tok := range tokens {
 200                 if fields := strings.SplitN(tok, ":", 2); len(fields) == 2 {
 201                         // Query: [<type>:] [<sibling-type>.]<attribute>:<value> ...
 202                         if i == 0 && fields[1] == "" {
 203                                 q.typ = fields[0]
 204                         } else if elems := strings.Split(fields[0], "."); len(elems) > 1 {
 205                                 objs := elems[:len(elems)-1]
 206                                 for _, o := range objs {
 207                                         if o != "host" && o != "service" && o != "metric" {
 208                                                 return nil, fmt.Errorf("Invalid object type %q", o)
 209                                         }
 210                                 }
 211                                 if err := q.attr(strings.Join(objs, "."), elems[len(elems)-1], fields[1]); err != nil {
 212                                         return nil, err
 213                                 }
 214                         } else {
 215                                 if err := q.attr("", fields[0], fields[1]); err != nil {
 216                                         return nil, err
 217                                 }
 218                         }
 219                 } else {
 220                         if err := q.arg("name", tok); err != nil {
 221                                 return nil, err
 222                         }
 223                 }
 224         }
 225         return q, nil
 226 }
 227
 228 // tokenize split the string s into its tokens where a token is either a quoted
 229 // string or surrounded by one or more consecutive whitespace characters.
 230 func tokenize(s string) ([]string, error) {
 231         scan := scanner{}
 232         tokens := []string{}
 233         start := -1
 234         for i, r := range s {
 235                 if !scan.inField(r) {
 236                         if start == -1 {
 237                                 // Skip leading and consecutive whitespace.
 238                                 continue
 239                         }
 240                         tok, err := unescape(s[start:i])
 241                         if err != nil {
 242                                 return nil, err
 243                         }
 244                         tokens = append(tokens, tok)
 245                         start = -1
 246                 } else if start == -1 {
 247                         // Found a new field.
 248                         start = i
 249                 }
 250         }
 251         if start >= 0 {
 252                 // Last (or possibly only) field.
 253                 tok, err := unescape(s[start:])
 254                 if err != nil {
 255                         return nil, err
 256                 }
 257                 tokens = append(tokens, tok)
 258         }
 259
 260         if scan.inQuotes {
 261                 return nil, errors.New("quoted string not terminated")
 262         }
 263         if scan.escaped {
 264                 return nil, errors.New("illegal character escape at end of string")
 265         }
 266         return tokens, nil
 267 }
 268
 269 func unescape(s string) (string, error) {
 270         var unescaped []byte
 271         var i, n int
 272         for i = 0; i < len(s); i++ {
 273                 if s[i] != '\\' {
 274                         n++
 275                         continue
 276                 }
 277
 278                 if i >= len(s) {
 279                         return "", errors.New("illegal character escape at end of string")
 280                 }
 281                 if s[i+1] != ' ' && s[i+1] != '"' && s[i+1] != '\\' {
 282                         // Allow simple escapes only for now.
 283                         return "", fmt.Errorf("illegal character escape \\%c", s[i+1])
 284                 }
 285                 if unescaped == nil {
 286                         unescaped = []byte(s)
 287                 }
 288                 copy(unescaped[n:], s[i+1:])
 289         }
 290
 291         if unescaped != nil {
 292                 return string(unescaped[:n]), nil
 293         }
 294         return s, nil
 295 }
 296
 297 type scanner struct {
 298         inQuotes bool
 299         escaped  bool
 300 }
 301
 302 func (s *scanner) inField(r rune) bool {
 303         if s.escaped {
 304                 s.escaped = false
 305                 return true
 306         }
 307         if r == '\\' {
 308                 s.escaped = true
 309                 return true
 310         }
 311         if s.inQuotes {
 312                 if r == '"' {
 313                         s.inQuotes = false
 314                         return false
 315                 }
 316                 return true
 317         }
 318         if r == '"' {
 319                 s.inQuotes = true
 320                 return false
 321         }
 322         return !unicode.IsSpace(r)
 323 }
 324
 325 // vim: set tw=78 sw=4 sw=4 noexpandtab :