tableserviceclient.go

package storage

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
)

const (
	headerAccept          = "Accept"
	headerEtag            = "Etag"
	headerPrefer          = "Prefer"
	headerXmsContinuation = "x-ms-Continuation-NextTableName"
)

// TableServiceClient contains operations for Microsoft Azure Table Storage
// Service.
type TableServiceClient struct {
	client Client
	auth   authentication
}

// TableOptions includes options for some table operations
type TableOptions struct {
	RequestID string
}

func (options *TableOptions) addToHeaders(h map[string]string) map[string]string {
	if options != nil {
		h = addToHeaders(h, "x-ms-client-request-id", options.RequestID)
	}
	return h
}

// QueryNextLink includes information for getting the next page of
// results in query operations
type QueryNextLink struct {
	NextLink *string
	ml       MetadataLevel
}

// GetServiceProperties gets the properties of your storage account's table service.
// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-table-service-properties
func (t *TableServiceClient) GetServiceProperties() (*ServiceProperties, error) {
	return t.client.getServiceProperties(tableServiceName, t.auth)
}

// SetServiceProperties sets the properties of your storage account's table service.
// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-table-service-properties
func (t *TableServiceClient) SetServiceProperties(props ServiceProperties) error {
	return t.client.setServiceProperties(props, tableServiceName, t.auth)
}

// GetTableReference returns a Table object for the specified table name.
func (t *TableServiceClient) GetTableReference(name string) *Table {
	return &Table{
		tsc:  t,
		Name: name,
	}
}

// QueryTablesOptions includes options for some table operations
type QueryTablesOptions struct {
	Top       uint
	Filter    string
	RequestID string
}

func (options *QueryTablesOptions) getParameters() (url.Values, map[string]string) {
	query := url.Values{}
	headers := map[string]string{}
	if options != nil {
		if options.Top > 0 {
			query.Add(OdataTop, strconv.FormatUint(uint64(options.Top), 10))
		}
		if options.Filter != "" {
			query.Add(OdataFilter, options.Filter)
		}
		headers = addToHeaders(headers, "x-ms-client-request-id", options.RequestID)
	}
	return query, headers
}

// QueryTables returns the tables in the storage account.
// You can use query options defined by the OData Protocol specification.
//
// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/query-tables
func (t *TableServiceClient) QueryTables(ml MetadataLevel, options *QueryTablesOptions) (*TableQueryResult, error) {
	query, headers := options.getParameters()
	uri := t.client.getEndpoint(tableServiceName, tablesURIPath, query)
	return t.queryTables(uri, headers, ml)
}

// NextResults returns the next page of results
// from a QueryTables or a NextResults operation.
//
// See https://docs.microsoft.com/rest/api/storageservices/fileservices/query-tables
// See https://docs.microsoft.com/rest/api/storageservices/fileservices/query-timeout-and-pagination
func (tqr *TableQueryResult) NextResults(options *TableOptions) (*TableQueryResult, error) {
	if tqr == nil {
		return nil, errNilPreviousResult
	}
	if tqr.NextLink == nil {
		return nil, errNilNextLink
	}
	headers := options.addToHeaders(map[string]string{})

	return tqr.tsc.queryTables(*tqr.NextLink, headers, tqr.ml)
}

// TableQueryResult contains the response from
// QueryTables and QueryTablesNextResults functions.
type TableQueryResult struct {
	OdataMetadata string  `json:"odata.metadata"`
	Tables        []Table `json:"value"`
	QueryNextLink
	tsc *TableServiceClient
}

func (t *TableServiceClient) queryTables(uri string, headers map[string]string, ml MetadataLevel) (*TableQueryResult, error) {
	if ml == EmptyPayload {
		return nil, errEmptyPayload
	}
	headers = mergeHeaders(headers, t.client.getStandardHeaders())
	headers[headerAccept] = string(ml)

	resp, err := t.client.exec(http.MethodGet, uri, headers, nil, t.auth)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
		return nil, err
	}

	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	var out TableQueryResult
	err = json.Unmarshal(respBody, &out)
	if err != nil {
		return nil, err
	}

	for i := range out.Tables {
		out.Tables[i].tsc = t
	}
	out.tsc = t

	nextLink := resp.Header.Get(http.CanonicalHeaderKey(headerXmsContinuation))
	if nextLink == "" {
		out.NextLink = nil
	} else {
		originalURI, err := url.Parse(uri)
		if err != nil {
			return nil, err
		}
		v := originalURI.Query()
		v.Set(nextTableQueryParameter, nextLink)
		newURI := t.client.getEndpoint(tableServiceName, tablesURIPath, v)
		out.NextLink = &newURI
		out.ml = ml
	}

	return &out, nil
}

func addBodyRelatedHeaders(h map[string]string, length int) map[string]string {
	h[headerContentType] = "application/json"
	h[headerContentLength] = fmt.Sprintf("%v", length)
	h[headerAcceptCharset] = "UTF-8"
	return h
}

func addReturnContentHeaders(h map[string]string, ml MetadataLevel) map[string]string {
	if ml != EmptyPayload {
		h[headerPrefer] = "return-content"
		h[headerAccept] = string(ml)
	} else {
		h[headerPrefer] = "return-no-content"
		// From API version 2015-12-11 onwards, Accept header is required
		h[headerAccept] = string(NoMetadata)
	}
	return h
}