path: root/importer.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 (
	"bufio"
	"bytes"
	"fmt"
	"github.com/golang-basic/go-curl"
	"mime/multipart"
	"net/http"
	"os"
	"path"
)

type ImportResult struct {
	ResponseCode int
	ErrorString  string
	Cart         uint
	Cut          uint
}

func (self *ImportResult) fromRDWebResult(rdres *RDWebResult) {
	self.ResponseCode = rdres.ResponseCode
	self.ErrorString = rdres.ErrorString
	if rdres.AudioConvertError != 0 {
		self.ErrorString += fmt.Sprintf(", Audio Convert Error: %d", rdres.AudioConvertError)
	}
}

func add_cart(ctx *ImportContext, res *ImportResult) (err error) {
	rhdl.Printf("importer: add_cart() called for cart: %d", ctx.Cart)

	if ctx.GroupName == "" {
		if err = ctx.getGroupOfCart(); err != nil {
			return
		}
	}

	var b bytes.Buffer
	w := multipart.NewWriter(&b)

	if err = w.WriteField("COMMAND", "12"); err != nil {
		return
	}
	if err = w.WriteField("LOGIN_NAME", ctx.UserName); err != nil {
		return
	}
	if err = w.WriteField("PASSWORD", ctx.Password); err != nil {
		return
	}
	if err = w.WriteField("GROUP_NAME", ctx.GroupName); err != nil {
		return
	}
	if err = w.WriteField("TYPE", "audio"); err != nil {
		return
	}
	if ctx.Cart != 0 {
		if err = w.WriteField("CART_NUMBER", fmt.Sprintf("%d", ctx.Cart)); err != nil {
			return
		}
	}
	w.Close()

	var resp *http.Response
	if resp, err = send_post_request(ctx.conf.RDXportEndpoint, &b, w.FormDataContentType()); err != nil {
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		var rdres *RDWebResult
		if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
			return
		}
		res.fromRDWebResult(rdres)
		res.Cart = ctx.Cart
		return
	}
	var cartadd *RDCartAdd
	if cartadd, err = NewRDCartAddFromXML(resp.Body); err != nil {
		return
	}
	res.ResponseCode = resp.StatusCode
	res.ErrorString = "OK"
	res.Cart = cartadd.Carts[0].Number
	ctx.Cart = res.Cart
	return
}

func add_cut(ctx *ImportContext, res *ImportResult) (err error) {
	rhdl.Printf("importer: add_cut() called for cart/cut: %d/%d", ctx.Cart, ctx.Cut)
	var b bytes.Buffer
	w := multipart.NewWriter(&b)

	if err = w.WriteField("COMMAND", "10"); err != nil {
		return
	}
	if err = w.WriteField("LOGIN_NAME", ctx.UserName); err != nil {
		return
	}
	if err = w.WriteField("PASSWORD", ctx.Password); err != nil {
		return
	}
	if err = w.WriteField("CART_NUMBER", fmt.Sprintf("%d", ctx.Cart)); err != nil {
		return
	}
	w.Close()

	var resp *http.Response
	if resp, err = send_post_request(ctx.conf.RDXportEndpoint, &b, w.FormDataContentType()); err != nil {
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		var rdres *RDWebResult
		if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
			return
		}
		res.fromRDWebResult(rdres)
		res.Cart = ctx.Cart
		res.Cut = ctx.Cut
		return
	}
	var cutadd *RDCutAdd
	if cutadd, err = NewRDCutAddFromXML(resp.Body); err != nil {
		return
	}
	res.ResponseCode = resp.StatusCode
	res.ErrorString = "OK"
	res.Cart = ctx.Cart
	res.Cut = cutadd.Cuts[0].Number
	ctx.Cut = cutadd.Cuts[0].Number
	return
}

