Golang log.Errorf函数代码示例

func cmdRm(c *cli.Context) {
	if len(c.Args()) == 0 {
		cli.ShowCommandHelp(c, "rm")
		fatal("You must specify a machine name")
	}

	force := c.Bool("force")
	store := getStore(c)

	for _, hostName := range c.Args() {
		h, err := loadHost(store, hostName)
		if err != nil {
			fatalf("Error removing host %q: %s", hostName, err)
		}
		if err := h.Driver.Remove(); err != nil {
			if !force {
				log.Errorf("Provider error removing machine %q: %s", hostName, err)
				continue
			}
		}

		if err := store.Remove(hostName); err != nil {
			log.Errorf("Error removing machine %q from store: %s", hostName, err)
		} else {
			log.Infof("Successfully removed %s", hostName)
		}
	}
}

func (d *Driver) Remove() error {
	s, err := d.GetState()
	if err != nil {
		if err == ErrMachineNotExist {
			log.Infof("machine does not exist, assuming it has been removed already")
			return nil
		}
		return err
	}
	if s == state.Running {
		if err := d.Stop(); err != nil {
			return err
		}
	}

	if err := d.removeDiskImage(); err != nil {
		return err
	}

	if d.NFSShare {
		log.Infof("Remove NFS share folder must be root. Please insert root password.")
		if _, err := nfsexports.Remove("", d.nfsExportIdentifier()); err != nil {
			log.Errorf("failed removing nfs share: %s", err.Error())
		}

		if err := nfsexports.ReloadDaemon(); err != nil {
			log.Errorf("failed reload nfs daemon: %s", err.Error())
		}
	}
	return nil
}

// SubmitDeploymentJobs api call to deployment jobs
func (c *ICSPClient) SubmitDeploymentJobs(dj DeploymentJobs) (jt *JobTask, err error) {
	log.Info("Applying OS Build plan for ICSP")
	var (
		uri  = "/rest/os-deployment-jobs"
		juri ODSUri
	)
	// refresh login
	c.RefreshLogin()
	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	jt = jt.NewJobTask(c)
	jt.Reset()
	data, err := c.RestAPICall(rest.POST, uri, dj)
	if err != nil {
		jt.IsDone = true
		log.Errorf("Error submitting new build request: %s", err)
		return jt, err
	}

	log.Debugf("Response submit new os build plan job %s", data)
	if err := json.Unmarshal([]byte(data), &juri); err != nil {
		jt.IsDone = true
		jt.JobURI = juri
		log.Errorf("Error with task un-marshal: %s", err)
		return jt, err
	}
	jt.JobURI = juri

	return jt, err
}

func (c *I3SClient) UpdateGoldenImage(goldenImage GoldenImage) error {
	log.Infof("Initializing update of golden image for %s.", goldenImage.Name)
	var (
		uri = goldenImage.URI.String()
		t   *Task
	)

	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, goldenImage)
	log.Debugf("task -> %+v", t)
	data, err := c.RestAPICall(rest.PUT, uri, goldenImage)
	if err != nil {
		t.TaskIsDone = true
		log.Errorf("Error submitting update golden image request: %s", err)
		return err
	}

	log.Debugf("Response update Golden Image %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	err = t.Wait()
	if err != nil {
		return err
	}

	return nil
}

func (c *OVClient) UpdateProfileTemplate(serverProfileTemplate ServerProfile) error {
	log.Infof("Initializing update of server profile template for %s.", serverProfileTemplate.Name)
	var (
		uri = serverProfileTemplate.URI.String()
		t   *Task
	)
	// refresh login
	c.RefreshLogin()
	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewProfileTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, serverProfileTemplate)
	log.Debugf("task -> %+v", t)
	data, err := c.RestAPICall(rest.PUT, uri, serverProfileTemplate)
	if err != nil {
		t.TaskIsDone = true
		log.Errorf("Error submitting update server profile template request: %s", err)
		return err
	}

	log.Debugf("Response update ServerProfileTemplate %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	err = t.Wait()
	if err != nil {
		return err
	}

	return nil
}

