http provider and http request data source

builtin/providers/http/data_source.go

@@ -0,0 +1,104 @@
+package http
+
+import (
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "regexp"
+ "time"
+
+ "github.com/hashicorp/terraform/helper/schema"
+)
+
+func dataSource() *schema.Resource {
+ return &schema.Resource{
+ Read: dataSourceRead,
+
+ Schema: map[string]*schema.Schema{
+ "url": &schema.Schema{
+ Type: schema.TypeString,
+ Required: true,
+ Elem: &schema.Schema{
+ Type: schema.TypeString,
+ },
+ },
+
+ "request_headers": &schema.Schema{
+ Type: schema.TypeMap,
+ Optional: true,
+ Elem: &schema.Schema{
+ Type: schema.TypeString,
+ },
+ },
+
+ "body": &schema.Schema{
+ Type: schema.TypeString,
+ Computed: true,
+ Elem: &schema.Schema{
+ Type: schema.TypeString,
+ },
+ },
+ },
+ }
+}
+
+func dataSourceRead(d *schema.ResourceData, meta interface{}) error {
+
+ url := d.Get("url").(string)
+ headers := d.Get("request_headers").(map[string]interface{})
+
+ client := &http.Client{}
+
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return fmt.Errorf("Error creating request: %s", err)
+ }
+
+ for name, value := range headers {
+ req.Header.Set(name, value.(string))
+ }
+
+ resp, err := client.Do(req)
+ if err != nil {
+ return fmt.Errorf("Error during making a request: %s", url)
+ }
+
+ defer resp.Body.Close()
+
+ if resp.StatusCode != 200 {
+ return fmt.Errorf("HTTP request error. Response code: %d", resp.StatusCode)
+ }
+
+ contentType := resp.Header.Get("Content-Type")
+ if contentType == "" || isContentTypeAllowed(contentType) == false {
+ return fmt.Errorf("Content-Type is not a text type. Got: %s", contentType)
+ }
+
+ bytes, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return fmt.Errorf("Error while reading response body. %s", err)
+ }
+
+ d.Set("body", string(bytes))
+ d.SetId(time.Now().UTC().String())
+
+ return nil
+}
+
+// This is to prevent potential issues w/ binary files
+// and generally unprintable characters
+// See https://github.com/hashicorp/terraform/pull/3858#issuecomment-156856738
+func isContentTypeAllowed(contentType string) bool {
+ allowedContentTypes := []*regexp.Regexp{
+ regexp.MustCompile("^text/.+"),
+ regexp.MustCompile("^application/json$"),
+ }
+
+ for _, r := range allowedContentTypes {
+ if r.MatchString(contentType) {
+ return true
+ }
+ }
+
+ return false
+}

builtin/providers/http/data_source_test.go

@@ -0,0 +1,166 @@
+package http
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "regexp"
+ "testing"
+
+ "github.com/hashicorp/terraform/helper/resource"
+ "github.com/hashicorp/terraform/terraform"
+)
+
+type TestHttpMock struct {
+ server *httptest.Server
+}
+
+const testDataSourceConfig_basic = `
+data "http" "http_test" {
+ url = "%s/meta_%d.txt"
+}
+
+output "body" {
+ value = "${data.http.http_test.body}"
+}
+`
+
+func TestDataSource_http200(t *testing.T) {
+ testHttpMock := setUpMockHttpServer()
+
+ defer testHttpMock.server.Close()
+
+ resource.UnitTest(t, resource.TestCase{
+ Providers: testProviders,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: fmt.Sprintf(testDataSourceConfig_basic, testHttpMock.server.URL, 200),
+ Check: func(s *terraform.State) error {
+ _, ok := s.RootModule().Resources["data.http.http_test"]
+ if !ok {
+ return fmt.Errorf("missing data resource")
+ }
+
+ outputs := s.RootModule().Outputs
+
+ if outputs["body"].Value != "1.0.0" {
+ return fmt.Errorf(
+ `'body' output is %s; want '1.0.0'`,
+ outputs["body"].Value,
+ )
+ }
+
+ return nil
+ },
+ },
+ },
+ })
+}
+
+func TestDataSource_http404(t *testing.T) {
+ testHttpMock := setUpMockHttpServer()
+
+ defer testHttpMock.server.Close()
+
+ resource.UnitTest(t, resource.TestCase{
+ Providers: testProviders,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: fmt.Sprintf(testDataSourceConfig_basic, testHttpMock.server.URL, 404),
+ ExpectError: regexp.MustCompile("HTTP request error. Response code: 404"),
+ },
+ },
+ })
+}
+
+const testDataSourceConfig_withHeaders = `
+data "http" "http_test" {
+ url = "%s/restricted/meta_%d.txt"
+
+ request_headers = {
+ "Authorization" = "Zm9vOmJhcg=="
+ }
+}
+
+output "body" {
+ value = "${data.http.http_test.body}"
+}
+`
+
+func TestDataSource_withHeaders200(t *testing.T) {
+ testHttpMock := setUpMockHttpServer()
+
+ defer testHttpMock.server.Close()
+
+ resource.UnitTest(t, resource.TestCase{
+ Providers: testProviders,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: fmt.Sprintf(testDataSourceConfig_withHeaders, testHttpMock.server.URL, 200),
+ Check: func(s *terraform.State) error {
+ _, ok := s.RootModule().Resources["data.http.http_test"]
+ if !ok {
+ return fmt.Errorf("missing data resource")
+ }
+
+ outputs := s.RootModule().Outputs
+
+ if outputs["body"].Value != "1.0.0" {
+ return fmt.Errorf(
+ `'body' output is %s; want '1.0.0'`,
+ outputs["body"].Value,
+ )
+ }
+
+ return nil
+ },
+ },
+ },
+ })
+}
+
+const testDataSourceConfig_error = `
+data "http" "http_test" {
+
+}
+`
+
+func TestDataSource_compileError(t *testing.T) {
+ resource.UnitTest(t, resource.TestCase{
+ Providers: testProviders,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: testDataSourceConfig_error,
+ ExpectError: regexp.MustCompile("required field is not set"),
+ },
+ },
+ })
+}
+
+func setUpMockHttpServer() *TestHttpMock {
+ Server := httptest.NewServer(
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path == "/meta_200.txt" {
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte("1.0.0"))
+ } else if r.URL.Path == "/restricted/meta_200.txt" {
+ if r.Header.Get("Authorization") == "Zm9vOmJhcg==" {
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte("1.0.0"))
+ } else {
+ w.WriteHeader(http.StatusForbidden)
+ }
+ } else if r.URL.Path == "/meta_404.txt" {
+ w.WriteHeader(http.StatusNotFound)
+ } else {
+ w.WriteHeader(http.StatusNotFound)
+ }
+
+ w.Header().Add("Content-Type", "text/plain")
+ }),
+ )
+
+ return &TestHttpMock{
+ server: Server,
+ }
+}

