解决Go Tableau 数据提取刷新 API exe 中的索引超出范围错误

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《解决Go Tableau 数据提取刷新 API exe 中的索引超出范围错误》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

我一直在尝试将 go 作为速成课程来学习。我的任务是构建一个小程序，它接受令牌名称、秘密令牌、数据源名称和参数，以检查 tableau 数据提取刷新的当前状态。我陷入了一个看似简单的解析错误，但无法找到简单的错误。这是代码：

package main

import (
    "bytes"
    "encoding/json"
    "flag"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "strings"
    "time"
)

const url = "https://xxx.xxxx.com/api/3.11/"

func main() {

    // get the login details from command line args
    tokenname := flag.string("token", "", "personal access token name")
    tokensecret := flag.string("secret", "", "personal access token secret")
    datasourcename := flag.string("datasrc", "", "datasource name")
    refreshinterval := flag.int("refresh", 5, "refresh interval in minutes")
    flag.parse()

    // if login details are not provided, prompt for them
    if *tokenname == "" || *tokensecret == "" {
        fmt.println("usage:")
        fmt.println("  -token     : personal access token name")
        fmt.println("  -secret : personal access token secret")
        fmt.println("  -datasrc  : datasource name")
        fmt.println("  -refresh  : refresh interval in minutes (optional. default is 5)")
        fmt.println("\n  example:")
        fmt.println("  " + os.args[0] + " -token  -secret  -siteid ")
        return
    }

    // sign in
    internalsiteid, authtoken := signin(*tokenname, *tokensecret)
    fmt.printf("internalsiteid: %s, authtoken: %s\n", internalsiteid, authtoken)

    // get datasource details
    datasrcid := getdatasrcdetails(internalsiteid, *datasourcename, authtoken)
    fmt.printf("datasrcid: %s\n", datasrcid)

    // run refresh extract
    jobid := runrefreshextract(internalsiteid, authtoken, datasrcid)

    // schedule a refresh status every 5 minutes
    ticker := time.newticker(time.duration(*refreshinterval) * time.minute)
    for range ticker.c {
        refreshjobstatus(internalsiteid, authtoken, jobid)
    }
}

// signin returns the internal site id and auth token.
func signin(tokenname, tokensecret string) (internalsiteid string, authtoken string) {

    // sign in
    type (

        // response body
        user struct {
            id string `json:"id"`
        }

        site struct {
            id         string `json:"id"`
            contenturl string `json:"contenturl"`
        }

        credentials struct {
            site        site   `json:"site"`
            user        user   `json:"user"`
            namedtoken  string `json:"personalaccesstokenname"`
            secrettoken string `json:"personalaccesstokensecret"`
            token       string `json:"token"`
        }

        signin struct {
            credentials credentials `json:"credentials"`
        }

        // request body
        signinrequest struct {
            credentials credentials `json:"credentials"`
        }
    )

    // make sign in request
    signinrequest := signinrequest{
        credentials: credentials{
            namedtoken:  tokenname,
            secrettoken: tokensecret,
            site: site{
                contenturl: "", //trying to run without the site id
            },
        },
    }

    // generate request for sign-in as a json string
    signindata, err := json.marshal(signinrequest)
    if err != nil {
        fmt.printf("error marshalling sign in request: %s\n", err)
        return
    }

    // send request
    resp, err := http.post(url+"auth/signin",
        "application/json",
        bytes.newbuffer(signindata),
    )
    if err != nil {
        fmt.printf("error marshalling sign in request: %s\n", err)
        return
    }

    // read response
    defer resp.body.close()

    // parse response
    var signinresponse signin
    err = json.newdecoder(resp.body).decode(&signinresponse)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }

    // return internal site id and auth token
    internalsiteid = signinrequest.credentials.site.id
    authtoken = signinrequest.credentials.token
    return
}

// getdatasrcdetails returns the datasource details.
func getdatasrcdetails(internalsiteid, datasrcname, authtoken string) (datasourceid string) {

    type (
        pagination struct {
            pagenumber     string `json:"pagenumber"`
            pagesize       string `json:"pagesize"`
            totalavailable string `json:"totalavailable"`
        }
        project struct {
            id   string `json:"id"`
            name string `json:"name"`
        }
        owner struct {
            id string `json:"id"`
        }
        tags struct {
        }
        datasource struct {
            project         project   `json:"project"`
            owner           owner     `json:"owner"`
            tags            tags      `json:"tags"`
            contenturl      string    `json:"contenturl"`
            createdat       time.time `json:"createdat"`
            encryptextracts string    `json:"encryptextracts"`
            id              string    `json:"id"`
            iscertified     bool      `json:"iscertified"`
            name            string    `json:"name"`
            type            string    `json:"type"`
            updatedat       time.time `json:"updatedat"`
            webpageurl      string    `json:"webpageurl"`
        }

        datasources struct {
            datasource []datasource `json:"datasource"`
        }

        response struct {
            pagination  pagination  `json:"pagination"`
            datasources datasources `json:"datasources"`
        }
    )

    req, err := http.newrequest("get", url+"sites/"+internalsiteid+"/datasources?filter=name:eq:"+datasrcname, nil)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    req.header.set("x-tableau-auth", authtoken)
    req.header.set("accept", "application/json")

    resp, err := http.defaultclient.do(req)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    defer resp.body.close()

    // parse response
    var response response
    err = json.newdecoder(resp.body).decode(&response)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }

    // return datasource id
    datasourceid = response.datasources.datasource[0].id
    return
}