// submit new profile template
func (c *OVClient) SubmitDeleteProfile(p ServerProfile) (t *Task, err error) {
	var (
		uri = p.URI.String()
	// 	task = rest_api(:oneview, :post, '/rest/server-profiles', { 'body' => new_template_profile })
	)
	t = t.NewProfileTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, p)
	log.Debugf("task -> %+v", t)
	if uri == "" {
		log.Warn("Unable to post delete, no uri found.")
		t.TaskIsDone = true
		return t, err
	}
	data, err := c.RestAPICall(rest.DELETE, uri, nil)
	if err != nil {
		log.Errorf("Error submitting new profile request: %s", err)
		t.TaskIsDone = true
		return t, err
	}

	log.Debugf("Response delete profile %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return t, err
	}

	return t, err
}

func (c *I3SClient) CreatePlanScript(planScript PlanScript) error {
	log.Infof("Initializing creation of plan script for %s.", planScript.Name)
	var (
		uri                 = "/rest/plan-scripts"
		attemptedPlanScript *PlanScript
	)

	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	data, err := c.RestAPICall(rest.POST, uri, planScript)
	if err != nil {
		log.Errorf("Error submitting new plan script request: %s", err)
		return err
	}

	log.Debugf("Response New Plan Script %s", data)
	if err := json.Unmarshal([]byte(data), &attemptedPlanScript); err != nil {
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	if attemptedPlanScript.URI == "" {
		return fmt.Errorf("PlanScript not succesfully created")
	}

	return nil
}

func (c *OVClient) CreateEnclosureGroup(eGroup EnclosureGroup) error {
	log.Infof("Initializing creation of enclosure group for %s.", eGroup.Name)
	var (
		uri = "/rest/enclosure-groups"
		t   *Task
	)

	// refresh login
	c.RefreshLogin()
	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewProfileTask(c)
	t.ResetTask()
	data, err := c.RestAPICall(rest.POST, uri, eGroup)
	if err != nil {
		log.Errorf("Error submitting new enclosure group request: %s", err)
		return err
	}

	log.Debugf("Response New EnclosureGroup %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	return nil
}

// IsActive provides a single function for determining if a host is active
// based on both the url and if the host is stopped.
func isActive(h *host.Host) (bool, error) {
	currentState, err := h.Driver.GetState()

	if err != nil {
		log.Errorf("error getting state for host %s: %s", h.Name, err)
		return false, err
	}

	url, err := h.GetURL()

	if err != nil {
		if err == drivers.ErrHostIsNotRunning {
			url = ""
		} else {
			log.Errorf("error getting URL for host %s: %s", h.Name, err)
			return false, err
		}
	}

	dockerHost := os.Getenv("DOCKER_HOST")

	notStopped := currentState != state.Stopped
	correctURL := url == dockerHost

	isActive := notStopped && correctURL

	return isActive, nil
}

func (c *OVClient) CreateFCNetwork(fcNet FCNetwork) error {
	log.Infof("Initializing creation of fc network for %s.", fcNet.Name)
	var (
		uri = "/rest/fc-networks"
		t   *Task
	)
	// refresh login
	c.RefreshLogin()
	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewProfileTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, fcNet)
	log.Debugf("task -> %+v", t)
	data, err := c.RestAPICall(rest.POST, uri, fcNet)
	if err != nil {
		t.TaskIsDone = true
		log.Errorf("Error submitting new fc network request: %s", err)
		return err
	}

	log.Debugf("Response New fcNetwork %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	err = t.Wait()
	if err != nil {
		return err
	}

	return nil
}

func attemptGetHostState(h *host.Host, stateQueryChan chan<- HostListItem) {
	currentState, err := h.Driver.GetState()
	if err != nil {
		log.Errorf("error getting state for host %s: %s", h.Name, err)
	}

	url, err := h.GetURL()
	if err != nil {
		if err == drivers.ErrHostIsNotRunning {
			url = ""
		} else {
			log.Errorf("error getting URL for host %s: %s", h.Name, err)
		}
	}

	active, err := isActive(h)
	if err != nil {
		log.Errorf("error determining if host is active for host %s: %s",
			h.Name, err)
	}

	stateQueryChan <- HostListItem{
		Name:         h.Name,
		Active:       active,
		DriverName:   h.Driver.DriverName(),
		State:        currentState,
		URL:          url,
		SwarmOptions: h.HostOptions.SwarmOptions,
	}
}

func (c *I3SClient) CreateArtifactsBundle(artifactsBundle InputArtifactsBundle) error {
	log.Infof("Initializing creation of artifactsBundle for %s.", artifactsBundle.Name)
	var (
		uri = "/rest/artifact-bundles"
		t   *Task
	)

	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, artifactsBundle)
	log.Debugf("task -> %+v", t)
	data, err := c.RestAPICall(rest.POST, uri, artifactsBundle)
	if err != nil {
		t.TaskIsDone = true
		log.Errorf("Error submitting new artifacts bundle request: %s", err)
		return err
	}

	log.Debugf("Response New ArtifactsBundle %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	err = t.Wait()
	if err != nil {
		return err
	}

	return nil
}

func cmdRm(c CommandLine) error {
	if len(c.Args()) == 0 {
		c.ShowHelp()
		return errors.New("You must specify a machine name")
	}

	force := c.Bool("force")
	store := getStore(c)

	for _, hostName := range c.Args() {
		h, err := loadHost(store, hostName)
		if err != nil {
			return fmt.Errorf("Error removing host %q: %s", hostName, err)
		}

		if err := h.Driver.Remove(); err != nil {
			if !force {
				log.Errorf("Provider error removing machine %q: %s", hostName, err)
				continue
			}
		}

		if err := store.Remove(hostName); err != nil {
			log.Errorf("Error removing machine %q from store: %s", hostName, err)
		} else {
			log.Infof("Successfully removed %s", hostName)
		}
	}

	return nil
}

func (c *I3SClient) CreateDeploymentPlan(deploymentPlan DeploymentPlan) error {
	log.Infof("Initializing creation of deploymentPlan for %s.", deploymentPlan.Name)
	var (
		uri = "/rest/deployment-plans"
		t   *Task
	)

	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())

	t = t.NewTask(c)
	t.ResetTask()
	log.Debugf("REST : %s \n %+v\n", uri, deploymentPlan)
	log.Debugf("task -> %+v", t)
	data, err := c.RestAPICall(rest.POST, uri, deploymentPlan)
	if err != nil {
		t.TaskIsDone = true
		log.Errorf("Error submitting new deployment plan request: %s", err)
		return err
	}

	log.Debugf("Response New DeploymentPlan %s", data)
	if err := json.Unmarshal([]byte(data), &t); err != nil {
		t.TaskIsDone = true
		log.Errorf("Error with task un-marshal: %s", err)
		return err
	}

	err = t.Wait()
	if err != nil {
		return err
	}

	return nil
}

// SubmitNewServer submit new profile template
func (c *ICSPClient) SubmitNewServer(sc ServerCreate) (jt *JobTask, err error) {
	log.Infof("Initializing creation of server for ICSP, %s.", sc.IPAddress)
	var (
		uri = "/rest/os-deployment-servers"
		// uri  = "/rest/os-deployment-ilos" //TODO: implement hidden api for server deploy that works in Houston
		juri ODSUri
	)
	// refresh login
	c.RefreshLogin()
	c.SetAuthHeaderOptions(c.GetAuthHeaderMap())
	// c.SetAuthHeaderOptions(c.GetAuthHeaderMapNoVer()) //TODO: only needed when using os-deployment-ilos

	jt = jt.NewJobTask(c)
	jt.Reset()
	data, err := c.RestAPICall(rest.POST, uri, sc)
	if err != nil {
		jt.IsDone = true
		log.Errorf("Error submitting new server request: %s", err)
		return jt, err
	}

	log.Debugf("Response submit new server %s", data)
	if err := json.Unmarshal([]byte(data), &juri); err != nil {
		jt.IsDone = true
		jt.JobURI = juri
		log.Errorf("Error with task un-marshal: %s", err)
		return jt, err
	}
	jt.JobURI = juri

	return jt, err
}