Example #1
0
func withRandomReservedJob(t *testing.T, conn *beanstalk.Conn) *Job {
	withRandomJob(t, conn)
	id, body, err := conn.Reserve(0)
	if err != nil {
		t.Fail()
	}
	return NewJob(conn, "default", id, body)
}
Example #2
0
func consumer() {
	var c *beanstalk.Conn = nil
	for {
		// connect to beanstalkd, infinite loop,
		if c == nil {
			var err error = nil
			c, err = beanstalk.Dial("tcp", CONN_BS_HOST+":"+CONN_BS_PORT)
			if err != nil {
				fmt.Println("Error connect to beanstalkd:", err.Error())
			} else {
				fmt.Println("Consumer connect to beanstalkd successfully.")
			}
		}

		/*
		   keys := make([]string, 0, len(mSNConn))
		   for k := range mSNConn {
		     keys = append(keys, k)
		   }
		   tubeSet := beanstalk.NewTubeSet(c, keys...)
		   id, body, err := tubeSet.Reserve(5*time.Second)
		*/
		// blocking api
		id, body, err := c.Reserve(120 * time.Second)
		if err != nil {
			// this err indicate the job queue is empty
			//fmt.Println("Error comsume beanstalk:", err.Error())
		} else {
			//
			val, ok := mSNConn[string(body[:3])]
			if ok {
				val.Write(body)
			}
			// delete job
			c.Delete(id)
			fmt.Printf("task id is: 【%d】; task content is 【%s】\n", id, string(body))
		}
	}
}
Example #3
0
func main() {
	flag.Parse()

	if len(ignoreChannels) > 0 {
		common.SetIgnores(ignoreChannels)
	}

	var (
		bs  *beanstalk.Conn
		err error
	)

	if len(flag.Args()) >= 1 {
		bs, err = beanstalk.Dial("tcp", flag.Args()[0])

		if err != nil {
			log.Fatal(err)
		}

		if !quiet {
			log.Printf("Connected to [%s]", flag.Args()[0])
		}

		if len(flag.Args()) >= 2 {
			bs.Tube.Name = flag.Args()[1]
		}
	} else {
		log.Fatalf("provide the beanstalk publisher! like example.com:11300")
	}

	//Clear out the old messages before we start back up
	for {
		id, msg, err := bs.Reserve(5 * time.Second)

		if !quiet {
			noti_msg := common.IrcNotify{}
			json.Unmarshal(msg, &noti_msg)

			log.Printf("removing old message [%s]", noti_msg.Message)
		}

		if err != nil {
			break
		}

		err = bs.Delete(id)

		if err != nil {
			log.Fatal(err)
		}
	}

	for {
		id, msg, err := bs.Reserve(5 * time.Second)

		if err == nil {
			noti_msg := common.IrcNotify{}
			json.Unmarshal(msg, &noti_msg)

			go common.Display(noti_msg, linger, quiet)

			err = bs.Delete(id)

			if err != nil {
				log.Fatal(err)
			}
		}

		time.Sleep(500 * time.Millisecond)
	}
}