builtin/providers/http/provider.go

@@ -0,0 +1,18 @@
+package http
+
+import (
+ "github.com/hashicorp/terraform/helper/schema"
+ "github.com/hashicorp/terraform/terraform"
+)
+
+func Provider() terraform.ResourceProvider {
+ return &schema.Provider{
+ Schema: map[string]*schema.Schema{},
+
+ DataSourcesMap: map[string]*schema.Resource{
+ "http": dataSource(),
+ },
+
+ ResourcesMap: map[string]*schema.Resource{},
+ }
+}

builtin/providers/http/provider_test.go

@@ -0,0 +1,18 @@
+package http
+
+import (
+ "testing"
+
+ "github.com/hashicorp/terraform/helper/schema"
+ "github.com/hashicorp/terraform/terraform"
+)
+
+var testProviders = map[string]terraform.ResourceProvider{
+ "http": Provider(),
+}
+
+func TestProvider(t *testing.T) {
+ if err := Provider().(*schema.Provider).InternalValidate(); err != nil {
+ t.Fatalf("err: %s", err)
+ }
+}

command/internal_plugin_list.go

@@ -35,6 +35,7 @@ import (
  googleprovider "github.com/hashicorp/terraform/builtin/providers/google"
  grafanaprovider "github.com/hashicorp/terraform/builtin/providers/grafana"
  herokuprovider "github.com/hashicorp/terraform/builtin/providers/heroku"
+ httpprovider "github.com/hashicorp/terraform/builtin/providers/http"
  icinga2provider "github.com/hashicorp/terraform/builtin/providers/icinga2"
  ignitionprovider "github.com/hashicorp/terraform/builtin/providers/ignition"
  influxdbprovider "github.com/hashicorp/terraform/builtin/providers/influxdb"
@@ -115,6 +116,7 @@ var InternalProviders = map[string]plugin.ProviderFunc{
  "google": googleprovider.Provider,
  "grafana": grafanaprovider.Provider,
  "heroku": herokuprovider.Provider,
+ "http": httpprovider.Provider,
  "icinga2": icinga2provider.Provider,
  "ignition": ignitionprovider.Provider,
  "influxdb": influxdbprovider.Provider,

website/source/docs/providers/http/data_source.html.md

@@ -0,0 +1,51 @@
+---
+layout: "http"
+page_title: "HTTP Data Source"
+sidebar_current: "docs-http-data-source"
+description: |-
+ Retrieves the content at an HTTP or HTTPS URL.
+---
+
+# `http` Data Source
+
+The `http` data source makes an HTTP GET request to the given URL and exports
+information about the response.
+
+The given URL may be either an `http` or `https` URL. At present this resource
+can only retrieve data from URLs that respond with `text/*` or
+`application/json` content types, and expects the result to be UTF-8 encoded
+regardless of the returned content type header.
+
+~> **Important** Although `https` URLs can be used, there is currently no
+mechanism to authenticate the remote server except for general verification of
+the server certificate's chain of trust. Data retrieved from servers not under
+your control should be treated as untrustworthy.
+
+## Example Usage
+
+```hcl
+data "http" "example" {
+ url = "https://checkpoint-api.hashicorp.com/v1/check/terraform"
+
+ # Optional request headers
+ request_headers {
+ "Accept" = "application/json"
+ }
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `url` - (Required) The URL to request data from. This URL must respond with
+ a `200 OK` response and a `text/*` or `application/json` Content-Type.
+
+* `request_headers` - (Optional) A map of strings representing additional HTTP
+ headers to include in the request.
+
+## Attributes Reference
+
+The following attributes are exported:
+
+* `body` - The raw body of the HTTP response.

website/source/docs/providers/http/index.html.markdown

@@ -0,0 +1,15 @@
+---
+layout: "http"
+page_title: "Provider: HTTP"
+sidebar_current: "docs-http-index"
+description: |-
+ The HTTP provider interacts with HTTP servers.
+---
+
+# HTTP Provider
+
+The HTTP provider is a utility provider for interacting with generic HTTP
+servers as part of a Terraform configuration.
+
+This provider requires no configuration. For information on the resources
+it provides, see the navigation bar.