func (parser *Parser) mapService(serviceMap map[interface{}]interface{}) (services.Service, error) {
serviceType := serviceMap["type"].(string)
log.Info("type of service is " + serviceType)
service, err := services.InitService(serviceType)
if err != nil {
return nil, err
}
newServiceValue := reflect.ValueOf(service).Elem()
newServiceType := reflect.TypeOf(service).Elem()
for i := 0; i < newServiceType.NumField(); i++ {
tagName := newServiceType.Field(i).Tag.Get("config")
for serviceOptKey, serviceOptVal := range serviceMap {
if tagName != serviceOptKey {
continue
}
fieldVal := newServiceValue.Field(i)
if fieldVal.Type() == reflect.ValueOf("string").Type() {
fieldVal.SetString(parser.EnvVariables.Replace(serviceOptVal.(string)))
}
}
}
return service, nil
}
// Parse reads the specified configuration and create the pipeline.Resource.
func (parser *Parser) Parse() (*pipelines.Resources, error) {
// parse require block
requireFiles, ok := (*parser.ConfigData)["require"].([]interface{})
var required map[string]map[interface{}]interface{}
var err error
if ok == true {
log.Info("found \"require\" block")
required, err = parser.mapRequires(requireFiles)
if err != nil {
log.Error("failed to load requires...")
return nil, err
}
log.Info("number of registered stages: " + strconv.Itoa(len(required)))
} else {
log.Info("not found \"require\" block")
}
// parse service block
serviceOps, ok := (*parser.ConfigData)["service"].(map[interface{}]interface{})
var repoService services.Service
if ok == true {
log.Info("found \"service\" block")
repoService, err = parser.mapService(serviceOps)
if err != nil {
log.Error("failed to load service settings...")
return nil, err
}
} else {
log.Info("not found \"service\" block")
repoService, err = services.InitService("local")
if err != nil {
log.Error("failed to init local mode...")
return nil, err
}
}
// parse messenger block
messengerOps, ok := (*parser.ConfigData)["messenger"].(map[interface{}]interface{})
var messenger messengers.Messenger
if ok == true {
log.Info("found messenger block")
messenger, err = parser.mapMessenger(messengerOps)
if err != nil {
log.Error("failed to init messenger...")
return nil, err
}
} else {
log.Info("not found messenger block")
messenger, err = messengers.InitMessenger("fake")
if err != nil {
return nil, err
}
}
// parse cleanup block
var cleanup = &pipelines.Pipeline{}
cleanupData, ok := (*parser.ConfigData)["cleanup"].([]interface{})
if ok == true {
log.Info("found cleanup block")
cleanupList, err := parser.convertYamlMapToStages(cleanupData, required)
if err != nil {
log.Error("failed to create a stage in cleanup...")
return nil, err
}
for stageItem := cleanupList.Front(); stageItem != nil; stageItem = stageItem.Next() {
cleanup.AddStage(stageItem.Value.(stages.Stage))
}
} else {
log.Info("not found cleanup block in the input file")
}
// parse pipeline block
var pipeline = &pipelines.Pipeline{}
pipelineData, ok := (*parser.ConfigData)["pipeline"].([]interface{})
if ok == false {
return nil, fmt.Errorf("no pipeline block in the input file")
}
stageList, err := parser.convertYamlMapToStages(pipelineData, required)
if err != nil {
log.Error("failed to create a stage in pipeline...")
return nil, err
}
for stageItem := stageList.Front(); stageItem != nil; stageItem = stageItem.Next() {
pipeline.AddStage(stageItem.Value.(stages.Stage))
}
var resources = &pipelines.Resources{Pipeline: pipeline, Cleanup: cleanup, Reporter: messenger, RepoService: repoService}
return resources, nil
}