path: root/src/helsinki.at/rhimport/rddb.go

//
//  rhimportd
//
//  The Radio Helsinki Rivendell Import Daemon
//
//
//  Copyright (C) 2015 Christian Pointner <equinox@helsinki.at>
//
//  This file is part of rhimportd.
//
//  rhimportd is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  any later version.
//
//  rhimportd is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with rhimportd. If not, see <http://www.gnu.org/licenses/>.
//

package rhimport

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

type getPasswordResult struct {
	password string
	err      error
}

type getPasswordRequest struct {
	username string
	cached   bool
	response chan getPasswordResult
}

type getGroupOfCartResult struct {
	group string
	err   error
}

type getGroupOfCartRequest struct {
	cart     uint
	response chan getGroupOfCartResult
}

type getShowInfoResult struct {
	title string
	carts map[int]int
	err   error
}

type getShowInfoRequest struct {
	showid   int
	response chan getShowInfoResult
}

type checkMusicGroupResult struct {
	ismusic bool
	err     error
}

type checkMusicGroupRequest struct {
	group    string
	response chan checkMusicGroupResult
}

type RdDb struct {
	dbh                 *sql.DB
	password_cache      map[string]string
	getPasswordChan     chan getPasswordRequest
	getPasswordStmt     *sql.Stmt
	getGroupOfCartChan  chan getGroupOfCartRequest
	getGroupOfCartStmt  *sql.Stmt
	getShowInfoChan     chan getShowInfoRequest
	getShowInfoStmt     *sql.Stmt
	checkMusicGroupChan chan checkMusicGroupRequest
	checkMusicGroupStmt *sql.Stmt
	quit                chan bool
	done                chan bool
}

func (self *RdDb) init(conf *Config) (err error) {
	dsn := fmt.Sprintf("%s:%s@tcp(%s:3306)/%s", conf.db_user, conf.db_passwd, conf.db_host, conf.db_db)
	if self.dbh, err = sql.Open("mysql", dsn); err != nil {
		return
	}
	if self.getPasswordStmt, err = self.dbh.Prepare("select PASSWORD from USERS where LOGIN_NAME = ?;"); err != nil {
		return
	}
	if self.getGroupOfCartStmt, err = self.dbh.Prepare("select NAME,DEFAULT_LOW_CART,DEFAULT_HIGH_CART from GROUPS where DEFAULT_LOW_CART <= ? and DEFAULT_HIGH_CART >= ?;"); err != nil {
		return
	}
	if self.getShowInfoStmt, err = self.dbh.Prepare("select TITLE,MACROS from CART where NUMBER = ?;"); err != nil {
		return
	}
	if self.checkMusicGroupStmt, err = self.dbh.Prepare("select count(*) from DROPBOXES where GROUP_NAME = ? and SET_USER_DEFINED like \"M;%\";"); err != nil {
		return
	}
	return
}

func (self *RdDb) getPassword(username string, cached bool) (pwd string, err error) {
	if cached {
		pwd = self.password_cache[username]
	}

	if pwd == "" {
		err = self.getPasswordStmt.QueryRow(username).Scan(&pwd)
		if err != nil {
			if err == sql.ErrNoRows {
				err = fmt.Errorf("user '%s' not known by rivendell", username)
			}
			return
		}
		self.password_cache[username] = pwd
	}

	return
}

func (self *RdDb) getGroupOfCart(cart uint) (group string, err error) {
	var rows *sql.Rows
	if rows, err = self.getGroupOfCartStmt.Query(cart, cart); err != nil {
		return
	}
	defer rows.Close()
	size_min := ^uint(0)
	for rows.Next() {
		var name string
		var low_cart, high_cart uint
		if err = rows.Scan(&name, &low_cart, &high_cart); err != nil {
			return
		}
		if high_cart >= low_cart {
			size := (high_cart - low_cart) + 1
			if size_min > size {
				group = name
				size_min = size
			}
		}
	}
	if err = rows.Err(); err != nil {
		return
	}
	if group == "" {
		err = fmt.Errorf("cart is outside of all group cart ranges")
	}
	return
}

func (self *RdDb) getShowInfo(showid int) (title string, carts map[int]int, err error) {
	var macros string
	err = self.getShowInfoStmt.QueryRow(showid).Scan(&title, &macros)
	if err != nil {
		if err == sql.ErrNoRows {
			err = fmt.Errorf("show '%d' not found", showid)
		}
		return
	}

	rhdl.Printf("RdDb: macros for showid '%d' are set to '%s'", showid, macros)
	// TODO: also fetch cart list and import params (norm_level, ...)
	carts = make(map[int]int)
	return
}

func (self *RdDb) checkMusicGroup(group string) (ismusic bool, err error) {
	var cnt int
	err = self.checkMusicGroupStmt.QueryRow(group).Scan(&cnt)
	if err != nil {
		if err == sql.ErrNoRows {
			err = nil
			ismusic = false
		}
		return
	}
	ismusic = cnt > 0
	return
}

func (self *RdDb) dispatchRequests() {
	defer func() { self.done <- true }()
	for {
		select {
		case <-self.quit:
			return
		case req := <-self.getPasswordChan:
			if req.cached {
				rhdl.Println("RdDb: got getPassword request for", req.username, "(cached)")
			} else {
				rhdl.Println("RdDb: got getPassword request for", req.username, "(not cached)")
			}
			pwd, err := self.getPassword(req.username, req.cached)
			req.response <- getPasswordResult{pwd, err}
		case req := <-self.getGroupOfCartChan:
			rhdl.Println("RdDb: got getGroupOfCart request for", req.cart)
			group, err := self.getGroupOfCart(req.cart)
			req.response <- getGroupOfCartResult{group, err}
		case req := <-self.getShowInfoChan:
			rhdl.Println("RdDb: got getShowInfo request for", req.showid)
			title, carts, err := self.getShowInfo(req.showid)
			req.response <- getShowInfoResult{title, carts, err}
		case req := <-self.checkMusicGroupChan:
			rhdl.Println("RdDb: got checkMusicGroup request for", req.group)
			ismusic, err := self.checkMusicGroup(req.group)
			req.response <- checkMusicGroupResult{ismusic, err}
		}
	}
}

func (self *RdDb) Cleanup() {
	self.quit <- true
	<-self.done
	close(self.quit)
	close(self.done)
	close(self.getPasswordChan)
	if self.dbh != nil {
		self.dbh.Close()
	}
	if self.getPasswordStmt != nil {
		self.getPasswordStmt.Close()
	}
	if self.getGroupOfCartStmt != nil {
		self.getGroupOfCartStmt.Close()
	}
	if self.getShowInfoStmt != nil {
		self.getShowInfoStmt.Close()
	}
	if self.checkMusicGroupStmt != nil {
		self.checkMusicGroupStmt.Close()
	}
}

func NewRdDb(conf *Config) (db *RdDb, err error) {
	db = new(RdDb)

	db.quit = make(chan bool)
	db.done = make(chan bool)
	db.password_cache = make(map[string]string)
	db.getPasswordChan = make(chan getPasswordRequest)
	db.getGroupOfCartChan = make(chan getGroupOfCartRequest)
	db.getShowInfoChan = make(chan getShowInfoRequest)
	db.checkMusicGroupChan = make(chan checkMusicGroupRequest)

	if err = db.init(conf); err != nil {
		return
	}

	go db.dispatchRequests()
	return
}