func put(t *testing.T, jobName, tube string, delay int, q *lentil.Beanstalkd) {
job := make(map[string]string)
job["tube"] = tube
job["name"] = jobName
jobjson, _ := json.Marshal(job)
e := q.Use(tube)
if e != nil {
t.Fatal(e)
}
_, e = q.Put(0, delay, 60, jobjson)
if e != nil {
t.Error(e)
}
}
func queryTubes(q *lentil.Beanstalkd) (map[string]*Tube, error) {
tubes := make(map[string]*Tube)
names, e := q.ListTubes()
if e != nil {
return nil, e
}
for _, tube := range names {
if tube == "default" {
continue
}
tubestats, e := q.StatsTube(tube)
if e != nil {
continue
}
ready, _ := strconv.Atoi(tubestats["current-jobs-ready"])
reserved, _ := strconv.Atoi(tubestats["current-jobs-reserved"])
delayed, _ := strconv.Atoi(tubestats["current-jobs-delayed"])
pause, _ := strconv.Atoi(tubestats["pause"])
tubes[tube] = NewTube(tube, uint(reserved), uint(ready), uint(delayed), uint(pause))
}
return tubes, nil
}
// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *ToBeanstalkd) Run() {
var conn *lentil.Beanstalkd
var tube = "default"
var ttr = 0
var host = ""
var err error
for {
select {
case msgI := <-b.inrule:
// set hostname for beanstalkd server
host, err = util.ParseString(msgI, "Host")
if err != nil {
b.Error(err.Error())
continue
}
// set tube name
tube, err = util.ParseString(msgI, "Tube")
if err != nil {
b.Error(errors.New("Could not parse tube name, setting to 'default'"))
tube = "default"
}
// set time to reserve
ttr, err = util.ParseInt(msgI, "TTR")
if err != nil || ttr < 0 {
b.Error(errors.New("Error parsing TTR. Setting TTR to 0"))
ttr = 0
}
// create beanstalkd connection
conn, err = lentil.Dial(host)
if err != nil {
// swallowing a panic from lentil here - streamtools must not die
b.Error(errors.New("Could not initiate connection with beanstalkd server"))
continue
}
// use the specified tube
conn.Use(tube)
case <-b.quit:
// close connection to beanstalkd and quit
if conn != nil {
conn.Quit()
}
return
case msg := <-b.in:
// deal with inbound data
msgStr, err := json.Marshal(msg)
if err != nil {
b.Error(err)
continue
}
if conn != nil {
_, err := conn.Put(0, 0, ttr, msgStr)
if err != nil {
b.Error(err.Error())
}
} else {
b.Error(errors.New("Beanstalkd connection not initated or lost. Please check your beanstalkd server or block settings."))
}
case respChan := <-b.queryrule:
// deal with a query request
respChan <- map[string]interface{}{
"Host": host,
"Tube": tube,
"TTR": ttr,
}
}
}
}
func ToBeanstalkd(b *Block) {
type toBeanstalkdRule struct {
Host string
Tube string
TTR int
}
var conn *lentil.Beanstalkd
var e error
var tube = "default"
var ttr = 0
var rule *toBeanstalkdRule
for {
select {
case m := <-b.Routes["set_rule"]:
if rule == nil {
rule = &toBeanstalkdRule{}
}
unmarshal(m, rule)
conn, e = lentil.Dial(rule.Host)
if e != nil {
log.Println(e.Error())
} else {
if len(rule.Tube) > 0 {
tube = rule.Tube
}
if rule.TTR > 0 {
ttr = rule.TTR
}
conn.Use(tube)
log.Println("initialized connection using tube:", tube)
}
case r := <-b.Routes["get_rule"]:
if rule == nil {
marshal(r, &toBeanstalkdRule{})
} else {
marshal(r, rule)
}
case msg := <-b.InChan:
if rule == nil {
break
}
msgStr, err := json.Marshal(msg.Msg)
if err != nil {
log.Println("wow bad json")
break
}
if conn == nil {
log.Panic("Connection to beanstalkd was dropped. Something is not right.")
break
}
jobId, err := conn.Put(0, 0, ttr, msgStr)
if err != nil {
log.Println(err.Error())
} else {
log.Println("put job on queue: Job Id:", jobId)
}
case msg := <-b.AddChan:
updateOutChans(msg, b)
case <-b.QuitChan:
quit(b)
return
}
}
}