func remove_cart(ctx *ImportContext, res *ImportResult) (err error) {
	rhdl.Printf("importer: remove_cart() called for cart: %d", ctx.Cart)
	var b bytes.Buffer
	w := multipart.NewWriter(&b)

	if err = w.WriteField("COMMAND", "13"); err != nil {
		return
	}
	if err = w.WriteField("LOGIN_NAME", ctx.UserName); err != nil {
		return
	}
	if err = w.WriteField("PASSWORD", ctx.Password); err != nil {
		return
	}
	if err = w.WriteField("CART_NUMBER", fmt.Sprintf("%d", ctx.Cart)); err != nil {
		return
	}
	w.Close()

	var resp *http.Response
	if resp, err = send_post_request(ctx.conf.RDXportEndpoint, &b, w.FormDataContentType()); err != nil {
		return
	}
	defer resp.Body.Close()

	var rdres *RDWebResult
	if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
		return
	}
	res.fromRDWebResult(rdres)
	res.Cart = ctx.Cart
	return
}

func remove_cut(ctx *ImportContext, res *ImportResult) (err error) {
	rhdl.Printf("importer: remove_cut() called for cart/cut: %d/%d", ctx.Cart, ctx.Cut)
	var b bytes.Buffer
	w := multipart.NewWriter(&b)

	if err = w.WriteField("COMMAND", "11"); err != nil {
		return
	}
	if err = w.WriteField("LOGIN_NAME", ctx.UserName); err != nil {
		return
	}
	if err = w.WriteField("PASSWORD", ctx.Password); err != nil {
		return
	}
	if err = w.WriteField("CART_NUMBER", fmt.Sprintf("%d", ctx.Cart)); err != nil {
		return
	}
	if err = w.WriteField("CUT_NUMBER", fmt.Sprintf("%d", ctx.Cut)); err != nil {
		return
	}
	w.Close()

	var resp *http.Response
	if resp, err = send_post_request(ctx.conf.RDXportEndpoint, &b, w.FormDataContentType()); err != nil {
		return
	}
	defer resp.Body.Close()

	var rdres *RDWebResult
	if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
		return
	}
	res.fromRDWebResult(rdres)
	res.Cart = ctx.Cart
	res.Cut = ctx.Cut
	return
}

func send_post_request(url string, b *bytes.Buffer, contenttype string) (resp *http.Response, err error) {
	var req *http.Request
	if req, err = http.NewRequest("POST", url, b); err != nil {
		return
	}
	if contenttype != "" {
		req.Header.Set("Content-Type", contenttype)
	}

	client := &http.Client{}
	if resp, err = client.Do(req); err != nil {
		return
	}
	return
}

func import_audio_create_request(ctx *ImportContext, easy *curl.CURL) (form *curl.Form, err error) {
	form = curl.NewForm()

	if err = form.Add("COMMAND", "2"); err != nil {
		return
	}
	if err = form.Add("LOGIN_NAME", ctx.UserName); err != nil {
		return
	}
	if err = form.Add("PASSWORD", ctx.Password); err != nil {
		return
	}
	if err = form.Add("CART_NUMBER", fmt.Sprintf("%d", ctx.Cart)); err != nil {
		return
	}
	if err = form.Add("CUT_NUMBER", fmt.Sprintf("%d", ctx.Cut)); err != nil {
		return
	}
	if err = form.Add("CHANNELS", fmt.Sprintf("%d", ctx.Channels)); err != nil {
		return
	}
	if err = form.Add("NORMALIZATION_LEVEL", fmt.Sprintf("%d", ctx.NormalizationLevel)); err != nil {
		return
	}
	if err = form.Add("AUTOTRIM_LEVEL", fmt.Sprintf("%d", ctx.AutotrimLevel)); err != nil {
		return
	}
	if err = form.Add("USE_METADATA", bool2str[ctx.UseMetaData]); err != nil {
		return
	}
	if err = form.AddFile("FILENAME", ctx.SourceFile); err != nil {
		return
	}

	return
}

