func()

in providers/ibm/cloud_functions.go [107:240]
111 lines of code
18 McCabe index (conditional complexity)

func (g *CloudFunctionGenerator) InitResources() error {
	region := g.Args["region"].(string)
	bmxConfig := &bluemix.Config{
		BluemixAPIKey: os.Getenv("IC_API_KEY"),
	}

	bmxConfig.Region = region

	sess, err := session.New(bmxConfig)
	if err != nil {
		return err
	}

	err = authenticateAPIKey(sess)
	if err != nil {
		return err
	}

	err = authenticateCF(sess)
	if err != nil {
		return err
	}

	nsClient, err := ns.New(sess)
	if err != nil {
		return err
	}

	nsList, err := nsClient.Namespaces().GetNamespaces()
	if err != nil {
		return nil
	}

	for _, n := range nsList.Namespaces {
		// Namespace
		if !n.IsIamEnabled() {
			continue
		}

		// Build whisk object
		wskClient, err := setupOpenWhiskClientConfigIAM(n, sess.Config, region)
		if err != nil {
			return err
		}

		// Package
		packageService := wskClient.Packages
		pkgOptions := &whisk.PackageListOptions{
			Limit: 100,
			Skip:  0,
		}
		pkgs, _, err := packageService.List(pkgOptions)
		if err != nil {
			return fmt.Errorf("Error retrieving IBM Cloud Function package: %s", err)
		}

		for _, p := range pkgs {
			g.Resources = append(g.Resources, g.loadPackages(n.GetName(), p.GetName()))
		}

		// Action
		actionService := wskClient.Actions
		actionOptions := &whisk.ActionListOptions{
			Limit: 100,
			Skip:  0,
		}
		actions, _, err := actionService.List("", actionOptions)
		if err != nil {
			return fmt.Errorf("Error retrieving IBM Cloud Function action: %s", err)
		}

		for _, a := range actions {
			actionID := ""
			parts := strings.Split(a.Namespace, "/")
			if len(parts) == 2 {
				var pkgDependsOn []string
				pkgDependsOn = append(pkgDependsOn,
					"ibm_function_package."+terraformutils.TfSanitize(fmt.Sprintf("%s_%s", n.GetName(), parts[1])))
				actionID = fmt.Sprintf("%s/%s", parts[1], a.Name)
				g.Resources = append(g.Resources, terraformutils.NewResource(
					fmt.Sprintf("%s:%s", n.GetName(), actionID),
					normalizeResourceName(a.Name, true),
					"ibm_function_action",
					"ibm",
					map[string]string{},
					[]string{},
					map[string]interface{}{
						"depends_on": pkgDependsOn,
					}))
			} else {
				g.Resources = append(g.Resources, terraformutils.NewResource(
					fmt.Sprintf("%s:%s", n.GetName(), a.Name),
					normalizeResourceName(a.Name, true),
					"ibm_function_action",
					"ibm",
					map[string]string{},
					[]string{},
					map[string]interface{}{}))
			}
		}

		// Rule
		ruleService := wskClient.Rules
		ruleOptions := &whisk.RuleListOptions{
			Limit: 100,
			Skip:  0,
		}
		rules, _, err := ruleService.List(ruleOptions)
		if err != nil {
			return fmt.Errorf("Error retrieving IBM Cloud Function rule: %s", err)
		}

		for _, r := range rules {
			g.Resources = append(g.Resources, g.loadRules(n.GetName(), r.Name))
		}

		// Triggers
		triggerService := wskClient.Triggers
		triggerOptions := &whisk.TriggerListOptions{
			Limit: 100,
			Skip:  0,
		}
		triggers, _, err := triggerService.List(triggerOptions)
		if err != nil {
			return fmt.Errorf("Error retrieving IBM Cloud Function trigger: %s", err)
		}

		for _, t := range triggers {
			g.Resources = append(g.Resources, g.loadTriggers(n.GetName(), t.Name))
		}
	}

	return nil
}