func (client Client) ListBuckets(options ...Option) (ListBucketsResult, error) {
	var out ListBucketsResult
	params, err := getRawParams(options)
	if err != nil {
		return out, err
	}
	resp, err := client.do("GET", "", params, nil, nil, options...)
	if err != nil {
		return out, err
	}
	defer resp.Body.Close()
	err = xmlUnmarshal(resp.Body, &out)
	return out, err
}
ListBuckets lists buckets of the current account under the given endpoint, with optional filters.

options    specifies the filters such as Prefix, Marker and MaxKeys. Prefix is the bucket name's prefix filter.
And marker makes sure the returned buckets' name are greater than it in lexicographic order.
Maxkeys limits the max keys to return, and by default it's 100 and up to 1000.
For the common usage scenario, please check out list_bucket.go in the sample.
ListBucketsResponse    the response object if error is nil.

error    it's nil if no error, otherwise it's an error object.
package oss
import (
	"bytes"
	"encoding/xml"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"strings"
	"time"
)
type (
	Client struct {
		Config     *Config       
		Conn       *Conn         
		HTTPClient *http.Client  
	}
	ClientOption func(*Client)
)
func New(endpoint, accessKeyID, accessKeySecret string, options ...ClientOption) (*Client, error) {
	config := getDefaultOssConfig()
	config.Endpoint = endpoint
	config.AccessKeyID = accessKeyID
	config.AccessKeySecret = accessKeySecret
	url := &urlMaker{}
	err := url.Init(config.Endpoint, config.IsCname, config.IsUseProxy)
	if err != nil {
		return nil, err
	}
	conn := &Conn{config: config, url: url}
	client := &Client{
		Config: config,
		Conn:   conn,
	}
	for _, option := range options {
		option(client)
	}
	err = conn.init(config, url, client.HTTPClient)
	return client, err
}
func (client Client) Bucket(bucketName string) (*Bucket, error) {
	err := CheckBucketName(bucketName)
	if err != nil {
		return nil, err
	}
	return &Bucket{
		client,
		bucketName,
	}, nil
}
func (client Client) CreateBucket(bucketName string, options ...Option) error {
	headers := make(map[string]string)
	handleOptions(headers, options)
	buffer := new(bytes.Buffer)
	var cbConfig createBucketConfiguration
	cbConfig.StorageClass = StorageStandard
	isStorageSet, valStroage, _ := isOptionSet(options, storageClass)
	isRedundancySet, valRedundancy, _ := isOptionSet(options, redundancyType)
	if isStorageSet {
		cbConfig.StorageClass = valStroage.(StorageClassType)
	}
	if isRedundancySet {
		cbConfig.DataRedundancyType = valRedundancy.(DataRedundancyType)
	}
	bs, err := xml.Marshal(cbConfig)
	if err != nil {
		return err
	}
	buffer.Write(bs)
	contentType := http.DetectContentType(buffer.Bytes())
	headers[HTTPHeaderContentType] = contentType
	params := map[string]interface{}{}
	resp, err := client.do("PUT", bucketName, params, headers, buffer, options...)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
}