func TestGroupCompletedRedis(t *testing.T) {
redisURL := os.Getenv("REDIS_URL")
redisPassword := os.Getenv("REDIS_PASSWORD")
if redisURL == "" {
return
}
groupUUID := "testGroupUUID"
task1 := &signatures.TaskSignature{
UUID: "testTaskUUID1",
GroupUUID: groupUUID,
}
task2 := &signatures.TaskSignature{
UUID: "testTaskUUID2",
GroupUUID: groupUUID,
}
backend := backends.NewRedisBackend(&config.Config{}, redisURL, redisPassword, "", 0)
// Cleanup before the test
backend.PurgeState(task1.UUID)
backend.PurgeState(task2.UUID)
backend.PurgeGroupMeta(groupUUID)
groupCompleted, err := backend.GroupCompleted(groupUUID, 2)
if assert.Error(t, err) {
assert.False(t, groupCompleted)
assert.Equal(t, "redigo: nil returned", err.Error())
}
backend.InitGroup(groupUUID, []string{task1.UUID, task2.UUID})
groupCompleted, err = backend.GroupCompleted(groupUUID, 2)
if assert.Error(t, err) {
assert.False(t, groupCompleted)
assert.Equal(t, "Expected byte array, instead got: <nil>", err.Error())
}
backend.SetStatePending(task1)
backend.SetStateStarted(task2)
groupCompleted, err = backend.GroupCompleted(groupUUID, 2)
if assert.NoError(t, err) {
assert.False(t, groupCompleted)
}
backend.SetStateStarted(task1)
backend.SetStateSuccess(task2, new(backends.TaskResult))
groupCompleted, err = backend.GroupCompleted(groupUUID, 2)
if assert.NoError(t, err) {
assert.False(t, groupCompleted)
}
backend.SetStateFailure(task1, "Some error")
groupCompleted, err = backend.GroupCompleted(groupUUID, 2)
if assert.NoError(t, err) {
assert.True(t, groupCompleted)
}
}
// BackendFactory creates a new object with backends.Backend interface
// Currently supported backends are AMQP and Memcache
func BackendFactory(cnf *config.Config) (backends.Backend, error) {
if strings.HasPrefix(cnf.ResultBackend, "amqp://") {
return backends.NewAMQPBackend(cnf), nil
}
if strings.HasPrefix(cnf.ResultBackend, "memcache://") {
parts := strings.Split(cnf.ResultBackend, "memcache://")
if len(parts) != 2 {
return nil, fmt.Errorf(
"Memcache result backend connection string should be in format memcache://server1:port,server2:port, instead got %s",
cnf.ResultBackend,
)
}
servers := strings.Split(parts[1], ",")
return backends.NewMemcacheBackend(cnf, servers), nil
}
if strings.HasPrefix(cnf.ResultBackend, "redis://") {
redisHost, redisPassword, redisDB, err := ParseRedisURL(cnf.ResultBackend)
if err != nil {
return nil, err
}
return backends.NewRedisBackend(cnf, redisHost, redisPassword, "", redisDB), nil
}
if strings.HasPrefix(cnf.ResultBackend, "redis+socket://") {
redisSocket, redisPassword, redisDB, err := ParseRedisSocketURL(cnf.ResultBackend)
if err != nil {
return nil, err
}
return backends.NewRedisBackend(cnf, "", redisPassword, redisSocket, redisDB), nil
}
if strings.HasPrefix(cnf.ResultBackend, "mongodb://") {
return backends.NewMongodbBackend(cnf)
}
if strings.HasPrefix(cnf.ResultBackend, "eager") {
return backends.NewEagerBackend(), nil
}
return nil, fmt.Errorf("Factory failed with result backend: %v", cnf.ResultBackend)
}
func TestGetStateRedis(t *testing.T) {
redisURL := os.Getenv("REDIS_URL")
redisPassword := os.Getenv("REDIS_PASSWORD")
if redisURL == "" {
return
}
signature := &signatures.TaskSignature{
UUID: "testTaskUUID",
GroupUUID: "testGroupUUID",
}
backend := backends.NewRedisBackend(new(config.Config), redisURL, redisPassword, "", 0)
go func() {
backend.SetStatePending(signature)
<-time.After(2 * time.Millisecond)
backend.SetStateReceived(signature)
<-time.After(2 * time.Millisecond)
backend.SetStateStarted(signature)
<-time.After(2 * time.Millisecond)
taskResult := &backends.TaskResult{
Type: "float64",
Value: 2,
}
backend.SetStateSuccess(signature, taskResult)
}()
var (
taskState *backends.TaskState
err error
)
for {
taskState, err = backend.GetState(signature.UUID)
if taskState == nil {
assert.Equal(t, "redigo: nil returned", err.Error())
continue
}
assert.NoError(t, err)
if taskState.IsCompleted() {
break
}
}
}
func TestPurgeStateRedis(t *testing.T) {
redisURL := os.Getenv("REDIS_URL")
redisPassword := os.Getenv("REDIS_PASSWORD")
if redisURL == "" {
return
}
signature := &signatures.TaskSignature{
UUID: "testTaskUUID",
GroupUUID: "testGroupUUID",
}
backend := backends.NewRedisBackend(new(config.Config), redisURL, redisPassword, "", 0)
backend.SetStatePending(signature)
taskState, err := backend.GetState(signature.UUID)
assert.NotNil(t, taskState)
assert.NoError(t, err)
backend.PurgeState(taskState.TaskUUID)
taskState, err = backend.GetState(signature.UUID)
assert.Nil(t, taskState)
assert.Error(t, err)
}
func TestBackendFactory(t *testing.T) {
var cnf config.Config
// 1) AMQP backend test
cnf = config.Config{ResultBackend: "amqp://*****:*****@localhost:5672/"}
actual, err := machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
expected := backends.NewAMQPBackend(&cnf)
assert.True(
t,
reflect.DeepEqual(actual, expected),
fmt.Sprintf("conn = %v, want %v", actual, expected),
)
}
// 2) Memcache backend test
cnf = config.Config{
ResultBackend: "memcache://10.0.0.1:11211,10.0.0.2:11211",
}
actual, err = machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
servers := []string{"10.0.0.1:11211", "10.0.0.2:11211"}
expected := backends.NewMemcacheBackend(&cnf, servers)
assert.True(
t,
reflect.DeepEqual(actual, expected),
fmt.Sprintf("conn = %v, want %v", actual, expected),
)
}
// 2) Redis backend test
// with password
cnf = config.Config{
ResultBackend: "redis://password@localhost:6379",
}
actual, err = machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
expected := backends.NewRedisBackend(&cnf, "localhost:6379", "password", "", 0)
assert.True(
t,
reflect.DeepEqual(actual, expected),
fmt.Sprintf("conn = %v, want %v", actual, expected),
)
}
// without password
cnf = config.Config{
ResultBackend: "redis://localhost:6379",
}
actual, err = machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
expected := backends.NewRedisBackend(&cnf, "localhost:6379", "", "", 0)
assert.True(
t,
reflect.DeepEqual(actual, expected),
fmt.Sprintf("conn = %v, want %v", actual, expected),
)
}
// using a socket file
cnf = config.Config{
ResultBackend: "redis+socket:///tmp/redis.sock",
}
actual, err = machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
expected := backends.NewRedisBackend(&cnf, "", "", "/tmp/redis.sock", 0)
assert.True(
t,
reflect.DeepEqual(actual, expected),
fmt.Sprintf("conn = %v, want %v", actual, expected),
)
}
// 4) MongoDB backend test
cnf = config.Config{
ResultBackend: "mongodb://localhost:27017/tasks",
}
actual, err = machinery.BackendFactory(&cnf)
if assert.NoError(t, err) {
assert.NotNil(t, actual)
}
}