func import_audio(ctx *ImportContext, res *ImportResult) (err error) {
	rhdl.Printf("importer: import_audio() called for cart/cut: %d/%d", ctx.Cart, ctx.Cut)
	easy := curl.EasyInit()

	if easy != nil {
		defer easy.Cleanup()

		easy.Setopt(curl.OPT_URL, ctx.conf.RDXportEndpoint)
		easy.Setopt(curl.OPT_POST, true)

		var form *curl.Form
		if form, err = import_audio_create_request(ctx, easy); err != nil {
			return
		}
		easy.Setopt(curl.OPT_HTTPPOST, form)
		easy.Setopt(curl.OPT_HTTPHEADER, []string{"Expect:"})

		var resbody bytes.Buffer
		easy.Setopt(curl.OPT_WRITEFUNCTION, func(ptr []byte, userdata interface{}) bool {
			b := userdata.(*bytes.Buffer)
			b.Write(ptr)
			return true
		})
		easy.Setopt(curl.OPT_WRITEDATA, &resbody)

		easy.Setopt(curl.OPT_NOPROGRESS, false)
		easy.Setopt(curl.OPT_PROGRESSFUNCTION, func(dltotal, dlnow, ultotal, ulnow float64, userdata interface{}) bool {
			if ctx.Cancel != nil && len(ctx.Cancel) > 0 {
				res.ResponseCode = http.StatusNoContent
				res.ErrorString = "canceled"
				return false
			}

			if ctx.ProgressCallBack != nil {
				if keep := ctx.ProgressCallBack(2, "importing", ulnow/ultotal, ctx.ProgressCallBackData); !keep {
					ctx.ProgressCallBack = nil
				}
			}
			return true
		})
		easy.Setopt(curl.OPT_PROGRESSDATA, ctx)

		if err = easy.Perform(); err != nil {
			if res.ResponseCode == http.StatusNoContent {
				rhl.Printf("import to cart/cat %d/%d got canceled", ctx.Cart, ctx.Cut)
				res.Cart = ctx.Cart
				res.Cut = ctx.Cut
				err = nil
			} else {
				err = fmt.Errorf("importer: %s", err)
			}
			return
		}

		var rdres *RDWebResult
		if rdres, err = NewRDWebResultFromXML(bufio.NewReader(&resbody)); err != nil {
			return
		}
		res.fromRDWebResult(rdres)
		res.Cart = ctx.Cart
		res.Cut = ctx.Cut
	} else {
		err = fmt.Errorf("Error initializing libcurl")
	}

	return
}

func add_cart_cut(ctx *ImportContext, res *ImportResult) (err error) {
	if err = add_cart(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
		return
	}
	if err = add_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
		return remove_cart(ctx, &ImportResult{ResponseCode: http.StatusOK})
	}
	return
}

func remove_add_cart_cut(ctx *ImportContext, res *ImportResult) (err error) {
	if err = remove_cart(ctx, res); err != nil || (res.ResponseCode != http.StatusOK && res.ResponseCode != http.StatusNotFound) {
		return
	}
	return add_cart_cut(ctx, res)
}

func is_cart_member_of_show(ctx *ImportContext, res *ImportResult, carts []uint) (found bool) {
	if ctx.Cart == 0 {
		return true
	}
	for _, cart := range carts {
		if cart == ctx.Cart {
			return true
		}
	}
	res.ResponseCode = http.StatusBadRequest
	res.ErrorString = fmt.Sprintf("Requested cart %d is not a member of show: %d", ctx.Cart, ctx.ShowId)
	res.Cart = ctx.Cart
	return false
}

func clear_show_carts(ctx *ImportContext, res *ImportResult, carts []uint) (err error) {
	if ctx.ClearShowCarts {
		orig_cart := ctx.Cart
		for _, cart := range carts {
			ctx.Cart = cart
			if err = remove_cart(ctx, res); err != nil || (res.ResponseCode != http.StatusOK && res.ResponseCode != http.StatusNotFound) {
				return
			}
		}
		ctx.Cart = orig_cart
	}
	return
}

func add_show_cart_cut(ctx *ImportContext, res *ImportResult, carts []uint) (err error) {
	if err = add_cart(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
		return
	}
	for _, cart := range carts {
		if cart == ctx.Cart {
			if err = add_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
				return remove_cart(ctx, &ImportResult{ResponseCode: http.StatusOK})
			}
			return
		}
	}
	if err = remove_cart(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
		return
	}
	res.ResponseCode = http.StatusForbidden
	res.ErrorString = fmt.Sprintf("Show %d has no free carts left", ctx.ShowId)
	return
}

