Golang Request.MapTo方法代码示例

// handleErrorMsg send the error message of an app if present.
func handleErrorMsg(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestErrorMsg
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to get error message: %v", err)
	}

	// Create the response value.
	res := api.ResponseErrorMsg{
		Name: data.Name,
	}

	// Get the app error if present.
	appErr := a.Error()
	if appErr != nil {
		res.ErrorMessage = strings.TrimSpace(appErr.Error())
	}

	return res, nil
}

// handleRestoreBackup handles the restore backup request.
func handleRestoreBackup(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestRestoreBackup
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 || len(data.Unix) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to restore backup: %v", err)
	}

	// Restore the backup.
	err = a.RestoreBackup(data.Unix)
	if err != nil {
		return nil, fmt.Errorf("failed to restore backup: %v", err)
	}

	return nil, nil
}

// handleSetupSet obtains the setup values and configures the app.
func handleSetupSet(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestSetupSet
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to setup app: %v", err)
	}

	// Get the response setup data from the app.
	err = a.Setup(&data.Setup)
	if err != nil {
		return nil, fmt.Errorf("failed to setup app: %v", err)
	}

	return nil, nil
}

// handleLogs send the log message of an app.
func handleLogs(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestLogs
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to get log message: %v", err)
	}

	// Create the response value.
	res := api.ResponseLogs{}

	// If no specific container is passed,
	// then send a list of all available containers.
	if len(data.Container) == 0 {
		res.Containers, err = a.Containers()
		if err != nil {
			return nil, fmt.Errorf("failed to get app containers: %v", err)
		}
	} else {
		var streamType docker.StdStream = docker.StdStreamCombined

		// Get the stream option.
		if len(data.Stream) > 0 {
			if data.Stream == "stderr" {
				streamType = docker.StdStreamError
			} else if data.Stream == "stdout" {
				streamType = docker.StdStreamOutput
			} else {
				return nil, fmt.Errorf("failed to get log messages: invalid stream option.")
			}
		}

		// Get the log messages.
		logs, err := docker.Logs(a.ContainerNamePrefix()+data.Container, streamType)
		if err != nil {
			return nil, fmt.Errorf("failed to get log messages: %v", err)
		}

		// Set the response log messages.
		res.LogMessages = logs
	}

	return res, nil
}

// handleHostFingerprintInfo obtains the host fingerprint and some information about it.
func handleHostFingerprintInfo(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestHostFingerprintInfo
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Be sure it is a valid stripped host.
	data.Host = utils.GetHostFromUrl(data.Host)

	// Validate.
	if len(data.Host) == 0 {
		return nil, fmt.Errorf("invalid host: '%s'", data.Host)
	}

	// Skip host fingerprint checking if this is a local repository.
	if strings.HasPrefix(data.Host, "file://") {
		// Create the response value.
		response := &api.ResponseHostFingerprintInfo{
			Host:        data.Host,
			Trusted:     true,
			Fingerprint: "",
		}

		return response, nil
	}

	// Check if the fingerprint exists for the host.
	exists, err := hostFingerprintExists(data.Host)
	if err != nil {
		return nil, fmt.Errorf("failed to get information about host fingerprint: %v", err)
	}

	// Obtain the fingerprint of the host.
	fingerprint, err := getSshHostFingerprint(data.Host)
	if err != nil {
		return nil, fmt.Errorf("failed to obtain host fingerprint: %v", err)
	}

	// Create the response value.
	response := &api.ResponseHostFingerprintInfo{
		Host:        data.Host,
		Trusted:     exists,
		Fingerprint: fingerprint,
	}

	return response, nil
}

// handleInfo returns information about an app.
func handleInfo(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestInfo
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to get information of app: %v", err)
	}

	// Get the setup data from the app.
	setup, err := a.GetSetup()
	if err != nil {
		return nil, fmt.Errorf("failed to get information of app: %v", err)
	}

	// Get the turtlefile.
	// Continue also on error.
	t, err := a.Turtlefile()
	if err != nil {
		return nil, err
	}

	// Create the response value.
	res := api.ResponseInfo{
		Name:       a.Name(),
		Maintainer: t.Maintainer,
		Turtlefile: t.Name,
		State:      a.State(),
		SourceURL:  a.SourceURL(),
		Branch:     a.Branch(),

		Setup: setup,
	}

	return res, nil
}

// handleListBackups returns a list of all app backups.
func handleListBackups(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestListBackups
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Obtain the app with the given name.
	a, err := apps.Get(data.Name)
	if err != nil {
		return nil, fmt.Errorf("failed to list backups: %v", err)
	}

	// Get all backup timestamps of the app.
	list, err := a.Backups()
	if err != nil {
		return nil, fmt.Errorf("failed to list backups: %v", err)
	}

	// Create the response value.
	res := api.ResponseListBackups{
		Backups: make([]api.ResponseListBackup, len(list)),
	}

	// Add all the backup timestamps to the response value.
	for i, u := range list {
		unix, err := strconv.ParseInt(u, 10, 64)
		if err != nil {
			return nil, fmt.Errorf("failed to list backups: failed to parse unix timestamp: %v", err)
		}

		res.Backups[i] = api.ResponseListBackup{
			Unix: u,
			Date: time.Unix(unix, 0).String(),
		}
	}

	return res, nil
}

// handleAddHostFingerprint adds a new host fingerprint.
func handleAddHostFingerprint(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestAddHostFingerprint
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Fingerprint) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Add the fingerprint.
	err = addHostFingerprint(data.Fingerprint)
	if err != nil {
		return nil, fmt.Errorf("failed to add host fingerprint: %v", err)
	}

	return nil, nil
}

// handleAdd handles the add App request.
func handleAdd(request *api.Request) (interface{}, error) {
	// Map the data to the custom type.
	var data api.RequestAdd
	err := request.MapTo(&data)
	if err != nil {
		return nil, err
	}

	// Validate.
	if len(data.Name) == 0 || len(data.SourceURL) == 0 || len(data.Branch) == 0 {
		return nil, fmt.Errorf("missing or invalid data: %+v", data)
	}

	// Add a new app.
	err = apps.Add(data.Name, data.SourceURL, data.Branch)
	if err != nil {
		return nil, fmt.Errorf("failed to add app: %v", err)
	}

	return nil, nil
}