func (client *RiakExplorerClient) Commit(node string) (CommitReply, error) {
	var m CommitReply
	commandURI := fmt.Sprintf("control/nodes/%s/commit", node)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
Commit instructs node to commit its current planned cluster changes
package riak_explorer
import (
	json "encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"strings"
)
type RiakExplorerClient struct {
	Host string
}
func NewRiakExplorerClient(host string) *RiakExplorerClient {
	c := &RiakExplorerClient{
		Host: host,
	}
	return c
}
type Links struct {
	Self    string `json:"self"`
	Related string `json:"related"`
}
func (client *RiakExplorerClient) GetAAEStatusJSON(node string) (string, error) {
	commandURI := fmt.Sprintf("control/nodes/%s/aae-status", node)
	body, err := client.doGet(commandURI)
	return string(body), err
}
func (client *RiakExplorerClient) GetStatusJSON(node string) (string, error) {
	commandURI := fmt.Sprintf("control/nodes/%s/status", node)
	body, err := client.doGet(commandURI)
	return string(body), err
}
func (client *RiakExplorerClient) GetRingreadyJSON(node string) (string, error) {
	commandURI := fmt.Sprintf("control/nodes/%s/ringready", node)
	body, err := client.doGet(commandURI)
	return string(body), err
}
func (client *RiakExplorerClient) GetTransfersJSON(node string) (string, error) {
	commandURI := fmt.Sprintf("control/nodes/%s/transfers", node)
	body, err := client.doGet(commandURI)
	return string(body), err
}
func (client *RiakExplorerClient) GetBucketTypesJSON(node string) (string, error) {
	commandURI := fmt.Sprintf("explore/nodes/%s/bucket_types", node)
	body, err := client.doGet(commandURI)
	return string(body), err
}
func (client *RiakExplorerClient) CreateBucketTypeJSON(node string, bucketType string, props string) (string, error) {
	commandURI := fmt.Sprintf("explore/nodes/%s/bucket_types/%s", node, bucketType)
	body, err := client.doPutWithData(commandURI, strings.NewReader(props))
	if err != nil {
		return body, err
	}
	return body, err
}
type PingReply struct {
	Ping struct {
		ID      string `json:"id"`
		Message string `json:"message"`
	} `json:"ping"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Ping() (PingReply, error) {
	var m PingReply
	v, err := client.doGet("explore/ping")
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type JoinReply struct {
	Join struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"join"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Join(fromNode string, toNode string) (JoinReply, error) {
	var m JoinReply
	commandURI := fmt.Sprintf("control/nodes/%s/join/%s", fromNode, toNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type StagedJoinReply struct {
	StagedJoin struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"staged-join"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) StagedJoin(fromNode string, toNode string) (StagedJoinReply, error) {
	var m StagedJoinReply
	commandURI := fmt.Sprintf("control/nodes/%s/staged-join/%s", fromNode, toNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type LeaveReply struct {
	Leave struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"leave"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Leave(stayingNode string, leavingNode string) (LeaveReply, error) {
	var m LeaveReply
	commandURI := fmt.Sprintf("control/nodes/%s/leave/%s", stayingNode, leavingNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type StagedLeaveReply struct {
	StagedLeave struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"staged-leave"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) StagedLeave(node string) (StagedLeaveReply, error) {
	var m StagedLeaveReply
	commandURI := fmt.Sprintf("control/nodes/%s/staged-leave", node)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
func (client *RiakExplorerClient) StagedLeaveTarget(stayingNode string, leavingNode string) (StagedLeaveReply, error) {
	var m StagedLeaveReply
	commandURI := fmt.Sprintf("control/nodes/%s/staged-leave/%s", stayingNode, leavingNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type ForceRemoveReply struct {
	ForceRemove struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"force-remove"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) ForceRemove(stayingNode string, leavingNode string) (ForceRemoveReply, error) {
	var m ForceRemoveReply
	commandURI := fmt.Sprintf("control/nodes/%s/force-remove/%s", stayingNode, leavingNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type ReplaceReply struct {
	Replace struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"replace"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Replace(fromNode string, oldNode string, newNode string) (ReplaceReply, error) {
	var m ReplaceReply
	commandURI := fmt.Sprintf("control/nodes/%s/replace/%s/%s", fromNode, oldNode, newNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type StagedReplaceReply struct {
	StagedReplace struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"staged-replace"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) StagedReplace(fromNode string, oldNode string, newNode string) (StagedReplaceReply, error) {
	var m StagedReplaceReply
	commandURI := fmt.Sprintf("control/nodes/%s/staged-replace/%s/%s", fromNode, oldNode, newNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type ForceReplaceReply struct {
	ForceReplace struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"force-replace"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) ForceReplace(fromNode string, oldNode string, newNode string) (ForceReplaceReply, error) {
	var m ForceReplaceReply
	commandURI := fmt.Sprintf("control/nodes/%s/force-replace/%s/%s", fromNode, oldNode, newNode)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type NodeChangeReply struct {
	Node   string `json:"node"`
	Action string `json:"action"`
	Target string `json:"target"`
}
type PlanReply struct {
	Plan struct {
		Changes []NodeChangeReply `json:"changes"`
		Error   string            `json:"error"`
	} `json:"plan"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Plan(node string) (PlanReply, error) {
	var m PlanReply
	commandURI := fmt.Sprintf("control/nodes/%s/plan", node)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type RepairReply struct {
	Repair struct {
		Success int `json:"success"`
		Error   int `json:"failure"`
	} `json:"repair"`
	Links Links `json:"links"`
}
func (client *RiakExplorerClient) Repair(node string) (RepairReply, error) {
	var m RepairReply
	commandURI := fmt.Sprintf("control/nodes/%s/repair", node)
	v, err := client.doGet(commandURI)
	if err != nil {
		return m, err
	}
	json.Unmarshal(v, &m)
	return m, nil
}
type CommitReply struct {
	Commit struct {
		Success string `json:"success"`
		Error   string `json:"error"`
	} `json:"commit"`
	Links Links `json:"links"`
}