Exemple #1
0
func NewRunner(verbose bool, logger *log.Logger) (*Runner, error) {
	this := new(Runner)
	this.logger = logger
	q, err := lentil.Dial(Config.QueueAddr)

	if err != nil {
		return nil, err
	}

	this.q = q
	this.verbose = verbose
	return this, nil
}
Exemple #2
0
func SendQueue(queue string, content string) {

	beanstalkd, err := lentil.Dial(Config.Genral.BeanstalkServer)
	if err != nil {
		log.Error(err)
	} else {
		err = beanstalkd.Use(queue)
	}
	if err != nil {
		log.Error(err)
	} else {
		beanstalkd.Put(0, 0, 30, []byte(content))
	}
}
Exemple #3
0
func NewListener(verbose, inclusive bool, filter []string, logpath string) (*Listener, error) {
	this := new(Listener)
	this.logpath = logpath
	err := this.resetLog()
	if err != nil {
		return nil, err
	}
	q, err := lentil.Dial(Config.QueueAddr)
	if err != nil {
		return nil, err
	}
	this.q = q
	this.verbose = verbose
	this.jobqueue = NewJobQueue(this.q, inclusive, filter)
	return this, nil
}
Exemple #4
0
//NewQueueService constructs a QueueService
func NewQueueService(tube string) *QueueService {
	conn, e := lentil.Dial(os.Getenv("QUEUE_BEANSTALK_HOST") + ":11300")
	if e != nil {
		log.Fatal(e)
	}
	tubeName := ""
	switch tube {
	case "luminous":
		tubeName = os.Getenv("QUEUE_PREDICT")
	case "go":
		tubeName = os.Getenv("QUEUE_GOPREDICT")
	}
	conn.Use(tubeName)
	return &QueueService{
		conn: conn,
	}
}
Exemple #5
0
func (j *Jobsms) Run() {
	for {
		Utils.LogInfo("Jobsms delay %d Second", Config.GetLoopTime().Sms)
		time.Sleep(time.Second * Config.GetLoopTime().Sms)

		beanstalkd, err := lentil.Dial(Config.GetBeanstalk().Server)
		if err != nil {
			Utils.LogPanicErr(err)
		} else {
			err = beanstalkd.Use(Config.GetBeanstalk().MobileQueue)
		}

		if err != nil {
			Utils.LogPanicErr(err)
		} else {
			for i := 0; i < 10; i++ {
				job, err := beanstalkd.PeekReady()
				if err != nil {
					//Utils.LogPanicErr(err)
					break
				} else {
					body := strings.SplitN(string(job.Body), "\t", 2)
					if len(body) == 2 {
						r, err := base64.StdEncoding.DecodeString(body[1])
						if err == nil {
							fmt.Printf("Job id: %d  \nmobile: %s \nbody: %s", job.Id, body[0], string(r))
							e := SendSms(body[0], string(r))
							if e != nil {
								Utils.LogPanicErr(e)
							}
						}
					}
					beanstalkd.Delete(job.Id)
				}
			}
		}

	}
}
Exemple #6
0
func BenchmarkPuttingJobsOld(b *testing.B) {
	b.StopTimer()
	client, err := lentil.Dial("127.0.0.1:11300")
	if err != nil {
		b.Logf("Beanstalkd connection error: ")
		b.FailNow()
	}

	defer client.Quit()

	var testString string = "{14113 http://www.musicload.de 10 200 OK ms:=http://www.musicload.de#options 10 3 98018 [14 12] 1341217746}"
	var testTube string = "test_tube"
	err = client.Use(testTube)
	if err != nil {
		b.Logf("Trouble with selecting correct tube in beanstalk %s\n", err)
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		_, _ = client.Put(10, 0, 120, []byte(testString))

	}
}
Exemple #7
0
func BenchmarkReservingJobsOld(b *testing.B) {
	b.StopTimer()

	client, err := lentil.Dial("127.0.0.1:11300")
	if err != nil {
		b.Logf("Beanstalkd connection error: ")
		b.FailNow()
	}

	defer client.Quit()

	var testTube string = "test_tube"

	_, err = client.Watch(testTube)
	if err != nil {
		b.Logf("Trouble with selecting correct tube in beanstalk %s\n", err)
	}

	b.StartTimer()
	for i := 0; i < b.N; i++ {
		_, _ = client.Reserve()
	}

}
Exemple #8
0
func (j *Jobmail) Run() {
	for {

		Utils.LogInfo("Jobmail delay %d Second", Config.GetLoopTime().Mail)
		time.Sleep(time.Second * Config.GetLoopTime().Mail)
		beanstalkd, err := lentil.Dial(Config.GetBeanstalk().Server)
		if err != nil {
			Utils.LogPanicErr(err)
		} else {
			err = beanstalkd.Use(Config.GetBeanstalk().MailQueue)
		}
		if err != nil {
			Utils.LogPanicErr(err)
		} else {
			for i := 0; i < 10; i++ {
				job, err := beanstalkd.PeekReady()
				if err != nil {
					//Utils.LogPanicErr(err)
					break
				} else {
					body := strings.SplitN(string(job.Body), "\t", 4)
					if len(body) == 4 {
						r, err := base64.StdEncoding.DecodeString(body[3])
						if err == nil {
							fmt.Printf("Job id: %d  \nmail to:%s \nsubject:%s\nbody: , %s", job.Id, body[0], body[1], string(r))
							//SendMail( body[0], body[1], string(r), body[2])
							SendMailBySohu(body[0], body[1], string(r))
						}
					}
					beanstalkd.Delete(job.Id)
				}
			}
		}

	}
}
Exemple #9
0
func connect(t *testing.T) *lentil.Beanstalkd {
	gq := os.Getenv("GLOW_QUEUE")
	if gq == "" {
		gq = "localhost:11300"
	}
	q, e := lentil.Dial(gq)
	if e != nil {
		t.Fatal(e)
	}
	// Clear beanstalkd
	tubes, e := q.ListTubes()
	if e != nil {
		t.Fatal(e)
	}
	for _, tube := range tubes {
		if tube == "default" {
			continue
		}
		_, e = q.Watch(tube)
		if e != nil {
			t.Fatal(e)
		}
		for {
			job, e := q.ReserveWithTimeout(0)
			if e != nil {
				break
			}
			q.Delete(job.Id)
		}
		_, e := q.Ignore(tube)
		if e != nil {
			t.Fatal(e)
		}
	}
	return q
}
// 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
		}
	}
}
Exemple #12
0
func main() {
	lentil.ReaderSize = 65536
	flag.Parse()
	log.SetFlags(0)
	q, e := lentil.Dial(*addr)
	err(e)
	if *listTubes {
		tubes, e := q.ListTubes()
		err(e)
		for _, tube := range tubes {
			fmt.Println(tube)
		}
		os.Exit(0)
	}
	if *pauseTube != "" {
		if *delay == 0 {
			log.Fatal("Usage: lentil pause-tube=<tube> delay=<seconds>")
		}
		e := q.PauseTube(*pauseTube, *delay)
		err(e)
		os.Exit(0)
	}
	if *statsTube != "" {
		stats, e := q.StatsTube(*statsTube)
		err(e)
		for k, v := range stats {
			fmt.Printf("%s:%s\n", k, v)
		}
		os.Exit(0)
	}
	if *stats {
		stats, e := q.Stats()
		err(e)
		for k, v := range stats {
			fmt.Printf("%s:%s\n", k, v)
		}
		os.Exit(0)
	}
	if *drain != "" {
		_, e := q.Watch(*drain)
		err(e)
		if *drain != "default" {
			_, e = q.Ignore("default")
			err(e)
		}
		for {
			job, e := q.ReserveWithTimeout(0)
			if e != nil {
				if e.Error() == "TIMED_OUT\r\n" {
					break
				}
				log.Fatal(e)
			}
			fmt.Printf("%d:%s\n", job.Id, job.Body)
			e = q.Delete(job.Id)
			err(e)
		}
		os.Exit(0)
	}
	if *put != "" {
		e = q.Use(*tube)
		err(e)
		id, e := q.Put(*pri, *delay, *ttr, []byte(*put))
		err(e)
		fmt.Printf("id:%d\n", id)
		os.Exit(0)
	}
	if *peek != 0 {
		job, e := q.Peek(uint64(*peek))
		err(e)
		fmt.Printf("%d:%s\n", job.Id, job.Body)
		os.Exit(0)
	}
	if *peekBuried {
		e := q.Use(*tube)
		err(e)
		job, e := q.PeekBuried()
		err(e)
		fmt.Printf("%d:%s\n", job.Id, job.Body)
		os.Exit(0)
	}
	if *peekDelayed {
		e := q.Use(*tube)
		err(e)
		job, e := q.PeekDelayed()
		err(e)
		fmt.Printf("%d:%s\n", job.Id, job.Body)
		os.Exit(0)
	}
	if *kick != 0 {
		e := q.Use(*tube)
		err(e)
		kicked, e := q.Kick(*kick)
		err(e)
		fmt.Printf("%d\n", kicked)
		os.Exit(0)
	}
	if *del != 0 {
		e := q.Delete(uint64(*del))
		err(e)
		os.Exit(0)
	}

	flag.Usage()
	os.Exit(1)
}