Gosearch

gosearch.go

/*
Python Client

import socket
import json
s.sendall(json.dumps({"method":"Search.Search", "params":[{"UserQuery":"providencia 229"}], "id":uuid.uuid4().hex})); print s.recv(1024)
*/
package main

import (
        "os"
        "log"
        "flag"
        "time"
        "database/sql"
        "net"
        "net/rpc"
        "net/rpc/jsonrpc"
        _ "github.com/go-sql-driver/mysql"
)

var (
        addr = flag.String("addr", ":8081", "Default address to listen on.")
)

type Search int

type SearchQuery struct {
        UserQuery string
}

type SearchResult struct {
        Title string
        Id int32
        PriceFormatted string
        UserId uint32
        Lat float32
        Lon float32
        Score float32
}

type SearchResults struct {
        Query SearchQuery
        TotalResults uint16
        Time int64
        Results []SearchResult
}

func QueryResults(query *SearchQuery) []SearchResult {
        db, err := sql.Open("mysql", os.Getenv("GOS_DB"))
        if err != nil {
                log.Fatal("Could not open database using mysql driver")
        }
        rows, err := db.Query("SELECT id, title, lat, lon FROM spaces WHERE id = ?", query.UserQuery)
        if err != nil {
                log.Println("SQL Error", err)
        }
        slice := []SearchResult{}  // This should alloc according to num_results
        for rows.Next() {
                var (
                        id int32
                        title string
                        lat float32
                        lon float32
                )
                rows.Scan(&id, &title, &lat, &lon)
                slice = append(slice, SearchResult{
                        Title: title,
                        Id: id,
                        Lat: lat,
                        Lon: lon,
                })
        }
        return slice
}

func (s *Search) Search(request *SearchQuery, response *SearchResults) error {
        log.Printf("Dispatch Search: %s", request.UserQuery)

        start := time.Now()

        slice := QueryResults(request)

        response.Query = *request
        response.TotalResults = 1
        response.Results = slice

        took := time.Since(start)
        response.Time = took.Nanoseconds()
        log.Printf("Took %v", took.String())
        return nil
}

func main() {
        flag.Parse()
        log.Printf("Starting RPC server at %s.", *addr)
        lis, err := net.Listen("tcp", *addr)
        if err != nil {
                log.Fatal("Listener error:", err)
        }
        s := new(Search)
        server := rpc.NewServer()
        server.Register(s)
        server.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)

        for {
                conn, err := lis.Accept()
                if err != nil {
                        log.Fatal("Conn accept error:", err)
                }
                go server.ServeCodec(jsonrpc.NewServerCodec(conn))
        }
}