func (parser *Parser) mapMessenger(messengerMap map[interface{}]interface{}) (messengers.Messenger, error) { messengerType := messengerMap["type"].(string) log.Info("type of reporter is " + messengerType) messenger, err := messengers.InitMessenger(messengerType) if err != nil { return nil, err } newMessengerValue := reflect.ValueOf(messenger).Elem() newMessengerType := reflect.TypeOf(messenger).Elem() for i := 0; i < newMessengerType.NumField(); i++ { tagName := newMessengerType.Field(i).Tag.Get("config") for messengerOptKey, messengerOptVal := range messengerMap { if tagName != messengerOptKey { continue } fieldVal := newMessengerValue.Field(i) if fieldVal.Type() == reflect.ValueOf("string").Type() { fieldVal.SetString(parser.EnvVariables.Replace(messengerOptVal.(string))) } else if fieldVal.Type().String() == "messengers.BaseMessenger" { elements := messengerOptVal.([]interface{}) suppressor := fieldVal.Interface().(messengers.BaseMessenger) for _, element := range elements { suppressor.SuppressFields = append(suppressor.SuppressFields, element.(string)) } fieldVal.Set(reflect.ValueOf(suppressor)) } } } return messenger, 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 }