grim/convey
Clone
Summary
Browse
Changes
Graph
closing merged branch
hostnames
2017-10-13, Gary Kramlich
33eae19fcbbe
closing merged branch
package
convey
import
(
"fmt"
"strings"
"github.com/go-yaml/yaml"
cConfig
"bitbucket.org/rw_grim/convey/config"
"bitbucket.org/rw_grim/convey/tasks"
)
func
findTask
(
rawType
string
)
(
cConfig
.
TaskMap
,
error
)
{
found
:=
[]
string
{}
for
engName
,
taskMap
:=
range
cConfig
.
TasksMap
{
for
taskType
,
_
:=
range
taskMap
.
Tasks
{
if
taskType
==
rawType
{
found
=
append
(
found
,
engName
)
}
}
}
if
len
(
found
)
==
0
{
return
cConfig
.
TaskMap
{},
fmt
.
Errorf
(
"no task type '%s' found"
,
rawType
)
}
else
if
len
(
found
)
>
1
{
return
cConfig
.
TaskMap
{},
fmt
.
Errorf
(
"found multiple engines supporting %s, please specify which (%s)"
,
rawType
,
strings
.
Join
(
found
,
", "
),
)
}
return
cConfig
.
TasksMap
[
found
[
0
]],
nil
}
func
loadTasks
(
path
string
,
raw
map
[
string
]
yaml
.
MapSlice
)
(
map
[
string
]
tasks
.
Task
,
error
)
{
realTasks
:=
map
[
string
]
tasks
.
Task
{}
for
name
,
task
:=
range
raw
{
realTask
,
err
:=
loadTask
(
name
,
task
)
if
err
!=
nil
{
return
nil
,
err
}
realTasks
[
name
]
=
realTask
}
return
realTasks
,
nil
}
func
loadTask
(
name
string
,
task
yaml
.
MapSlice
)
(
tasks
.
Task
,
error
)
{
// figure out the engine and type for the task
var
(
rawEngine
string
rawType
string
)
for
_
,
item
:=
range
task
{
switch
item
.
Key
.(
string
)
{
case
"engine"
:
rawEngine
=
item
.
Value
.(
string
)
case
"type"
:
rawType
=
item
.
Value
.(
string
)
}
}
var
engineMap
cConfig
.
TaskMap
// if the engine wasn't specified search based on the task type
if
rawEngine
==
""
{
// if the task type wasn't specified use the default engine
if
rawType
==
""
{
engineMap
=
cConfig
.
TasksMap
[
cConfig
.
DefaultEngine
]
}
else
{
eMap
,
err
:=
findTask
(
rawType
)
if
err
!=
nil
{
return
nil
,
err
}
engineMap
=
eMap
}
}
else
{
// now see if we have the task for the given engine
eMap
,
found
:=
cConfig
.
TasksMap
[
rawEngine
]
if
!
found
{
return
nil
,
fmt
.
Errorf
(
"unknown engine '%s'"
,
rawEngine
)
}
engineMap
=
eMap
}
// if we don't have a rawType use the default for the engine
if
rawType
==
""
{
rawType
=
engineMap
.
Default
}
taskType
,
found
:=
engineMap
.
Tasks
[
rawType
]
if
!
found
{
return
nil
,
fmt
.
Errorf
(
"unknown task type '%s'"
,
rawType
)
}
realTask
,
err
:=
tasks
.
CloneTask
(
task
,
taskType
)
if
err
!=
nil
{
return
nil
,
err
}
err
=
realTask
.
Valid
()
if
err
!=
nil
{
return
nil
,
fmt
.
Errorf
(
"%s: %s"
,
name
,
err
.
Error
())
}
return
realTask
,
nil
}