// runrefreshextract runs a refresh extract request.
func runrefreshextract(internalsiteid, authtoken, datasrcid string) (jobid string) {

    type (
        datasource struct {
            id   string `json:"id"`
            name string `json:"name"`
        }
        extractrefreshjob struct {
            notes      string     `json:"notes"`
            datasource datasource `json:"datasource"`
        }
        job struct {
            extractrefreshjob extractrefreshjob `json:"extractrefreshjob"`
            id                string            `json:"id"`
            mode              string            `json:"mode"`
            type              string            `json:"type"`
            progress          string            `json:"progress"`
            createdat         time.time         `json:"createdat"`
            startedat         time.time         `json:"startedat"`
            completedat       time.time         `json:"completedat"`
            finishcode        string            `json:"finishcode"`
        }
        response struct {
            job job `json:"job"`
        }
    )

    body := strings.newreader(``)
    req, err := http.newrequest("post", url+"sites/"+internalsiteid+"/datasources/"+datasrcid+"/refresh", body)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    req.header.set("x-tableau-auth", authtoken)
    req.header.set("accept", "application/json")
    req.header.set("content-type", "application/xml")

    resp, err := http.defaultclient.do(req)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    defer resp.body.close()

    // parse response
    var response response
    err = json.newdecoder(resp.body).decode(&response)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }

    // return job id
    jobid = response.job.id
    return
}

// refreshjobstatus checks the status of a refresh job.
func refreshjobstatus(internalsiteid, authtoken, jobid string) {

    req, err := http.newrequest("get", url+"sites/"+internalsiteid+"/jobs/"+jobid, nil)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    req.header.set("x-tableau-auth", authtoken)
    req.header.set("accept", "application/json")

    resp, err := http.defaultclient.do(req)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    defer resp.body.close()

    // print response body
    body, err := ioutil.readall(resp.body)
    if err != nil {
        fmt.printf("error parsing sign in response: %s\n", err)
        return
    }
    fmt.println("-- refresh job status: ", resp.status, string(body), "--")
}

我遇到的错误似乎很明显，但我发誓我的代码在登录响应中返回的内容方面遵循 api 规范：

C:\Users\xxx\OneDrive\Documents\apiRefresh>main3.2 -token xxxx -secret xxxxx -datasrc xxxxx
Error parsing sign in response: invalid character '<' looking for beginning of value
internalSiteID: , authToken:
panic: runtime error: index out of range [0] with length 0

goroutine 1 [running]:
main.getDatasrcDetails({0x0?, 0xc000006018?}, {0xc00000a140?, 0x22?}, {0x0, 0x0})
        C:/Users/xxxxx/OneDrive/Documents/apiRefresh/main3.2.go:202 +0x516
main.main()
        C:/Users/xxxxxxxx/OneDrive/Documents/apiRefresh/main3.2.go:43 +0x23a

谁能帮我找出哪里出了问题？

正确答案

简短回答

您正在尝试访问不存在的切片中的索引。

datasourceid = response.datasources.datasource[0].id

更长的答案

由于 signin 不成功，随后 http 请求不成功而导致错误。正如您在输出中看到的那样，signin 无法获取 authtoken。

error parsing sign in response: invalid character '<' looking for beginning of value
internalsiteid: , authtoken:

此时您的应用不应继续执行。我相信在 getdatasrcdetails 中请求数据源将返回非正常状态代码，很可能是 401 unauthorized。之后代码出现恐慌

datasourceid = response.datasources.datasource[0].id

因为 len(response.datasources.datasource) == 0

推荐

考虑使用正确的 error handling。

func main() {
    ...
    // Sign in
    internalSiteID, authToken, err := signIn(*tokenName, *tokenSecret)
    if err != nil {
       // handle error
       return
    }
    fmt.Printf("internalSiteID: %s, authToken: %s\n", internalSiteID, authToken)

    // Get datasource details
    datasrcID, err := getDatasrcDetails(internalSiteID, *datasourceName, authToken)
    if err != nil {
       // handle error
       return
    }
    fmt.Printf("datasrcID: %s\n", datasrcID)
    ....
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。