func cleanup_files(ctx *ImportContext) {
	if ctx.DeleteSourceFile {
		rhdl.Printf("importer: removing file: %s", ctx.SourceFile)
		if err := os.Remove(ctx.SourceFile); err != nil {
			rhl.Printf("importer: error removing source file: %s", err)
			return
		}
		if ctx.DeleteSourceDir {
			dir := path.Dir(ctx.SourceFile)
			rhdl.Printf("importer: also removing directory: %s", dir)
			if err := os.Remove(dir); err != nil {
				rhl.Printf("importer: error removing source directory: %s", err)
			}
		}
	}
	return
}

func ImportFile(ctx *ImportContext) (res *ImportResult, err error) {
	defer cleanup_files(ctx)

	rhl.Printf("importer: ImportFile called with: show-id: %d, pool-name: '%s', cart/cut: %d/%d", ctx.ShowId, ctx.GroupName, ctx.Cart, ctx.Cut)

	if ctx.ProgressCallBack != nil {
		if keep := ctx.ProgressCallBack(2, "importing", 0.0, ctx.ProgressCallBackData); !keep {
			ctx.ProgressCallBack = nil
		}
	}

	// TODO: on trusted interfaces we should call getPassword again with cached=false after 401's
	if ctx.Trusted {
		if err = ctx.getPassword(true); err != nil {
			return
		}
	}

	rmCartOnErr := false
	rmCutOnErr := false
	res = &ImportResult{ResponseCode: http.StatusOK}
	if ctx.ShowId != 0 { // Import to a show
		var show_carts []uint
		if show_carts, err = ctx.getShowInfo(); err != nil {
			return
		}
		if !is_cart_member_of_show(ctx, res, show_carts) {
			return
		}
		if err = clear_show_carts(ctx, res, show_carts); err != nil || (res.ResponseCode != http.StatusOK && res.ResponseCode != http.StatusNotFound) {
			return
		}
		if ctx.ClearCart && !ctx.ClearShowCarts {
			if err = remove_add_cart_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
				return
			}
		} else {
			if err = add_show_cart_cut(ctx, res, show_carts); err != nil || res.ResponseCode != http.StatusOK {
				return
			}
		}
		rmCartOnErr = true
	} else if ctx.GroupName != "" { // Import to music pool
		if err = ctx.getMusicInfo(); err != nil {
			return
		}
		if err = add_cart_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
			return
		}
		rmCartOnErr = true
	} else if ctx.Cart != 0 && ctx.Cut == 0 { // Import to Cart
		if ctx.ClearCart {
			if err = remove_add_cart_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
				return
			}
			rmCartOnErr = true
		} else {
			if err = add_cut(ctx, res); err != nil {
				return
			}
			if res.ResponseCode != http.StatusOK {
				if err = add_cart_cut(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
					return
				}
				rmCartOnErr = true
			} else {
				rmCutOnErr = true
			}
		}
	}

	if ctx.Cart != 0 && ctx.Cut != 0 { // Import to specific Cut within Cart
		if err = import_audio(ctx, res); err != nil || res.ResponseCode != http.StatusOK {
			if err != nil {
				rhl.Printf("Fileimport has failed (Cart/Cut %d/%d): %s", ctx.Cart, ctx.Cut, err)
			} else {
				rhl.Printf("Fileimport has failed (Cart/Cut %d/%d): %s", res.Cart, res.Cut, res.ErrorString)
			}
			// Try to clean up after failed import
			rmres := ImportResult{ResponseCode: http.StatusOK}
			if rmCartOnErr {
				if rerr := remove_cart(ctx, &rmres); rerr != nil {
					return
				}
			} else if rmCutOnErr {
				if rerr := remove_cut(ctx, &rmres); rerr != nil {
					return
				}
			}
		} else {
			rhl.Printf("File got succesfully imported into Cart/Cut %d/%d", res.Cart, res.Cut)
		}
	} else {
		res.ResponseCode = http.StatusBadRequest
		res.ErrorString = "importer: The request doesn't contain enough information to be processed"
	}

	return
}