summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--rhimport/bs1770_responses.go46
-rw-r--r--rhimport/conf.go2
-rw-r--r--rhimport/converter.go104
-rw-r--r--rhimport/core.go12
-rw-r--r--rhimport/fetcher.go40
-rw-r--r--rhimport/importer.go30
-rw-r--r--rhimport/rdxport_responses.go26
-rw-r--r--rhimport/session.go272
-rw-r--r--rhimport/session_store.go66
-rw-r--r--rhimport/wave_generator.go62
-rw-r--r--rhimport/youtubedl_responses.go6
11 files changed, 333 insertions, 333 deletions
diff --git a/rhimport/bs1770_responses.go b/rhimport/bs1770_responses.go
index b254b9c..b0a66fe 100644
--- a/rhimport/bs1770_responses.go
+++ b/rhimport/bs1770_responses.go
@@ -30,57 +30,57 @@ import (
"io"
)
-type BS1770Result struct {
- Album BS1770ResultAlbum `xml:"album"`
+type bs1770Result struct {
+ Album bs1770ResultAlbum `xml:"album"`
}
-type BS1770ResultAlbum struct {
- Tracks []BS1770ResultTrack `xml:"track"`
- Summary BS1770ResultSummary `xml:"summary"`
+type bs1770ResultAlbum struct {
+ Tracks []bs1770ResultTrack `xml:"track"`
+ Summary bs1770ResultSummary `xml:"summary"`
}
-type BS1770ResultTrack struct {
+type bs1770ResultTrack struct {
Total uint `xml:"total,attr"`
Number uint `xml:"number,attr"`
File string `xml:"file,attr"`
- Integrated BS1770ResultValueLUFS `xml:"integrated"`
- Momentary BS1770ResultValueLUFS `xml:"momentary"`
- ShorttermMaximum BS1770ResultValueLUFS `xml:"shortterm-maximum"`
- SamplePeak BS1770ResultValueSPFS `xml:"sample-peak"`
- TruePeak BS1770ResultValueTPFS `xml:"true-peak"`
+ Integrated bs1770ResultValueLUFS `xml:"integrated"`
+ Momentary bs1770ResultValueLUFS `xml:"momentary"`
+ ShorttermMaximum bs1770ResultValueLUFS `xml:"shortterm-maximum"`
+ SamplePeak bs1770ResultValueSPFS `xml:"sample-peak"`
+ TruePeak bs1770ResultValueTPFS `xml:"true-peak"`
}
-type BS1770ResultSummary struct {
+type bs1770ResultSummary struct {
Total uint `xml:"total,attr"`
- Integrated BS1770ResultValueLUFS `xml:"integrated"`
- Momentary BS1770ResultValueLUFS `xml:"momentary"`
- ShorttermMaximum BS1770ResultValueLUFS `xml:"shortterm-maximum"`
- SamplePeak BS1770ResultValueSPFS `xml:"sample-peak"`
- TruePeak BS1770ResultValueTPFS `xml:"true-peak"`
+ Integrated bs1770ResultValueLUFS `xml:"integrated"`
+ Momentary bs1770ResultValueLUFS `xml:"momentary"`
+ ShorttermMaximum bs1770ResultValueLUFS `xml:"shortterm-maximum"`
+ SamplePeak bs1770ResultValueSPFS `xml:"sample-peak"`
+ TruePeak bs1770ResultValueTPFS `xml:"true-peak"`
}
-type BS1770ResultValueLUFS struct {
+type bs1770ResultValueLUFS struct {
LUFS float64 `xml:"lufs,attr"`
LU float64 `xml:"lu,attr"`
}
-type BS1770ResultValueRange struct {
+type bs1770ResultValueRange struct {
LUFS float64 `xml:"lufs,attr"`
}
-type BS1770ResultValueSPFS struct {
+type bs1770ResultValueSPFS struct {
SPFS float64 `xml:"spfs,attr"`
Factor float64 `xml:"factor,attr"`
}
-type BS1770ResultValueTPFS struct {
+type bs1770ResultValueTPFS struct {
TPFS float64 `xml:"tpfs,attr"`
Factor float64 `xml:"factor,attr"`
}
-func NewBS1770ResultFromXML(data io.Reader) (res *BS1770Result, err error) {
+func newBS1770ResultFromXML(data io.Reader) (res *bs1770Result, err error) {
decoder := xml.NewDecoder(data)
- res = &BS1770Result{}
+ res = &bs1770Result{}
if xmlerr := decoder.Decode(res); xmlerr != nil {
err = fmt.Errorf("Error parsing XML response: %s", xmlerr)
return
diff --git a/rhimport/conf.go b/rhimport/conf.go
index 502882d..f141a78 100644
--- a/rhimport/conf.go
+++ b/rhimport/conf.go
@@ -78,7 +78,7 @@ func (c *Config) readConfigFile() error {
}
func NewConfig(configfile, rdxportEndpoint, tempDir, localFetchDir string) (conf *Config, err error) {
- conf = new(Config)
+ conf = &Config{}
conf.ConfigFile = configfile
conf.RDXportEndpoint = rdxportEndpoint
conf.TempDir = tempDir
diff --git a/rhimport/converter.go b/rhimport/converter.go
index e53da9c..d9ac263 100644
--- a/rhimport/converter.go
+++ b/rhimport/converter.go
@@ -37,31 +37,31 @@ import (
"strings"
)
-type FetchConverter interface {
+type fetchConverter interface {
io.WriteCloser
GetResult(ctx *Context, res *Result) (result string, err error)
}
-type FetchConverterResult struct {
+type fetchConverterResult struct {
output string
err error
loudnessCorr float64
}
-func NewFetchConverter(ctx *Context, filename string, metadata map[string]string) (FetchConverter, string, error) {
+func newFetchConverter(ctx *Context, filename string, metadata map[string]string) (fetchConverter, string, error) {
switch ctx.FetchConverter {
case "null":
// no support for loudness evaluation - leave normalization to Rivendell
- return NewNullFetchConverter(ctx, filename, metadata)
+ return newNullFetchConverter(ctx, filename, metadata)
case "ffmpeg":
// no support for loudness evaluation - leave normalization to Rivendell
- return NewFFMpegFetchConverter(ctx, filename, metadata)
+ return newFFMpegFetchConverter(ctx, filename, metadata)
case "bs1770":
ctx.NormalizationLevel = 0 // disable Rivendell normalization
- return NewBS1770FetchConverter(ctx, filename, metadata)
+ return newBS1770FetchConverter(ctx, filename, metadata)
case "ffmpeg-bs1770":
ctx.NormalizationLevel = 0 // disable Rivendell normalization
- return NewFFMpegBS1770FetchConverter(ctx, filename, metadata)
+ return newFFMpegBS1770FetchConverter(ctx, filename, metadata)
}
return nil, "", errors.New("unknown fetch converter type: " + ctx.FetchConverter)
}
@@ -70,27 +70,27 @@ func NewFetchConverter(ctx *Context, filename string, metadata map[string]string
// NUll Converter aka File Writer
//
-type NullFetchConverter struct {
+type nullFetchConverter struct {
file *os.File
}
-func NewNullFetchConverter(ctx *Context, filename string, metadata map[string]string) (n *NullFetchConverter, newFilename string, err error) {
- n = &NullFetchConverter{}
+func newNullFetchConverter(ctx *Context, filename string, metadata map[string]string) (n *nullFetchConverter, newFilename string, err error) {
+ n = &nullFetchConverter{}
newFilename = filepath.Dir(filename) + "/conv-null" + filepath.Ext(filename)
ctx.stdlog.Printf("null-converter: opening file '%s' -> '%s'", filename, newFilename)
n.file, err = os.OpenFile(newFilename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
return
}
-func (c *NullFetchConverter) Write(p []byte) (n int, err error) {
+func (c *nullFetchConverter) Write(p []byte) (n int, err error) {
return c.file.Write(p)
}
-func (c *NullFetchConverter) Close() (err error) {
+func (c *nullFetchConverter) Close() (err error) {
return c.file.Close()
}
-func (c *NullFetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
+func (c *nullFetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
return "", nil
}
@@ -98,14 +98,14 @@ func (c *NullFetchConverter) GetResult(ctx *Context, res *Result) (result string
// FFMpeg Converter: converts all files into flac
//
-type FFMpegFetchConverter struct {
+type ffmpegFetchConverter struct {
cmd *exec.Cmd
pipe io.WriteCloser
- result chan FetchConverterResult
+ result chan fetchConverterResult
}
-func NewFFMpegFetchConverter(ctx *Context, filename string, metadata map[string]string) (ff *FFMpegFetchConverter, filenameFlac string, err error) {
- ff = &FFMpegFetchConverter{}
+func newFFMpegFetchConverter(ctx *Context, filename string, metadata map[string]string) (ff *ffmpegFetchConverter, filenameFlac string, err error) {
+ ff = &ffmpegFetchConverter{}
filenameFlac = filepath.Dir(filename) + "/conv-ffmpeg.flac"
ctx.stdlog.Printf("ffmpeg-converter: starting ffmpeg for file '%s' -> '%s'", filename, filenameFlac)
ff.cmd = exec.Command("ffmpeg", "-loglevel", "warning", "-i", "-", "-map_metadata", "0")
@@ -119,23 +119,23 @@ func NewFFMpegFetchConverter(ctx *Context, filename string, metadata map[string]
return nil, "", err
}
- ff.result = make(chan FetchConverterResult, 1)
+ ff.result = make(chan fetchConverterResult, 1)
go func() {
output, err := ff.cmd.CombinedOutput()
- ff.result <- FetchConverterResult{strings.TrimSpace(string(output)), err, 0.0}
+ ff.result <- fetchConverterResult{strings.TrimSpace(string(output)), err, 0.0}
}()
return
}
-func (ff *FFMpegFetchConverter) Write(p []byte) (n int, err error) {
+func (ff *ffmpegFetchConverter) Write(p []byte) (n int, err error) {
return ff.pipe.Write(p)
}
-func (ff *FFMpegFetchConverter) Close() (err error) {
+func (ff *ffmpegFetchConverter) Close() (err error) {
return ff.pipe.Close()
}
-func (ff *FFMpegFetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
+func (ff *ffmpegFetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
if ff.result != nil {
select {
case r := <-ff.result:
@@ -155,16 +155,16 @@ func (ff *FFMpegFetchConverter) GetResult(ctx *Context, res *Result) (result str
// BS1770 Converter: calculates loudness correction value using ITU BS1770 (EBU R128)
//
-type BS1770FetchConverter struct {
+type bs1770FetchConverter struct {
cmd *exec.Cmd
file *os.File
pipe io.WriteCloser
multi io.Writer
- result chan FetchConverterResult
+ result chan fetchConverterResult
}
-func NewBS1770FetchConverter(ctx *Context, filename string, metadata map[string]string) (bs *BS1770FetchConverter, newFilename string, err error) {
- bs = &BS1770FetchConverter{}
+func newBS1770FetchConverter(ctx *Context, filename string, metadata map[string]string) (bs *bs1770FetchConverter, newFilename string, err error) {
+ bs = &bs1770FetchConverter{}
newFilename = filepath.Dir(filename) + "/conv-bs1770" + filepath.Ext(filename)
ctx.stdlog.Printf("bs1770-converter: starting bs1770gain for file '%s' -> '%s'", filename, newFilename)
bs.file, err = os.OpenFile(newFilename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
@@ -179,31 +179,31 @@ func NewBS1770FetchConverter(ctx *Context, filename string, metadata map[string]
bs.cmd.Stdout = &bsStdout
bs.cmd.Stderr = &bsStderr
- bs.result = make(chan FetchConverterResult, 1)
+ bs.result = make(chan fetchConverterResult, 1)
go func() {
if err := bs.cmd.Run(); err != nil {
- bs.result <- FetchConverterResult{strings.TrimSpace(string(bsStderr.String())), err, 0.0}
+ bs.result <- fetchConverterResult{strings.TrimSpace(string(bsStderr.String())), err, 0.0}
}
- res, err := NewBS1770ResultFromXML(&bsStdout)
+ res, err := newBS1770ResultFromXML(&bsStdout)
if err != nil {
- bs.result <- FetchConverterResult{bsStdout.String(), err, 0.0}
+ bs.result <- fetchConverterResult{bsStdout.String(), err, 0.0}
return
}
if len(res.Album.Tracks) == 0 {
- bs.result <- FetchConverterResult{bsStdout.String(), fmt.Errorf("bs1770gain returned no/invalid result"), 0.0}
+ bs.result <- fetchConverterResult{bsStdout.String(), fmt.Errorf("bs1770gain returned no/invalid result"), 0.0}
return
}
- bs.result <- FetchConverterResult{"", nil, res.Album.Tracks[0].Integrated.LU}
+ bs.result <- fetchConverterResult{"", nil, res.Album.Tracks[0].Integrated.LU}
}()
return
}
-func (bs *BS1770FetchConverter) Write(p []byte) (n int, err error) {
+func (bs *bs1770FetchConverter) Write(p []byte) (n int, err error) {
return bs.multi.Write(p)
}
-func (bs *BS1770FetchConverter) Close() (err error) {
+func (bs *bs1770FetchConverter) Close() (err error) {
errPipe := bs.pipe.Close()
errFile := bs.file.Close()
if errFile != nil {
@@ -212,7 +212,7 @@ func (bs *BS1770FetchConverter) Close() (err error) {
return errPipe
}
-func (bs *BS1770FetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
+func (bs *bs1770FetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
if bs.result != nil {
select {
case r := <-bs.result:
@@ -233,16 +233,16 @@ func (bs *BS1770FetchConverter) GetResult(ctx *Context, res *Result) (result str
// using ITU BS1770 (EBU R128)
//
-type FFMpegBS1770FetchConverter struct {
+type ffmpegBS1770FetchConverter struct {
ffmpeg *exec.Cmd
bs1770 *exec.Cmd
pipe io.WriteCloser
- resultFF chan FetchConverterResult
- resultBS chan FetchConverterResult
+ resultFF chan fetchConverterResult
+ resultBS chan fetchConverterResult
}
-func NewFFMpegBS1770FetchConverter(ctx *Context, filename string, metadata map[string]string) (ff *FFMpegBS1770FetchConverter, filenameFlac string, err error) {
- ff = &FFMpegBS1770FetchConverter{}
+func newFFMpegBS1770FetchConverter(ctx *Context, filename string, metadata map[string]string) (ff *ffmpegBS1770FetchConverter, filenameFlac string, err error) {
+ ff = &ffmpegBS1770FetchConverter{}
filenameFlac = filepath.Dir(filename) + "/conv-ffmpeg-bs1770.flac"
ctx.stdlog.Printf("ffmpeg-bs1770-converter: starting ffmpeg and bs1770gain for file '%s' -> '%s'", filename, filenameFlac)
ff.ffmpeg = exec.Command("ffmpeg", "-loglevel", "warning", "-i", "pipe:0", "-map_metadata", "0")
@@ -270,46 +270,46 @@ func NewFFMpegBS1770FetchConverter(ctx *Context, filename string, metadata map[s
ff.bs1770.Stdout = &bsStdout
ff.bs1770.Stderr = &bsStderr
- ff.resultFF = make(chan FetchConverterResult, 1)
- ff.resultBS = make(chan FetchConverterResult, 1)
+ ff.resultFF = make(chan fetchConverterResult, 1)
+ ff.resultBS = make(chan fetchConverterResult, 1)
go func() {
err := ff.ffmpeg.Run()
ffstdout.Close()
- ff.resultFF <- FetchConverterResult{strings.TrimSpace(string(ffStderr.String())), err, 0.0}
+ ff.resultFF <- fetchConverterResult{strings.TrimSpace(string(ffStderr.String())), err, 0.0}
}()
go func() {
if err := ff.bs1770.Run(); err != nil {
- ff.resultBS <- FetchConverterResult{strings.TrimSpace(string(bsStderr.String())), err, 0.0}
+ ff.resultBS <- fetchConverterResult{strings.TrimSpace(string(bsStderr.String())), err, 0.0}
}
- res, err := NewBS1770ResultFromXML(&bsStdout)
+ res, err := newBS1770ResultFromXML(&bsStdout)
if err != nil {
- ff.resultBS <- FetchConverterResult{bsStdout.String(), err, 0.0}
+ ff.resultBS <- fetchConverterResult{bsStdout.String(), err, 0.0}
return
}
if len(res.Album.Tracks) == 0 {
- ff.resultBS <- FetchConverterResult{bsStdout.String(), fmt.Errorf("bs1770gain returned no/invalid result"), 0.0}
+ ff.resultBS <- fetchConverterResult{bsStdout.String(), fmt.Errorf("bs1770gain returned no/invalid result"), 0.0}
return
}
- ff.resultBS <- FetchConverterResult{"", nil, res.Album.Tracks[0].Integrated.LU}
+ ff.resultBS <- fetchConverterResult{"", nil, res.Album.Tracks[0].Integrated.LU}
}()
return
}
-func (ff *FFMpegBS1770FetchConverter) Write(p []byte) (n int, err error) {
+func (ff *ffmpegBS1770FetchConverter) Write(p []byte) (n int, err error) {
return ff.pipe.Write(p)
}
-func (ff *FFMpegBS1770FetchConverter) Close() (err error) {
+func (ff *ffmpegBS1770FetchConverter) Close() (err error) {
return ff.pipe.Close()
}
-func (ff *FFMpegBS1770FetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
+func (ff *ffmpegBS1770FetchConverter) GetResult(ctx *Context, res *Result) (result string, err error) {
if ff.resultFF == nil || ff.resultBS == nil {
return "", nil
}
- var rff, rbs *FetchConverterResult
+ var rff, rbs *fetchConverterResult
for {
select {
case r := <-ff.resultFF:
diff --git a/rhimport/core.go b/rhimport/core.go
index a0f1060..f01ed77 100644
--- a/rhimport/core.go
+++ b/rhimport/core.go
@@ -63,6 +63,16 @@ func Init(stdlog, dbglog *log.Logger) {
type ProgressCB func(step int, stepName string, current, total float64, title string, cart, cut uint, userdata interface{}) bool
type DoneCB func(result Result, userdata interface{}) bool
+type ProgressData struct {
+ Step int
+ StepName string
+ Current float64
+ Total float64
+ Title string
+ Cart uint
+ Cut uint
+}
+
type Result struct {
ResponseCode int
ErrorString string
@@ -167,7 +177,7 @@ func NewContext(conf *Config, db *rddb.DBChan, stdlog, dbglog *log.Logger) *Cont
dbglog = log.New(ioutil.Discard, "", 0)
}
- ctx := new(Context)
+ ctx := &Context{}
ctx.conf = conf
ctx.db = db
ctx.stdlog = stdlog
diff --git a/rhimport/fetcher.go b/rhimport/fetcher.go
index e3280c4..f8bfa0a 100644
--- a/rhimport/fetcher.go
+++ b/rhimport/fetcher.go
@@ -45,14 +45,14 @@ import (
"github.com/andelf/go-curl"
)
-type FetcherCurlCBData struct {
+type fetcherCurlCBData struct {
ctx *Context
res *Result
basepath string
filename string
remotename string
metadata map[string]string
- conv FetchConverter
+ conv fetchConverter
totalSize float64
written uint64
writeError error
@@ -60,7 +60,7 @@ type FetcherCurlCBData struct {
func curlHeaderCallback(ptr []byte, userdata interface{}) bool {
hdr := fmt.Sprintf("%s", ptr)
- data := userdata.(*FetcherCurlCBData)
+ data := userdata.(*fetcherCurlCBData)
if strings.HasPrefix(hdr, "Content-Disposition:") {
if mediatype, params, err := mime.ParseMediaType(strings.TrimPrefix(hdr, "Content-Disposition:")); err == nil {
@@ -73,7 +73,7 @@ func curlHeaderCallback(ptr []byte, userdata interface{}) bool {
}
func curlWriteCallback(ptr []byte, userdata interface{}) bool {
- data := userdata.(*FetcherCurlCBData)
+ data := userdata.(*fetcherCurlCBData)
if data.conv == nil {
if data.filename == "" {
name := path.Clean("/" + data.remotename)
@@ -84,7 +84,7 @@ func curlWriteCallback(ptr []byte, userdata interface{}) bool {
data.filename = filepath.Join(data.basepath, name)
}
data.ctx.OrigFilename = data.filename
- conv, newFilename, err := NewFetchConverter(data.ctx, data.filename, data.metadata)
+ conv, newFilename, err := newFetchConverter(data.ctx, data.filename, data.metadata)
if err != nil {
data.ctx.stdlog.Printf("Unable to create converter for file %s: %s", data.filename, err)
data.writeError = err
@@ -110,7 +110,7 @@ func curlWriteCallback(ptr []byte, userdata interface{}) bool {
}
func curlProgressCallback(dltotal, dlnow, ultotal, ulnow float64, userdata interface{}) bool {
- data := userdata.(*FetcherCurlCBData)
+ data := userdata.(*fetcherCurlCBData)
if data.writeError != nil {
return false
@@ -132,7 +132,7 @@ func curlProgressCallback(dltotal, dlnow, ultotal, ulnow float64, userdata inter
return true
}
-func checkYoutubeDL(ctx *Context, res *Result, uri *url.URL) *YoutubeDLInfo {
+func checkYoutubeDL(ctx *Context, res *Result, uri *url.URL) *youtubeDLInfo {
cmd := exec.Command("youtube-dl", "--no-playlist", "-f", "bestaudio/best", "--prefer-free-formats", "-J", ctx.SourceUri)
var stderr, stdout bytes.Buffer
cmd.Stdout = &stdout
@@ -142,7 +142,7 @@ func checkYoutubeDL(ctx *Context, res *Result, uri *url.URL) *YoutubeDLInfo {
}
ctx.stdlog.Printf("running youtube-dl for '%s'", ctx.SourceUri)
- done := make(chan *YoutubeDLInfo)
+ done := make(chan *youtubeDLInfo)
go func() {
defer func() {
done <- nil
@@ -151,7 +151,7 @@ func checkYoutubeDL(ctx *Context, res *Result, uri *url.URL) *YoutubeDLInfo {
ctx.dbglog.Printf("youtube-dl: %v, stderr: %s", err, strings.TrimSpace(stderr.String()))
return
}
- info, err := NewYoutubeDLInfoFromJSON(&stdout)
+ info, err := newYoutubeDLInfoFromJSON(&stdout)
if err != nil {
ctx.dbglog.Printf("youtube-dl: %v, stderr: %s", err, strings.TrimSpace(stderr.String()))
return
@@ -203,7 +203,7 @@ func fetchFileCurl(ctx *Context, res *Result, uri *url.URL) (err error) {
}
}
- cbdata := &FetcherCurlCBData{ctx: ctx, res: res, remotename: path.Base(uri.Path)}
+ cbdata := &fetcherCurlCBData{ctx: ctx, res: res, remotename: path.Base(uri.Path)}
if cbdata.basepath, err = ioutil.TempDir(ctx.conf.TempDir, "rhimportd-"); err != nil {
return
}
@@ -356,7 +356,7 @@ func fetchFileArchiv(ctx *Context, res *Result, uri *url.URL) (err error) {
return
}
- cbdata := &FetcherCurlCBData{ctx: ctx, res: res}
+ cbdata := &fetcherCurlCBData{ctx: ctx, res: res}
cbdata.filename = fmt.Sprintf("%s/%s", destpath, srcfile)
easy.Setopt(curl.OPT_WRITEFUNCTION, curlWriteCallback)
@@ -433,8 +433,8 @@ func fetchFileDirConvert(ctx *Context, res *Result, origSrc *os.File, sizeTotal
origDir, origFile := path.Split(ctx.SourceFile)
ctx.OrigFilename = ctx.SourceFile
- var conv FetchConverter
- if conv, ctx.SourceFile, err = NewFetchConverter(ctx, filepath.Join(basepath, origFile), nil); err != nil {
+ var conv fetchConverter
+ if conv, ctx.SourceFile, err = newFetchConverter(ctx, filepath.Join(basepath, origFile), nil); err != nil {
ctx.stdlog.Printf("Unable to create converter for file %s: %s", origDir+origFile, err)
return
}
@@ -567,12 +567,12 @@ func fetchFileSilence(ctx *Context, res *Result, uri *url.URL) error {
}
duration := time.Duration(d) * 100 * time.Millisecond
- wav, err := NewPCMWavFile(uint32(ctx.conf.SampleRate), 16, uint16(ctx.Channels), duration)
+ wav, err := newPCMWavFile(uint32(ctx.conf.SampleRate), 16, uint16(ctx.Channels), duration)
if err != nil {
return err
}
fileSize := wav.GetFileSize()
- wav.Generator = NewSilenceGenerator()
+ wav.generator = NewSilenceGenerator()
uri.Scheme = "attachment"
uri.Host = strconv.FormatUint(uint64(fileSize), 10)
@@ -606,7 +606,7 @@ func fetchFileSilence(ctx *Context, res *Result, uri *url.URL) error {
return fetchFileAttachment(ctx, res, uri)
}
-func writeAttachmentFile(ctx *Context, res *Result, sizeTotal uint64, conv FetchConverter) error {
+func writeAttachmentFile(ctx *Context, res *Result, sizeTotal uint64, conv fetchConverter) error {
written := uint64(0)
for {
select {
@@ -672,9 +672,9 @@ func fetchFileAttachment(ctx *Context, res *Result, uri *url.URL) error {
ctx.SourceFile = filepath.Join(basepath, path.Clean("/"+uri.Path))
- var conv FetchConverter
+ var conv fetchConverter
ctx.OrigFilename = ctx.SourceFile
- if conv, ctx.SourceFile, err = NewFetchConverter(ctx, ctx.SourceFile, nil); err != nil {
+ if conv, ctx.SourceFile, err = newFetchConverter(ctx, ctx.SourceFile, nil); err != nil {
ctx.stdlog.Printf("Unable to create converter for file %s: %s", ctx.OrigFilename, err)
return err
}
@@ -709,10 +709,10 @@ func fetchFileAttachment(ctx *Context, res *Result, uri *url.URL) error {
return nil
}
-type FetchFunc func(*Context, *Result, *url.URL) (err error)
+type fetchFunc func(*Context, *Result, *url.URL) (err error)
var (
- fetchers = map[string]FetchFunc{
+ fetchers = map[string]fetchFunc{
"local": fetchFileLocal,
"tmp": fetchFileTmp,
"silence": fetchFileSilence,
diff --git a/rhimport/importer.go b/rhimport/importer.go
index 4b06724..57c525d 100644
--- a/rhimport/importer.go
+++ b/rhimport/importer.go
@@ -37,7 +37,7 @@ import (
"github.com/andelf/go-curl"
)
-func (res *Result) fromRDWebResult(rdres *RDWebResult) {
+func (res *Result) fromRDWebResult(rdres *rdWebResult) {
res.ResponseCode = rdres.ResponseCode
res.ErrorString = rdres.ErrorString
if rdres.AudioConvertError != 0 {
@@ -86,16 +86,16 @@ func addCart(ctx *Context, res *Result) (err error) {
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
- var rdres *RDWebResult
- if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
+ 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 {
+ var cartadd *rdCartAdd
+ if cartadd, err = newRDCartAddFromXML(resp.Body); err != nil {
return
}
res.ResponseCode = resp.StatusCode
@@ -131,8 +131,8 @@ func addCut(ctx *Context, res *Result) (err error) {
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
- var rdres *RDWebResult
- if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
+ var rdres *rdWebResult
+ if rdres, err = newRDWebResultFromXML(resp.Body); err != nil {
return
}
res.fromRDWebResult(rdres)
@@ -140,8 +140,8 @@ func addCut(ctx *Context, res *Result) (err error) {
res.Cut = ctx.Cut
return
}
- var cutadd *RDCutAdd
- if cutadd, err = NewRDCutAddFromXML(resp.Body); err != nil {
+ var cutadd *rdCutAdd
+ if cutadd, err = newRDCutAddFromXML(resp.Body); err != nil {
return
}
res.ResponseCode = resp.StatusCode
@@ -177,8 +177,8 @@ func removeCart(ctx *Context, res *Result) (err error) {
}
defer resp.Body.Close()
- var rdres *RDWebResult
- if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
+ var rdres *rdWebResult
+ if rdres, err = newRDWebResultFromXML(resp.Body); err != nil {
return
}
res.fromRDWebResult(rdres)
@@ -214,8 +214,8 @@ func removeCut(ctx *Context, res *Result) (err error) {
}
defer resp.Body.Close()
- var rdres *RDWebResult
- if rdres, err = NewRDWebResultFromXML(resp.Body); err != nil {
+ var rdres *rdWebResult
+ if rdres, err = newRDWebResultFromXML(resp.Body); err != nil {
return
}
res.fromRDWebResult(rdres)
@@ -328,8 +328,8 @@ func importAudio(ctx *Context, res *Result) (err error) {
return
}
- var rdres *RDWebResult
- if rdres, err = NewRDWebResultFromXML(bufio.NewReader(&resbody)); err != nil {
+ var rdres *rdWebResult
+ if rdres, err = newRDWebResultFromXML(bufio.NewReader(&resbody)); err != nil {
return
}
res.fromRDWebResult(rdres)
diff --git a/rhimport/rdxport_responses.go b/rhimport/rdxport_responses.go
index 2871408..b9c3f9b 100644
--- a/rhimport/rdxport_responses.go
+++ b/rhimport/rdxport_responses.go
@@ -30,15 +30,15 @@ import (
"io"
)
-type RDWebResult struct {
+type rdWebResult struct {
ResponseCode int `xml:"ResponseCode"`
ErrorString string `xml:"ErrorString"`
AudioConvertError int `xml:"AudioConvertError"`
}
-func NewRDWebResultFromXML(data io.Reader) (res *RDWebResult, err error) {
+func newRDWebResultFromXML(data io.Reader) (res *rdWebResult, err error) {
decoder := xml.NewDecoder(data)
- res = &RDWebResult{}
+ res = &rdWebResult{}
if xmlerr := decoder.Decode(res); xmlerr != nil {
err = fmt.Errorf("Error parsing XML response: %s", xmlerr)
return
@@ -46,11 +46,11 @@ func NewRDWebResultFromXML(data io.Reader) (res *RDWebResult, err error) {
return
}
-type RDCartAdd struct {
- Carts []RDCart `xml:"cart"`
+type rdCartAdd struct {
+ Carts []rdCart `xml:"cart"`
}
-type RDCart struct {
+type rdCart struct {
Number uint `xml:"number"`
Type string `xml:"type"`
GroupName string `xml:"groupName"`
@@ -79,9 +79,9 @@ type RDCart struct {
MetadataDatetime string `xml:"metadataDatetime"`
}
-func NewRDCartAddFromXML(data io.Reader) (cart *RDCartAdd, err error) {
+func newRDCartAddFromXML(data io.Reader) (cart *rdCartAdd, err error) {
decoder := xml.NewDecoder(data)
- cart = &RDCartAdd{}
+ cart = &rdCartAdd{}
if xmlerr := decoder.Decode(cart); xmlerr != nil {
err = fmt.Errorf("Error parsing XML response: %s", xmlerr)
return
@@ -89,11 +89,11 @@ func NewRDCartAddFromXML(data io.Reader) (cart *RDCartAdd, err error) {
return
}
-type RDCutAdd struct {
- Cuts []RDCut `xml:"cut"`
+type rdCutAdd struct {
+ Cuts []rdCut `xml:"cut"`
}
-type RDCut struct {
+type rdCut struct {
Name string `xml:"cutName"`
CartNumber uint `xml:"cartNumber"`
Number uint `xml:"cutNumber"`
@@ -139,9 +139,9 @@ type RDCut struct {
TalkEndPoint int `xml:"talkEndPoint"`
}
-func NewRDCutAddFromXML(data io.Reader) (cut *RDCutAdd, err error) {
+func newRDCutAddFromXML(data io.Reader) (cut *rdCutAdd, err error) {
decoder := xml.NewDecoder(data)
- cut = &RDCutAdd{}
+ cut = &rdCutAdd{}
if xmlerr := decoder.Decode(cut); xmlerr != nil {
err = fmt.Errorf("Error parsing XML response: %s", xmlerr)
return
diff --git a/rhimport/session.go b/rhimport/session.go
index a119285..e749020 100644
--- a/rhimport/session.go
+++ b/rhimport/session.go
@@ -31,33 +31,23 @@ import (
)
const (
- SESSION_NEW = iota
- SESSION_RUNNING
- SESSION_CANCELED
- SESSION_DONE
- SESSION_TIMEOUT
+ _SESSION_NEW = iota
+ _SESSION_RUNNING
+ _SESSION_CANCELED
+ _SESSION_DONE
+ _SESSION_TIMEOUT
)
-type SessionProgressCB struct {
+type sessionProgressCB struct {
cb ProgressCB
userdata interface{}
}
-type SessionDoneCB struct {
+type sessionDoneCB struct {
cb DoneCB
userdata interface{}
}
-type ProgressData struct {
- Step int
- StepName string
- Current float64
- Total float64
- Title string
- Cart uint
- Cut uint
-}
-
type sessionAddProgressHandlerResponse struct {
err error
}
@@ -87,7 +77,7 @@ type attachUploaderRequest struct {
response chan<- attachUploaderResponse
}
-type Session struct {
+type session struct {
ctx Context
state int
removeFunc func()
@@ -103,8 +93,8 @@ type Session struct {
addProgressChan chan sessionAddProgressHandlerRequest
addDoneChan chan sessionAddDoneHandlerRequest
attachUploaderChan chan attachUploaderRequest
- progressCBs []*SessionProgressCB
- doneCBs []*SessionDoneCB
+ progressCBs []*sessionProgressCB
+ doneCBs []*sessionDoneCB
cancelUploader chan bool
}
@@ -148,47 +138,47 @@ func sessionRun(ctx Context, done chan<- Result) {
done <- *res
}
-func (self *Session) run(timeout time.Duration) {
- self.ctx.ProgressCallBack = sessionProgressCallback
- self.ctx.ProgressCallBackData = (chan<- ProgressData)(self.progressIntChan)
- self.ctx.Cancel = self.cancelIntChan
- go sessionRun(self.ctx, self.doneIntChan)
- self.state = SESSION_RUNNING
+func (s *session) run(timeout time.Duration) {
+ s.ctx.ProgressCallBack = sessionProgressCallback
+ s.ctx.ProgressCallBackData = (chan<- ProgressData)(s.progressIntChan)
+ s.ctx.Cancel = s.cancelIntChan
+ go sessionRun(s.ctx, s.doneIntChan)
+ s.state = _SESSION_RUNNING
if timeout > 3*time.Hour {
- self.ctx.stdlog.Printf("requested session timeout (%v) is to high - lowering to 3h", timeout)
+ s.ctx.stdlog.Printf("requested session timeout (%v) is to high - lowering to 3h", timeout)
timeout = 3 * time.Hour
}
- self.timer.Reset(timeout)
+ s.timer.Reset(timeout)
return
}
-func (self *Session) cancel() {
- self.ctx.dbglog.Println("Session: canceling running import")
+func (s *session) cancel() {
+ s.ctx.dbglog.Println("Session: canceling running import")
select {
- case self.cancelIntChan <- true:
+ case s.cancelIntChan <- true:
default: // session got canceled already??
}
- self.state = SESSION_CANCELED
+ s.state = _SESSION_CANCELED
}
-func (self *Session) addProgressHandler(userdata interface{}, cb ProgressCB) (resp sessionAddProgressHandlerResponse) {
- if self.state != SESSION_NEW && self.state != SESSION_RUNNING {
+func (s *session) addProgressHandler(userdata interface{}, cb ProgressCB) (resp sessionAddProgressHandlerResponse) {
+ if s.state != _SESSION_NEW && s.state != _SESSION_RUNNING {
resp.err = fmt.Errorf("session is already done/canceled")
}
- self.progressCBs = append(self.progressCBs, &SessionProgressCB{cb, userdata})
+ s.progressCBs = append(s.progressCBs, &sessionProgressCB{cb, userdata})
return
}
-func (self *Session) addDoneHandler(userdata interface{}, cb DoneCB) (resp sessionAddDoneHandlerResponse) {
- if self.state != SESSION_NEW && self.state != SESSION_RUNNING {
+func (s *session) addDoneHandler(userdata interface{}, cb DoneCB) (resp sessionAddDoneHandlerResponse) {
+ if s.state != _SESSION_NEW && s.state != _SESSION_RUNNING {
resp.err = fmt.Errorf("session is already done/canceled")
}
- self.doneCBs = append(self.doneCBs, &SessionDoneCB{cb, userdata})
+ s.doneCBs = append(s.doneCBs, &sessionDoneCB{cb, userdata})
return
}
-func (self *Session) callProgressHandler(p *ProgressData) {
- for _, cb := range self.progressCBs {
+func (s *session) callProgressHandler(p *ProgressData) {
+ for _, cb := range s.progressCBs {
if cb.cb != nil {
if keep := cb.cb(p.Step, p.StepName, p.Current, p.Total, p.Title, p.Cart, p.Cut, cb.userdata); !keep {
cb.cb = nil
@@ -197,8 +187,8 @@ func (self *Session) callProgressHandler(p *ProgressData) {
}
}
-func (self *Session) callDoneHandler(r *Result) {
- for _, cb := range self.doneCBs {
+func (s *session) callDoneHandler(r *Result) {
+ for _, cb := range s.doneCBs {
if cb.cb != nil {
if keep := cb.cb(*r, cb.userdata); !keep {
cb.cb = nil
@@ -207,88 +197,88 @@ func (self *Session) callDoneHandler(r *Result) {
}
}
-func (self *Session) attachUploader() (resp attachUploaderResponse) {
- if self.cancelUploader != nil {
+func (s *session) attachUploader() (resp attachUploaderResponse) {
+ if s.cancelUploader != nil {
return
}
- self.cancelUploader = make(chan bool, 1)
- resp.cancel = self.cancelUploader
- resp.attachment = self.ctx.AttachmentChan
+ s.cancelUploader = make(chan bool, 1)
+ resp.cancel = s.cancelUploader
+ resp.attachment = s.ctx.AttachmentChan
return
}
-func (self *Session) dispatchRequests() {
+func (s *session) dispatchRequests() {
defer func() {
- if self.cancelUploader != nil {
- close(self.cancelUploader)
+ if s.cancelUploader != nil {
+ close(s.cancelUploader)
}
- self.done <- true
+ s.done <- true
}()
var lastProgress *ProgressData
progressPending := 0
- pt := time.NewTimer(self.progressRateLimit)
+ pt := time.NewTimer(s.progressRateLimit)
pt.Stop()
for {
select {
- case <-self.quit:
- if self.state == SESSION_RUNNING {
- self.cancel()
+ case <-s.quit:
+ if s.state == _SESSION_RUNNING {
+ s.cancel()
}
return
- case <-self.timer.C:
- if self.state == SESSION_RUNNING {
- self.cancel()
+ case <-s.timer.C:
+ if s.state == _SESSION_RUNNING {
+ s.cancel()
}
- self.state = SESSION_TIMEOUT
+ s.state = _SESSION_TIMEOUT
r := &Result{ResponseCode: http.StatusInternalServerError, ErrorString: "session timed out"}
- self.callDoneHandler(r)
- if self.removeFunc != nil {
- self.removeFunc()
+ s.callDoneHandler(r)
+ if s.removeFunc != nil {
+ s.removeFunc()
}
- case t := <-self.runChan:
- if self.state == SESSION_NEW {
- self.run(t)
+ case t := <-s.runChan:
+ if s.state == _SESSION_NEW {
+ s.run(t)
}
- case <-self.cancelChan:
- if self.state == SESSION_RUNNING {
- self.cancel()
+ case <-s.cancelChan:
+ if s.state == _SESSION_RUNNING {
+ s.cancel()
}
- case req := <-self.addProgressChan:
- req.response <- self.addProgressHandler(req.userdata, req.callback)
- case req := <-self.addDoneChan:
- req.response <- self.addDoneHandler(req.userdata, req.callback)
+ case req := <-s.addProgressChan:
+ req.response <- s.addProgressHandler(req.userdata, req.callback)
+ case req := <-s.addDoneChan:
+ req.response <- s.addDoneHandler(req.userdata, req.callback)
case <-pt.C:
if progressPending > 1 && lastProgress != nil {
- self.callProgressHandler(lastProgress)
+ s.callProgressHandler(lastProgress)
}
progressPending = 0
lastProgress = nil
- case p := <-self.progressIntChan:
- if self.state == SESSION_RUNNING {
+ case p := <-s.progressIntChan:
+ if s.state == _SESSION_RUNNING {
if lastProgress == nil {
- self.callProgressHandler(&p)
- pt.Reset(self.progressRateLimit)
+ s.callProgressHandler(&p)
+ pt.Reset(s.progressRateLimit)
} else if lastProgress.Step != p.Step {
- self.callProgressHandler(lastProgress)
- self.callProgressHandler(&p)
- pt.Reset(self.progressRateLimit)
+ s.callProgressHandler(lastProgress)
+ s.callProgressHandler(&p)
+ pt.Reset(s.progressRateLimit)
}
lastProgress = &p
progressPending++
}
- case r := <-self.doneIntChan:
- if self.state != SESSION_TIMEOUT {
- self.timer.Stop()
- self.state = SESSION_DONE
- self.callDoneHandler(&r)
- if self.removeFunc != nil {
- self.removeFunc()
+ case r := <-s.doneIntChan:
+ if s.state != _SESSION_TIMEOUT {
+ s.timer.Stop()
+ s.state = _SESSION_DONE
+ s.callDoneHandler(&r)
+ if s.removeFunc != nil {
+ s.removeFunc()
}
}
- case req := <-self.attachUploaderChan:
- req.response <- self.attachUploader()
+ case req := <-s.attachUploaderChan:
+ req.response <- s.attachUploader()
}
}
}
@@ -296,7 +286,7 @@ func (self *Session) dispatchRequests() {
// *********************************************************
// Public Interface
-type SessionChan struct {
+type Session struct {
runChan chan<- time.Duration
cancelChan chan<- bool
addProgressChan chan<- sessionAddProgressHandlerRequest
@@ -304,28 +294,28 @@ type SessionChan struct {
attachUploaderChan chan<- attachUploaderRequest
}
-func (self *SessionChan) Run(timeout time.Duration) {
+func (s *Session) Run(timeout time.Duration) {
select {
- case self.runChan <- timeout:
+ case s.runChan <- timeout:
default: // command is already pending or session is about to be closed/removed
}
}
-func (self *SessionChan) Cancel() {
+func (s *Session) Cancel() {
select {
- case self.cancelChan <- true:
+ case s.cancelChan <- true:
default: // cancel is already pending or session is about to be closed/removed
}
}
-func (self *SessionChan) AddProgressHandler(userdata interface{}, cb ProgressCB) error {
+func (s *Session) AddProgressHandler(userdata interface{}, cb ProgressCB) error {
resCh := make(chan sessionAddProgressHandlerResponse)
req := sessionAddProgressHandlerRequest{}
req.userdata = userdata
req.callback = cb
req.response = resCh
select {
- case self.addProgressChan <- req:
+ case s.addProgressChan <- req:
default:
return fmt.Errorf("session is about to be closed/removed")
}
@@ -334,14 +324,14 @@ func (self *SessionChan) AddProgressHandler(userdata interface{}, cb ProgressCB)
return res.err
}
-func (self *SessionChan) AddDoneHandler(userdata interface{}, cb DoneCB) error {
+func (s *Session) AddDoneHandler(userdata interface{}, cb DoneCB) error {
resCh := make(chan sessionAddDoneHandlerResponse)
req := sessionAddDoneHandlerRequest{}
req.userdata = userdata
req.callback = cb
req.response = resCh
select {
- case self.addDoneChan <- req:
+ case s.addDoneChan <- req:
default:
return fmt.Errorf("session is about to be closed/removed")
}
@@ -350,12 +340,12 @@ func (self *SessionChan) AddDoneHandler(userdata interface{}, cb DoneCB) error {
return res.err
}
-func (self *SessionChan) AttachUploader() (<-chan bool, chan<- AttachmentChunk) {
+func (s *Session) AttachUploader() (<-chan bool, chan<- AttachmentChunk) {
resCh := make(chan attachUploaderResponse)
req := attachUploaderRequest{}
req.response = resCh
select {
- case self.attachUploaderChan <- req:
+ case s.attachUploaderChan <- req:
default:
// session is about to be closed/removed
return nil, nil
@@ -368,53 +358,53 @@ func (self *SessionChan) AttachUploader() (<-chan bool, chan<- AttachmentChunk)
// *********************************************************
// Semi-Public Interface (only used by sessionStore)
-func (self *Session) getInterface() *SessionChan {
- ch := &SessionChan{}
- ch.runChan = self.runChan
- ch.cancelChan = self.cancelChan
- ch.addProgressChan = self.addProgressChan
- ch.addDoneChan = self.addDoneChan
- ch.attachUploaderChan = self.attachUploaderChan
+func (s *session) getInterface() *Session {
+ ch := &Session{}
+ ch.runChan = s.runChan
+ ch.cancelChan = s.cancelChan
+ ch.addProgressChan = s.addProgressChan
+ ch.addDoneChan = s.addDoneChan
+ ch.attachUploaderChan = s.attachUploaderChan
return ch
}
-func (self *Session) cleanup() {
- self.quit <- true
- self.ctx.dbglog.Printf("Session: waiting for session to close")
- <-self.done
- close(self.quit)
- close(self.done)
- self.timer.Stop()
+func (s *session) cleanup() {
+ s.quit <- true
+ s.ctx.dbglog.Printf("Session: waiting for session to close")
+ <-s.done
+ close(s.quit)
+ close(s.done)
+ s.timer.Stop()
// don't close the channels we give out because this might lead to a panic if
// somebody wites to an already removed session
- // close(self.cancelIntChan)
- // close(self.progressIntChan)
- // close(self.doneIntChan)
- // close(self.runChan)
- // close(self.cancelChan)
- // close(self.addProgressChan)
- // close(self.addDoneChan)
- // close(self.attachUploader)
- self.ctx.dbglog.Printf("Session: cleanup is now done")
+ // close(s.cancelIntChan)
+ // close(s.progressIntChan)
+ // close(s.doneIntChan)
+ // close(s.runChan)
+ // close(s.cancelChan)
+ // close(s.addProgressChan)
+ // close(s.addDoneChan)
+ // close(s.attachUploader)
+ s.ctx.dbglog.Printf("Session: cleanup is now done")
}
-func newSession(ctx *Context, removeFunc func()) (session *Session) {
- session = new(Session)
- session.state = SESSION_NEW
- session.removeFunc = removeFunc
- session.ctx = *ctx
- session.quit = make(chan bool, 1)
- session.done = make(chan bool)
- session.timer = time.NewTimer(10 * time.Second)
- session.cancelIntChan = make(chan bool, 1)
- session.progressRateLimit = 100 * time.Millisecond // TODO: hardcoded value
- session.progressIntChan = make(chan ProgressData, 10)
- session.doneIntChan = make(chan Result, 1)
- session.runChan = make(chan time.Duration, 1)
- session.cancelChan = make(chan bool, 1)
- session.addProgressChan = make(chan sessionAddProgressHandlerRequest, 10)
- session.addDoneChan = make(chan sessionAddDoneHandlerRequest, 10)
- session.attachUploaderChan = make(chan attachUploaderRequest, 1)
- go session.dispatchRequests()
+func newSession(ctx *Context, removeFunc func()) (s *session) {
+ s = &session{}
+ s.state = _SESSION_NEW
+ s.removeFunc = removeFunc
+ s.ctx = *ctx
+ s.quit = make(chan bool, 1)
+ s.done = make(chan bool)
+ s.timer = time.NewTimer(10 * time.Second)
+ s.cancelIntChan = make(chan bool, 1)
+ s.progressRateLimit = 100 * time.Millisecond // TODO: hardcoded value
+ s.progressIntChan = make(chan ProgressData, 10)
+ s.doneIntChan = make(chan Result, 1)
+ s.runChan = make(chan time.Duration, 1)
+ s.cancelChan = make(chan bool, 1)
+ s.addProgressChan = make(chan sessionAddProgressHandlerRequest, 10)
+ s.addDoneChan = make(chan sessionAddDoneHandlerRequest, 10)
+ s.attachUploaderChan = make(chan attachUploaderRequest, 1)
+ go s.dispatchRequests()
return
}
diff --git a/rhimport/session_store.go b/rhimport/session_store.go
index dafe71e..bb36473 100644
--- a/rhimport/session_store.go
+++ b/rhimport/session_store.go
@@ -38,7 +38,7 @@ import (
type newSessionResponse struct {
id string
- session *SessionChan
+ session *Session
responsecode int
errorstring string
}
@@ -50,7 +50,7 @@ type newSessionRequest struct {
}
type getSessionResponse struct {
- session *SessionChan
+ session *Session
refId string
responsecode int
errorstring string
@@ -96,17 +96,17 @@ type removeSessionRequest struct {
response chan removeSessionResponse
}
-type SessionStoreSessionElement struct {
- s *Session
+type sessionStoreSessionElement struct {
+ s *session
refId string
}
-type SessionStoreUserElement struct {
- sessions map[string]*SessionStoreSessionElement
+type sessionStoreUserElement struct {
+ sessions map[string]*sessionStoreSessionElement
updateCBs []SessionsListCB
}
-func (user *SessionStoreUserElement) callUpdateHandler(added, removed map[string]string) {
+func (user *sessionStoreUserElement) callUpdateHandler(added, removed map[string]string) {
var keptCBs []SessionsListCB
for _, cb := range user.updateCBs {
if cb.cb != nil {
@@ -118,20 +118,20 @@ func (user *SessionStoreUserElement) callUpdateHandler(added, removed map[string
user.updateCBs = keptCBs
}
-func (user *SessionStoreUserElement) callUpdateHandlerAdd(id, refId string) {
+func (user *sessionStoreUserElement) callUpdateHandlerAdd(id, refId string) {
added := make(map[string]string)
added[id] = refId
user.callUpdateHandler(added, nil)
}
-func (user *SessionStoreUserElement) callUpdateHandlerRemove(id, refId string) {
+func (user *sessionStoreUserElement) callUpdateHandlerRemove(id, refId string) {
removed := make(map[string]string)
removed[id] = refId
user.callUpdateHandler(nil, removed)
}
-type SessionStore struct {
- store map[string]*SessionStoreUserElement
+type sessionStore struct {
+ store map[string]*sessionStoreUserElement
conf *Config
db *rddb.DBChan
stdlog *log.Logger
@@ -152,7 +152,7 @@ func generateSessionId() (string, error) {
return base64.RawURLEncoding.EncodeToString(b[:]), nil
}
-func (store *SessionStore) new(ctx *Context, refId string) (resp newSessionResponse) {
+func (store *sessionStore) new(ctx *Context, refId string) (resp newSessionResponse) {
resp.responsecode = http.StatusOK
resp.errorstring = "OK"
if !ctx.Trusted {
@@ -175,8 +175,8 @@ func (store *SessionStore) new(ctx *Context, refId string) (resp newSessionRespo
resp.id = id
if _, exists := store.store[ctx.UserName]; !exists {
- newuser := &SessionStoreUserElement{}
- newuser.sessions = make(map[string]*SessionStoreSessionElement)
+ newuser := &sessionStoreUserElement{}
+ newuser.sessions = make(map[string]*sessionStoreSessionElement)
store.store[ctx.UserName] = newuser
}
ctx.conf = store.conf
@@ -187,7 +187,7 @@ func (store *SessionStore) new(ctx *Context, refId string) (resp newSessionRespo
if pref := ctx.dbglog.Prefix(); strings.Contains(pref, "%s") {
ctx.dbglog.SetPrefix(fmt.Sprintf(pref, resp.id))
}
- s := &SessionStoreSessionElement{newSession(ctx, func() { store.GetInterface().Remove(ctx.UserName, resp.id) }), refId}
+ s := &sessionStoreSessionElement{newSession(ctx, func() { store.GetInterface().Remove(ctx.UserName, resp.id) }), refId}
store.store[ctx.UserName].sessions[resp.id] = s
resp.session = store.store[ctx.UserName].sessions[resp.id].s.getInterface()
store.dbglog.Printf("SessionStore: created session for '%s' -> %s", ctx.UserName, resp.id)
@@ -195,7 +195,7 @@ func (store *SessionStore) new(ctx *Context, refId string) (resp newSessionRespo
return
}
-func (store *SessionStore) get(username, id string) (resp getSessionResponse) {
+func (store *sessionStore) get(username, id string) (resp getSessionResponse) {
resp.responsecode = http.StatusOK
resp.errorstring = "OK"
@@ -216,7 +216,7 @@ func (store *SessionStore) get(username, id string) (resp getSessionResponse) {
return
}
-func (store *SessionStore) list(username, password string, trusted bool, userdata interface{}, cb SessionsUpdateCB) (resp listSessionsResponse) {
+func (store *sessionStore) list(username, password string, trusted bool, userdata interface{}, cb SessionsUpdateCB) (resp listSessionsResponse) {
resp.responsecode = http.StatusOK
resp.errorstring = "OK"
if !trusted {
@@ -239,15 +239,15 @@ func (store *SessionStore) list(username, password string, trusted bool, userdat
user.updateCBs = append(user.updateCBs, SessionsListCB{cb, userdata})
}
} else if cb != nil {
- newuser := &SessionStoreUserElement{}
- newuser.sessions = make(map[string]*SessionStoreSessionElement)
+ newuser := &sessionStoreUserElement{}
+ newuser.sessions = make(map[string]*sessionStoreSessionElement)
newuser.updateCBs = []SessionsListCB{SessionsListCB{cb, userdata}}
store.store[username] = newuser
}
return
}
-func (store *SessionStore) remove(username, id string) (resp removeSessionResponse) {
+func (store *sessionStore) remove(username, id string) (resp removeSessionResponse) {
resp.responsecode = http.StatusOK
resp.errorstring = "OK"
@@ -276,7 +276,7 @@ func (store *SessionStore) remove(username, id string) (resp removeSessionRespon
return
}
-func (store *SessionStore) maintenanceTask() {
+func (store *sessionStore) maintenanceTask() {
for name, user := range store.store {
user.callUpdateHandler(nil, nil)
if len(user.sessions) == 0 && len(user.updateCBs) == 0 {
@@ -286,7 +286,7 @@ func (store *SessionStore) maintenanceTask() {
}
}
-func (store *SessionStore) dispatchRequests() {
+func (store *sessionStore) dispatchRequests() {
defer func() { store.done <- true }()
mt := time.NewTicker(1 * time.Minute)
@@ -311,14 +311,14 @@ func (store *SessionStore) dispatchRequests() {
// *********************************************************
// Public Interface
-type SessionStoreChan struct {
+type SessionStore struct {
newChan chan<- newSessionRequest
getChan chan<- getSessionRequest
listChan chan listSessionsRequest
removeChan chan<- removeSessionRequest
}
-func (store *SessionStoreChan) New(ctx *Context, refId string) (string, *SessionChan, int, string) {
+func (store *SessionStore) New(ctx *Context, refId string) (string, *Session, int, string) {
resCh := make(chan newSessionResponse)
req := newSessionRequest{}
req.ctx = ctx
@@ -330,7 +330,7 @@ func (store *SessionStoreChan) New(ctx *Context, refId string) (string, *Session
return res.id, res.session, res.responsecode, res.errorstring
}
-func (store *SessionStoreChan) Get(user, id string) (*SessionChan, string, int, string) {
+func (store *SessionStore) Get(user, id string) (*Session, string, int, string) {
resCh := make(chan getSessionResponse)
req := getSessionRequest{}
req.user = user
@@ -342,7 +342,7 @@ func (store *SessionStoreChan) Get(user, id string) (*SessionChan, string, int,
return res.session, res.refId, res.responsecode, res.errorstring
}
-func (store *SessionStoreChan) List(user, password string, trusted bool, userdata interface{}, cb SessionsUpdateCB) (map[string]string, int, string) {
+func (store *SessionStore) List(user, password string, trusted bool, userdata interface{}, cb SessionsUpdateCB) (map[string]string, int, string) {
resCh := make(chan listSessionsResponse)
req := listSessionsRequest{}
req.user = user
@@ -357,7 +357,7 @@ func (store *SessionStoreChan) List(user, password string, trusted bool, userdat
return res.sessions, res.responsecode, res.errorstring
}
-func (store *SessionStoreChan) Remove(user, id string) (int, string) {
+func (store *SessionStore) Remove(user, id string) (int, string) {
resCh := make(chan removeSessionResponse)
req := removeSessionRequest{}
req.user = user
@@ -369,8 +369,8 @@ func (store *SessionStoreChan) Remove(user, id string) (int, string) {
return res.responsecode, res.errorstring
}
-func (store *SessionStore) GetInterface() *SessionStoreChan {
- ch := &SessionStoreChan{}
+func (store *sessionStore) GetInterface() *SessionStore {
+ ch := &SessionStore{}
ch.newChan = store.newChan
ch.getChan = store.getChan
ch.listChan = store.listChan
@@ -378,7 +378,7 @@ func (store *SessionStore) GetInterface() *SessionStoreChan {
return ch
}
-func (store *SessionStore) Cleanup() {
+func (store *sessionStore) Cleanup() {
store.quit <- true
<-store.done
close(store.quit)
@@ -389,15 +389,15 @@ func (store *SessionStore) Cleanup() {
close(store.removeChan)
}
-func NewSessionStore(conf *Config, db *rddb.DBChan, stdlog, dbglog *log.Logger) (store *SessionStore, err error) {
- store = new(SessionStore)
+func NewSessionStore(conf *Config, db *rddb.DBChan, stdlog, dbglog *log.Logger) (store *sessionStore, err error) {
+ store = &sessionStore{}
store.conf = conf
store.db = db
store.stdlog = stdlog
store.dbglog = dbglog
store.quit = make(chan bool, 1)
store.done = make(chan bool)
- store.store = make(map[string]*SessionStoreUserElement)
+ store.store = make(map[string]*sessionStoreUserElement)
store.newChan = make(chan newSessionRequest, 10)
store.getChan = make(chan getSessionRequest, 10)
store.listChan = make(chan listSessionsRequest, 10)
diff --git a/rhimport/wave_generator.go b/rhimport/wave_generator.go
index f4c3261..7816bc0 100644
--- a/rhimport/wave_generator.go
+++ b/rhimport/wave_generator.go
@@ -34,11 +34,11 @@ import (
)
const (
- RIFF_TAG = "RIFF"
- WAVE_TAG = "WAVE"
- FMT_TAG = "fmt "
- FMT_ID_PCM = 0x0001
- DATA_TAG = "data"
+ _RIFF_TAG = "RIFF"
+ _WAVE_TAG = "WAVE"
+ _FMT_TAG = "fmt "
+ _FMT_ID_PCM = 0x0001
+ _DATA_TAG = "data"
)
type wavHeader struct {
@@ -60,31 +60,31 @@ type wavHeader struct {
}
func (h *wavHeader) Bytes() []byte {
- buf := new(bytes.Buffer)
+ buf := &bytes.Buffer{}
binary.Write(buf, binary.LittleEndian, h)
return buf.Bytes()
}
-type SampleGenerator interface {
+type sampleGenerator interface {
Reset(samplePeriod float64)
GetSamples(nSamples uint32, channels uint16) []float64 // this needs to be normalized, aka -1 <= value <= 1
}
-type WavFile struct {
+type wavFile struct {
header wavHeader
headerSize uint32
pcmSampleMax float64
pcmSampleBytes uint32
samplePeriod float64
- Generator SampleGenerator
+ generator sampleGenerator
readOffset uint32
}
-func (wav *WavFile) GetFileSize() (size uint32) {
+func (wav *wavFile) GetFileSize() (size uint32) {
return wav.headerSize + wav.header.dataLength
}
-func (wav *WavFile) Read(p []byte) (n int, err error) {
+func (wav *wavFile) Read(p []byte) (n int, err error) {
n = 0
if wav.readOffset >= (wav.header.riffLength + 8) {
return n, io.EOF
@@ -93,16 +93,16 @@ func (wav *WavFile) Read(p []byte) (n int, err error) {
if wav.readOffset < wav.headerSize {
n = copy(p, wav.header.Bytes()[wav.readOffset:])
wav.readOffset += uint32(n)
- wav.Generator.Reset(wav.samplePeriod)
+ wav.generator.Reset(wav.samplePeriod)
}
if n >= len(p) {
return
}
nsamples := uint32(len(p)-n) / uint32(wav.header.blockAlign)
- data := wav.Generator.GetSamples(nsamples, wav.header.nChannels)
+ data := wav.generator.GetSamples(nsamples, wav.header.nChannels)
switch wav.header.fmtID {
- case FMT_ID_PCM:
+ case _FMT_ID_PCM:
idx := 0
for _, normalized := range data {
scaled := wav.pcmSampleMax * normalized
@@ -123,8 +123,8 @@ func (wav *WavFile) Read(p []byte) (n int, err error) {
return
}
-func NewPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, length time.Duration) (wav *WavFile, err error) {
- wav = &WavFile{}
+func newPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, length time.Duration) (wav *wavFile, err error) {
+ wav = &wavFile{}
wav.headerSize = 8 + 4 + 8 + 16 + 8
if length <= 0 {
return nil, errors.New("invalid length: must be > 0")
@@ -154,61 +154,61 @@ func NewPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, lengt
}
dataLen := nFrames * uint32(frameSize)
- copy(wav.header.riffTag[:], RIFF_TAG)
+ copy(wav.header.riffTag[:], _RIFF_TAG)
wav.header.riffLength = wav.headerSize - 8 + dataLen
- copy(wav.header.waveTag[:], WAVE_TAG)
+ copy(wav.header.waveTag[:], _WAVE_TAG)
- copy(wav.header.fmtTag[:], FMT_TAG)
+ copy(wav.header.fmtTag[:], _FMT_TAG)
wav.header.fmtLength = 16
- wav.header.fmtID = FMT_ID_PCM
+ wav.header.fmtID = _FMT_ID_PCM
wav.header.nChannels = channels
wav.header.sampleRate = sampleRate
wav.header.byteRate = sampleRate * uint32(frameSize)
wav.header.blockAlign = frameSize
wav.header.sampleDepth = sampleDepth
- copy(wav.header.dataTag[:], DATA_TAG)
+ copy(wav.header.dataTag[:], _DATA_TAG)
wav.header.dataLength = dataLen
return
}
-type SilenceGenerator struct {
+type silenceGenerator struct {
}
-func NewSilenceGenerator() *SilenceGenerator {
- return &SilenceGenerator{}
+func NewSilenceGenerator() *silenceGenerator {
+ return &silenceGenerator{}
}
-func (s *SilenceGenerator) Reset(samplePeriod float64) {
+func (s *silenceGenerator) Reset(samplePeriod float64) {
// nothing here
}
-func (s *SilenceGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
+func (s *silenceGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
data = make([]float64, int(nSamples)*int(nChannels))
return
}
-type SinusGenerator struct {
+type sinusGenerator struct {
amp float64
freq float64
sp float64
t float64
}
-func NewSinusGenerator(ampDB, freq float64) (sin *SinusGenerator) {
- sin = &SinusGenerator{}
+func newSinusGenerator(ampDB, freq float64) (sin *sinusGenerator) {
+ sin = &sinusGenerator{}
sin.amp = math.Pow(10.0, (ampDB / 20.0))
sin.freq = freq
return
}
-func (sin *SinusGenerator) Reset(samplePeriod float64) {
+func (sin *sinusGenerator) Reset(samplePeriod float64) {
sin.sp = samplePeriod
sin.t = 0
}
-func (sin *SinusGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
+func (sin *sinusGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
data = make([]float64, int(nSamples)*int(nChannels))
for i := 0; i < int(nSamples); i++ {
val := sin.amp * math.Sin(2*math.Pi*sin.freq*sin.t)
diff --git a/rhimport/youtubedl_responses.go b/rhimport/youtubedl_responses.go
index 6f6d7ee..abc4f11 100644
--- a/rhimport/youtubedl_responses.go
+++ b/rhimport/youtubedl_responses.go
@@ -30,7 +30,7 @@ import (
"io"
)
-type YoutubeDLInfo struct {
+type youtubeDLInfo struct {
ID string `json:"id"`
Title string `json:"title"`
URL string `json:"url"`
@@ -41,9 +41,9 @@ type YoutubeDLInfo struct {
HTTPHeaders map[string]string `json:"http_headers"`
}
-func NewYoutubeDLInfoFromJSON(data io.Reader) (res *YoutubeDLInfo, err error) {
+func newYoutubeDLInfoFromJSON(data io.Reader) (res *youtubeDLInfo, err error) {
decoder := json.NewDecoder(data)
- res = &YoutubeDLInfo{}
+ res = &youtubeDLInfo{}
if jsonerr := decoder.Decode(res); jsonerr != nil {
err = fmt.Errorf("Error parsing JSON response: %s", jsonerr)
return
generated by cgit v0.10.2 at 2024-11-21 20:19:05 (GMT)