mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-07-01 07:42:40 +00:00
Update hashicorp/terraform to 0.12-alpha4. (#2744)
This commit is contained in:
Nathan McKinley
GitHub
parent
aaf55a5455
commit
b89618ccaa
7
go.mod
7
go.mod
|
|
@ -7,21 +7,17 @@ require (
|
|||
github.com/davecgh/go-spew v1.1.1
|
||||
github.com/dustinkirkland/golang-petname v0.0.0-20170921220637-d3c2ba80e75e // indirect
|
||||
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
|
||||
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c // indirect
|
||||
github.com/googleapis/gax-go v2.0.2+incompatible // indirect
|
||||
github.com/hashicorp/errwrap v1.0.0
|
||||
github.com/hashicorp/go-cleanhttp v0.5.0
|
||||
github.com/hashicorp/go-getter v0.0.0-20181213035916-be39683deade // indirect
|
||||
github.com/hashicorp/go-hclog v0.0.0-20181001195459-61d530d6c27f // indirect
|
||||
github.com/hashicorp/go-multierror v1.0.0
|
||||
github.com/hashicorp/go-plugin v0.0.0-20181212150838-f444068e8f5a // indirect
|
||||
github.com/hashicorp/go-uuid v1.0.0 // indirect
|
||||
github.com/hashicorp/go-version v1.0.0
|
||||
github.com/hashicorp/hcl v1.0.0 // indirect
|
||||
github.com/hashicorp/hcl2 v0.0.0-20181215005721-253da47fd604 // indirect
|
||||
github.com/hashicorp/hil v0.0.0-20170627220502-fa9f258a9250 // indirect
|
||||
github.com/hashicorp/logutils v1.0.0 // indirect
|
||||
github.com/hashicorp/terraform v0.11.9-0.20180926212128-35d82b055591
|
||||
github.com/hashicorp/terraform v0.12.0-alpha4
|
||||
github.com/hashicorp/vault v1.0.1 // indirect
|
||||
github.com/keybase/go-crypto v0.0.0-20181127160227-255a5089e85a // indirect
|
||||
github.com/mitchellh/cli v1.0.0 // indirect
|
||||
|
|
@ -37,7 +33,6 @@ require (
|
|||
golang.org/x/net v0.0.0-20181217023233-e147a9138326 // indirect
|
||||
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890
|
||||
google.golang.org/api v0.0.0-20181217000635-41dc4b66e69d
|
||||
google.golang.org/appengine v1.3.0 // indirect
|
||||
google.golang.org/genproto v0.0.0-20181218023534-67d6565462c5 // indirect
|
||||
google.golang.org/grpc v1.17.0 // indirect
|
||||
)
|
||||
|
|
|
|||
136
go.sum
136
go.sum
|
|
@ -1,40 +1,75 @@
|
|||
cloud.google.com/go v0.15.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
|
||||
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
|
||||
cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
|
||||
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
|
||||
git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
|
||||
github.com/Azure/azure-sdk-for-go v21.3.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
|
||||
github.com/Azure/go-autorest v10.15.4+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
|
||||
github.com/Azure/go-ntlmssp v0.0.0-20170803034930-c92175d54006/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
|
||||
github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
|
||||
github.com/Unknwon/com v0.0.0-20151008135407-28b053d5a292/go.mod h1:KYCjqMOeHpNuTOiFQU6WEcTG7poCJrUs0YgyHNtn1no=
|
||||
github.com/abdullin/seq v0.0.0-20160510034733-d5467c17e7af/go.mod h1:5Jv4cbFiHJMsVxt52+i0Ha45fjshj6wxYr1r19tB9bw=
|
||||
github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
|
||||
github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
|
||||
github.com/agl/ed25519 v0.0.0-20150830182803-278e1ec8e8a6/go.mod h1:WPjqKcmVOxf0XSf3YxCJs6N6AOSrOx3obionmG7T0y0=
|
||||
github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk=
|
||||
github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607/go.mod h1:LzD22aAzDP8/dyiCKFp31He4m2GPjl0AFyzDtZzUu9M=
|
||||
github.com/apparentlymart/go-cidr v0.0.0-20170616213631-2bd8b58cf427/go.mod h1:EBcsNrHc3zQeuaeCeCtQruQm+n9/YjEn/vI25Lg7Gwc=
|
||||
github.com/apparentlymart/go-cidr v1.0.0 h1:lGDvXx8Lv9QHjrAVP7jyzleG4F9+FkRhJcEsDFxeb8w=
|
||||
github.com/apparentlymart/go-cidr v1.0.0/go.mod h1:EBcsNrHc3zQeuaeCeCtQruQm+n9/YjEn/vI25Lg7Gwc=
|
||||
github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3 h1:ZSTrOEhiM5J5RFxEaFvMZVEAM1KvT1YzbEOwB2EAGjA=
|
||||
github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM=
|
||||
github.com/apparentlymart/go-textseg v1.0.0 h1:rRmlIsPEEhUTIKQb7T++Nz/A5Q6C9IuX2wFoYVvnCs0=
|
||||
github.com/apparentlymart/go-textseg v1.0.0/go.mod h1:z96Txxhf3xSFMPmb5X/1W05FF/Nj9VFpLOpjS5yuumk=
|
||||
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
|
||||
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
|
||||
github.com/armon/go-radix v0.0.0-20160115234725-4239b77079c7/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
|
||||
github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310 h1:BUAU3CGlLvorLI26FmByPp2eC2qla6E1Tw+scpcg/to=
|
||||
github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
|
||||
github.com/aws/aws-sdk-go v1.15.55/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
|
||||
github.com/aws/aws-sdk-go v1.15.78 h1:LaXy6lWR0YK7LKyuU0QWy2ws/LWTPfYV/UgfiBu4tvY=
|
||||
github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM=
|
||||
github.com/beevik/etree v0.0.0-20171015221209-af219c0c7ea1/go.mod h1:r8Aw8JqVegEf0w2fDnATrX9VpkMcyFeM0FhwO62wh+A=
|
||||
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
|
||||
github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
|
||||
github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
|
||||
github.com/bgentry/speakeasy v0.0.0-20161015143505-675b82c74c0e/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
|
||||
github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
|
||||
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
|
||||
github.com/blang/semver v0.0.0-20170202183821-4a1e882c79dc/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
|
||||
github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
|
||||
github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
|
||||
github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
|
||||
github.com/bsm/go-vlq v0.0.0-20150828105119-ec6e8d4f5f4e/go.mod h1:N+BjUcTjSxc2mtRGSCPsat1kze3CUtvJN3/jTXlp29k=
|
||||
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
|
||||
github.com/chzyer/readline v0.0.0-20161106042343-c914be64f07d/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
|
||||
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
|
||||
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
|
||||
github.com/coreos/bbolt v1.3.0/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
|
||||
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
|
||||
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
|
||||
github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
|
||||
github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/dgrijalva/jwt-go v0.0.0-20160617170158-f0777076321a/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
|
||||
github.com/dimchansky/utfbom v1.0.0/go.mod h1:rO41eb7gLfo8SF1jd9F8HplJm1Fewwi4mQvIirEdv+8=
|
||||
github.com/dnaeon/go-vcr v0.0.0-20180920040454-5637cf3d8a31/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
|
||||
github.com/dustinkirkland/golang-petname v0.0.0-20170921220637-d3c2ba80e75e h1:bRcq7ruHMqCVB/ugLbBylx+LrccNACFDEaqAD/aZ80Q=
|
||||
github.com/dustinkirkland/golang-petname v0.0.0-20170921220637-d3c2ba80e75e/go.mod h1:V+Qd57rJe8gd4eiGzZyg4h54VLHmYVVw54iMnlAMrF8=
|
||||
github.com/dylanmei/iso8601 v0.1.0/go.mod h1:w9KhXSgIyROl1DefbMYIE7UVSIvELTbMrCfx+QkYnoQ=
|
||||
github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08/go.mod h1:VBVDFSBXCIW8JaHQpI8lldSKfYaLMzP9oyq6IJ4fhzY=
|
||||
github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
|
||||
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
|
||||
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
|
||||
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
|
||||
github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
|
||||
github.com/go-test/deep v1.0.1 h1:UQhStjbkDClarlmv0am7OXXO4/GaPdCGiUiMTvi28sg=
|
||||
github.com/go-test/deep v1.0.1/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
|
||||
github.com/gogo/protobuf v0.0.0-20180821102207-98f6aa8b3bcf/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
|
||||
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
|
||||
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
|
||||
github.com/golang/groupcache v0.0.0-20180513044358-24b0969c4cb7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
|
||||
github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
|
||||
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
|
||||
github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
|
||||
|
|
@ -46,51 +81,91 @@ github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c h1:964Od4U6p2jUkFxvCy
|
|||
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
|
||||
github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
|
||||
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
|
||||
github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
|
||||
github.com/googleapis/gax-go v0.0.0-20161107002406-da06d194a00e/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
|
||||
github.com/googleapis/gax-go v2.0.2+incompatible h1:silFMLAnr330+NRuag/VjIGF7TLp/LBrV2CJKFLWEww=
|
||||
github.com/googleapis/gax-go v2.0.2+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
|
||||
github.com/gophercloud/gophercloud v0.0.0-20170524130959-3027adb1ce72/go.mod h1:3WdhXV3rUYy9p6AUW8d94kr+HS62Y4VL9mBnFxsD8q4=
|
||||
github.com/gopherjs/gopherjs v0.0.0-20181004151105-1babbf986f6f/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
|
||||
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
|
||||
github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
|
||||
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
|
||||
github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
|
||||
github.com/grpc-ecosystem/grpc-gateway v1.5.1/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
|
||||
github.com/hashicorp/consul v0.0.0-20171026175957-610f3c86a089/go.mod h1:mFrjN1mfidgJfYP1xrJCF+AfRhr6Eaqhb2+sfyn/OOI=
|
||||
github.com/hashicorp/errwrap v0.0.0-20180715044906-d6c0cd880357/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
|
||||
github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
|
||||
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
|
||||
github.com/hashicorp/go-azure-helpers v0.0.0-20181122151743-c51a3103be3b/go.mod h1:e+GPy2nvD+spqsdjUyw5tbo73rBbu955QBaV9GZoBEA=
|
||||
github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de/go.mod h1:xIwEieBHERyEvaeKF/TcHh1Hu+lxPM+n2vT1+g9I4m4=
|
||||
github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
|
||||
github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
|
||||
github.com/hashicorp/go-getter v0.0.0-20180327010114-90bb99a48d86/go.mod h1:6rdJFnhkXnzGOJbvkrdv4t9nLwKcVA+tmbQeUlkIzrU=
|
||||
github.com/hashicorp/go-getter v0.0.0-20181213035916-be39683deade h1:dBvCsh6SUU8TbrVIXoapp1UGtalncagxH7OnOkrPN/A=
|
||||
github.com/hashicorp/go-getter v0.0.0-20181213035916-be39683deade/go.mod h1:BjYbO/QwTRCU20p2qOfbWtU2TTSuTqPNx1RnlndKOxE=
|
||||
github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI=
|
||||
github.com/hashicorp/go-hclog v0.0.0-20181001195459-61d530d6c27f h1:Yv9YzBlAETjy6AOX9eLBZ3nshNVRREgerT/3nvxlGho=
|
||||
github.com/hashicorp/go-hclog v0.0.0-20181001195459-61d530d6c27f/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
|
||||
github.com/hashicorp/go-immutable-radix v0.0.0-20180129170900-7f3cd4390caa/go.mod h1:6ij3Z20p+OhOkCSrA0gImAWoHYQRGbnlcuk6XYTiaRw=
|
||||
github.com/hashicorp/go-msgpack v0.0.0-20150518234257-fa3f63826f7c/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
|
||||
github.com/hashicorp/go-multierror v0.0.0-20180717150148-3d5d8f294aa0/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I=
|
||||
github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
|
||||
github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
|
||||
github.com/hashicorp/go-plugin v0.0.0-20181205205220-20341d70f4ff/go.mod h1:Ft7ju2vWzhO0ETMKUVo12XmXmII6eSUS4rsPTkY/siA=
|
||||
github.com/hashicorp/go-plugin v0.0.0-20181212150838-f444068e8f5a h1:z9eTtDWoxYrJvtAD+xAepmTEfEmYgouWUytJ84UWAr8=
|
||||
github.com/hashicorp/go-plugin v0.0.0-20181212150838-f444068e8f5a/go.mod h1:Ft7ju2vWzhO0ETMKUVo12XmXmII6eSUS4rsPTkY/siA=
|
||||
github.com/hashicorp/go-retryablehttp v0.5.0/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
|
||||
github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90/go.mod h1:o4zcYY1e0GEZI6eSEr+43QDYmuGglw1qSO6qdHUHCgg=
|
||||
github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
|
||||
github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
|
||||
github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
|
||||
github.com/hashicorp/go-slug v0.2.0/go.mod h1:+zDycQOzGqOqMW7Kn2fp9vz/NtqpMLQlgb9JUF+0km4=
|
||||
github.com/hashicorp/go-sockaddr v0.0.0-20180320115054-6d291a969b86/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
|
||||
github.com/hashicorp/go-tfe v0.3.4/go.mod h1:Vssg8/lwVz+PyJ/nAK97zYmXxxLe28MCIMhKo+rva1o=
|
||||
github.com/hashicorp/go-uuid v1.0.0 h1:RS8zrF7PhGwyNPOtxSClXXj9HA8feRnJzgnI1RJCSnM=
|
||||
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
|
||||
github.com/hashicorp/go-version v0.0.0-20180322230233-23480c066577/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
|
||||
github.com/hashicorp/go-version v1.0.0 h1:21MVWPKDphxa7ineQQTrCU5brh7OuVVAzGOCnnCPtE8=
|
||||
github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
|
||||
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
|
||||
github.com/hashicorp/hcl v0.0.0-20170504190234-a4b07c25de5f/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
|
||||
github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
|
||||
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
|
||||
github.com/hashicorp/hcl2 v0.0.0-20181204002630-cd67ba1b25f3/go.mod h1:ShfpTh661oAaxo7VcNxg0zcZW6jvMa7Moy2oFx7e5dE=
|
||||
github.com/hashicorp/hcl2 v0.0.0-20181215005721-253da47fd604 h1:k660QMbAqhL4vxSNPmvOAjzZJ7BQiwTrT8pa8RH3OEA=
|
||||
github.com/hashicorp/hcl2 v0.0.0-20181215005721-253da47fd604/go.mod h1:ShfpTh661oAaxo7VcNxg0zcZW6jvMa7Moy2oFx7e5dE=
|
||||
github.com/hashicorp/hil v0.0.0-20170627220502-fa9f258a9250 h1:fooK5IvDL/KIsi4LxF/JH68nVdrBSiGNPhS2JAQjtjo=
|
||||
github.com/hashicorp/hil v0.0.0-20170627220502-fa9f258a9250/go.mod h1:KHvg/R2/dPtaePb16oW4qIyzkMxXOL38xjRN64adsts=
|
||||
github.com/hashicorp/logutils v0.0.0-20150609070431-0dc08b1671f3/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
|
||||
github.com/hashicorp/logutils v1.0.0 h1:dLEQVugN8vlakKOUE3ihGLTZJRB4j+M2cdTm/ORI65Y=
|
||||
github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
|
||||
github.com/hashicorp/memberlist v0.1.0/go.mod h1:ncdBp14cuox2iFOq3kDiquKU6fqsTBc3W6JvZwjxxsE=
|
||||
github.com/hashicorp/serf v0.0.0-20160124182025-e4ec8cc423bb/go.mod h1:h/Ru6tmZazX7WO/GDmwdpS975F019L4t5ng5IgwbNrE=
|
||||
github.com/hashicorp/terraform v0.11.9-0.20180926212128-35d82b055591 h1:A2Bm1/dX0N2FRBqg10MgN0OYmdL/S8ZbgdmDvWmmQ7o=
|
||||
github.com/hashicorp/terraform v0.11.9-0.20180926212128-35d82b055591/go.mod h1:uN1KUiT7Wdg61fPwsGXQwK3c8PmpIVZrt5Vcb1VrSoM=
|
||||
github.com/hashicorp/terraform v0.12.0-alpha4 h1:8V1VhAeQPY3tt55zxJ4lOhtSi/QUVLqFmFSLsi1xSqc=
|
||||
github.com/hashicorp/terraform v0.12.0-alpha4/go.mod h1:/NPUSmdWTeKONyjGU/WorQ6BZEPkaAs4yC+LVKL7wy8=
|
||||
github.com/hashicorp/vault v0.0.0-20161029210149-9a60bf2a50e4/go.mod h1:KfSyffbKxoVyspOdlaGVjIuwLobi07qD1bAbosPMpP0=
|
||||
github.com/hashicorp/vault v1.0.1 h1:x3hcjkJLd5L4ehPhZcraokFO7dq8MJ3oKvQtrkIiIU8=
|
||||
github.com/hashicorp/vault v1.0.1/go.mod h1:KfSyffbKxoVyspOdlaGVjIuwLobi07qD1bAbosPMpP0=
|
||||
github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb h1:b5rjCoWHc7eqmAS4/qyk21ZsHyb6Mxv/jykxvNTkU4M=
|
||||
github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
|
||||
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
|
||||
github.com/jen20/awspolicyequivalence v0.0.0-20170831201602-3d48364a137a/go.mod h1:uoIMjNxUfXi48Ci40IXkPRbghZ1vbti6v9LCbNqRgHY=
|
||||
github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
|
||||
github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE=
|
||||
github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
|
||||
github.com/jmespath/go-jmespath v0.0.0-20160803190731-bd40a432e4c7 h1:SMvOWPJCES2GdFracYbBQh93GXac8fq7HeN6JnpduB8=
|
||||
github.com/jmespath/go-jmespath v0.0.0-20160803190731-bd40a432e4c7/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
|
||||
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
|
||||
github.com/joyent/triton-go v0.0.0-20180313100802-d8f9c0314926/go.mod h1:U+RSyWxWd04xTqnuOQxnai7XGS2PrPY2cfGoDKtMHjA=
|
||||
github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
|
||||
github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
|
||||
github.com/keybase/go-crypto v0.0.0-20161004153544-93f5b35093ba/go.mod h1:ghbZscTyKdM07+Fw3KSi0hcJm+AlEUWj8QLlPtijN/M=
|
||||
github.com/keybase/go-crypto v0.0.0-20181127160227-255a5089e85a h1:X/UFlwD2/UV0RCy+8ITi4DmxJwk83YUH7bXwkJIHHMo=
|
||||
github.com/keybase/go-crypto v0.0.0-20181127160227-255a5089e85a/go.mod h1:ghbZscTyKdM07+Fw3KSi0hcJm+AlEUWj8QLlPtijN/M=
|
||||
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
|
||||
github.com/konsorten/go-windows-terminal-sequences v0.0.0-20180402223658-b729f2633dfe/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
|
||||
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
|
||||
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
|
||||
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
||||
|
|
@ -98,62 +173,116 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
|
|||
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
||||
github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
|
||||
github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
|
||||
github.com/lusis/go-artifactory v0.0.0-20160115162124-7e4ce345df82/go.mod h1:y54tfGmO3NKssKveTEFFzH8C/akrSOy/iW9qEAUDV84=
|
||||
github.com/marstr/guid v1.1.0/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho=
|
||||
github.com/masterzen/azure-sdk-for-go v0.0.0-20161014135628-ee4f0065d00c/go.mod h1:mf8fjOu33zCqxUjuiU3I8S1lJMyEAlH+0F2+M5xl3hE=
|
||||
github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
|
||||
github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939/go.mod h1:CfZSN7zwz5gJiFhZJz49Uzk7mEBHIceWmbFmYx7Hf7E=
|
||||
github.com/mattn/go-colorable v0.0.0-20160220075935-9cbef7c35391/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
|
||||
github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
|
||||
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
|
||||
github.com/mattn/go-isatty v0.0.0-20161123143637-30a891c33c7c/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
|
||||
github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
|
||||
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
|
||||
github.com/mattn/go-shellwords v1.0.1/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o=
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
|
||||
github.com/miekg/dns v1.0.8/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
|
||||
github.com/mitchellh/cli v0.0.0-20171129193617-33edc47170b5/go.mod h1:oGumspjLm2kTyiT1QMGpFqRlmxnKHfCvhZEVnx+5UeE=
|
||||
github.com/mitchellh/cli v1.0.0 h1:iGBIsUe3+HZ/AD/Vd7DErOt5sU9fa8Uj7A2s1aggv1Y=
|
||||
github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
|
||||
github.com/mitchellh/colorstring v0.0.0-20150917214807-8631ce90f286/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
|
||||
github.com/mitchellh/copystructure v0.0.0-20170525013902-d23ffcb85de3/go.mod h1:eOsF2yLPlBBJPvD+nhl5QMTBSOBbOph6N7j/IDUw7PY=
|
||||
github.com/mitchellh/copystructure v1.0.0 h1:Laisrj+bAB6b/yJwB5Bt3ITZhGJdqmxquMKeZ+mmkFQ=
|
||||
github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
|
||||
github.com/mitchellh/go-homedir v0.0.0-20161203194507-b8bc1bf76747/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
|
||||
github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
|
||||
github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
|
||||
github.com/mitchellh/go-linereader v0.0.0-20141013185533-07bab5fdd958/go.mod h1:OaY7UOoTkkrX3wRwjpYRKafIkkyeD0UtweSHAWWiqQM=
|
||||
github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
|
||||
github.com/mitchellh/go-testing-interface v1.0.0 h1:fzU/JVNcaqHQEcVFAKeR41fkiLdIPrefOvVG1VZ96U0=
|
||||
github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
|
||||
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
|
||||
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
|
||||
github.com/mitchellh/go-wordwrap v1.0.0 h1:6GlHJ/LTGMrIJbwgdqdl2eEH8o+Exx/0m8ir9Gns0u4=
|
||||
github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
|
||||
github.com/mitchellh/hashstructure v0.0.0-20160209213820-6b17d669fac5/go.mod h1:QjSHrPWS+BGUVBYkbTZWEnOh3G1DutKwClXU/ABz6AQ=
|
||||
github.com/mitchellh/hashstructure v1.0.0 h1:ZkRJX1CyOoTkar7p/mLS5TZU4nJ1Rn/F8u9dGS02Q3Y=
|
||||
github.com/mitchellh/hashstructure v1.0.0/go.mod h1:QjSHrPWS+BGUVBYkbTZWEnOh3G1DutKwClXU/ABz6AQ=
|
||||
github.com/mitchellh/mapstructure v0.0.0-20170307201123-53818660ed49/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
|
||||
github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
|
||||
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
|
||||
github.com/mitchellh/panicwrap v0.0.0-20161208170302-ba9e1a65e0f7/go.mod h1:QuAqW7/z+iv6aWFJdrA8kCbsF0OOJVKCICqTcYBexuY=
|
||||
github.com/mitchellh/prefixedio v0.0.0-20151214002211-6e6954073784/go.mod h1:kB1naBgV9ORnkiTVeyJOI1DavaJkG4oNIq0Af6ZVKUo=
|
||||
github.com/mitchellh/reflectwalk v0.0.0-20170726202117-63d60e9d0dbc/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
|
||||
github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
|
||||
github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
|
||||
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
|
||||
github.com/oklog/run v1.0.0 h1:Ru7dDtJNOyC66gQ5dQmaCa0qIsAUFY3sFpK1Xk8igrw=
|
||||
github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
|
||||
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
|
||||
github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
|
||||
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
|
||||
github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
|
||||
github.com/packer-community/winrmcp v0.0.0-20180102160824-81144009af58/go.mod h1:f6Izs6JvFTdnRbziASagjZ2vmf55NSIkC/weStxCHqk=
|
||||
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
|
||||
github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
|
||||
github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
|
||||
github.com/pkg/errors v0.0.0-20170505043639-c605e284fe17/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/posener/complete v0.0.0-20171219111128-6bee943216c8/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
|
||||
github.com/posener/complete v1.1.1 h1:ccV59UEOTzVDnDUEFdT95ZzHVZ+5+158q8+SJb2QV5w=
|
||||
github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
|
||||
github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
|
||||
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
|
||||
github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
|
||||
github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
|
||||
github.com/satori/go.uuid v0.0.0-20160927100844-b061729afc07/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
|
||||
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
|
||||
github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
|
||||
github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
|
||||
github.com/sirupsen/logrus v1.1.1/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
|
||||
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
|
||||
github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
|
||||
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
|
||||
github.com/spf13/afero v1.0.2 h1:5bRmqmInNmNFkI9NG9O0Xc/Lgl9wOWWUUA/O8XZqTCo=
|
||||
github.com/spf13/afero v1.0.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
|
||||
github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
|
||||
github.com/stoewer/go-strcase v1.0.2 h1:l3iQ2FPu8+36ars/7syO1dQAkjwMCb1IE3J+Th0ohfE=
|
||||
github.com/stoewer/go-strcase v1.0.2/go.mod h1:eLfe5bL3qbL7ep/KafHzthxejrOF5J3xmt03uL5tzek=
|
||||
github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
|
||||
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
|
||||
github.com/svanharmelen/jsonapi v0.0.0-20180618144545-0c0828c3f16d/go.mod h1:BSTlc8jOjh0niykqEGVXOLXdi9o0r0kR8tCYiMvjFgw=
|
||||
github.com/terraform-providers/terraform-provider-aws v1.41.0/go.mod h1:uvqaeKnm2ydZ2LuKuW1NDNBu6heC/7IDGXWm36/6oKs=
|
||||
github.com/terraform-providers/terraform-provider-openstack v0.0.0-20170616075611-4080a521c6ea/go.mod h1:2aQ6n/BtChAl1y2S60vebhyJyZXBsuAI5G4+lHrT1Ew=
|
||||
github.com/terraform-providers/terraform-provider-random v2.0.0+incompatible h1:4wuExSWk/NHYS95P2H4KGv22bsabuDjGk5cFikIYzuU=
|
||||
github.com/terraform-providers/terraform-provider-random v2.0.0+incompatible/go.mod h1:1U2balY0mfjMnO5iotT60EuFqDJxqP433wJcybviCTw=
|
||||
github.com/terraform-providers/terraform-provider-template v1.0.0/go.mod h1:/J+B8me5DCMa0rEBH5ic2aKPjhtpWNeScmxFJWxB1EU=
|
||||
github.com/terraform-providers/terraform-provider-tls v1.2.0/go.mod h1:Mxe/v5u31LDW4m32O1z6Ursdh95dpc9Puq6otkYg7tU=
|
||||
github.com/tmc/grpc-websocket-proxy v0.0.0-20171017195756-830351dc03c6/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
|
||||
github.com/ugorji/go v0.0.0-20180813092308-00b869d2f4a5/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
|
||||
github.com/ulikunitz/xz v0.5.4/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
|
||||
github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
|
||||
github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
|
||||
github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
|
||||
github.com/vmihailenco/msgpack v4.0.1+incompatible h1:RMF1enSPeKTlXrXdOcqjFUElywVZjjC6pqse21bKbEU=
|
||||
github.com/vmihailenco/msgpack v4.0.1+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
|
||||
github.com/xanzy/ssh-agent v0.2.0/go.mod h1:0NyE30eGUDliuLEHJgYte/zncp2zdTStcOnWhgSqHD8=
|
||||
github.com/xiang90/probing v0.0.0-20160813154853-07dd2e8dfe18/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
|
||||
github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
|
||||
github.com/zclconf/go-cty v0.0.0-20181129180422-88fbe721e0f8/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
|
||||
github.com/zclconf/go-cty v0.0.0-20181218225846-4fe1e489ee06 h1:J3bfEicd/d85VHC6bPhrKb+2jO+Uquiy2bnkhia6XBA=
|
||||
github.com/zclconf/go-cty v0.0.0-20181218225846-4fe1e489ee06/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
|
||||
go.opencensus.io v0.17.0/go.mod h1:mp1VrMQxhlqqDpKvH4UcQUa4YwlzNmymAjPrDdfxNpI=
|
||||
go.opencensus.io v0.18.0 h1:Mk5rgZcggtbvtAun5aJzAtjKKN/t0R3jJPlWILlv938=
|
||||
go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
|
||||
go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
|
||||
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
|
||||
go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
|
||||
golang.org/x/crypto v0.0.0-20180816225734-aabede6cba87/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||
golang.org/x/crypto v0.0.0-20181112202954-3d3f9f413869/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||
golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
|
||||
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||
golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
|
||||
|
|
@ -168,6 +297,7 @@ golang.org/x/net v0.0.0-20181129055619-fae4c4e3ad76/go.mod h1:mL1N/T3taQHkDXs73r
|
|||
golang.org/x/net v0.0.0-20181217023233-e147a9138326 h1:iCzOf0xz39Tstp+Tu/WwyGjUXCk34QhQORRxBeXXTA4=
|
||||
golang.org/x/net v0.0.0-20181217023233-e147a9138326/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
golang.org/x/oauth2 v0.0.0-20181003184128-c57b0facaced/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890 h1:uESlIz09WIHT2I+pasSXcpLYqYK8wHcdCetU3VuMBJE=
|
||||
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
|
|
@ -175,12 +305,17 @@ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTm
|
|||
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
|
||||
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 h1:YAFjXN64LMvktoUZH9zgY4lGc/msGN7HQfoSuKCgaDU=
|
||||
golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
|
||||
google.golang.org/api v0.0.0-20181015145326-625cd1887957/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
|
||||
google.golang.org/api v0.0.0-20181217000635-41dc4b66e69d h1:VhRqKr7/NDe5MpNpIj6Cy1xiwcVL4ZPs2GjTYziBRRg=
|
||||
google.golang.org/api v0.0.0-20181217000635-41dc4b66e69d/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
|
||||
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
|
||||
|
|
@ -198,6 +333,7 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
|
|||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
|
||||
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
|
||||
gopkg.in/vmihailenco/msgpack.v2 v2.9.1/go.mod h1:/3Dn1Npt9+MYyLpYYXjInO/5jvMLamn+AEGwNEOatn8=
|
||||
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||
honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
|
||||
|
|
|
|||
184
vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
generated
vendored
Normal file
184
vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
# HCL Dynamic Blocks Extension
|
||||
|
||||
This HCL extension implements a special block type named "dynamic" that can
|
||||
be used to dynamically generate blocks of other types by iterating over
|
||||
collection values.
|
||||
|
||||
Normally the block structure in an HCL configuration file is rigid, even
|
||||
though dynamic expressions can be used within attribute values. This is
|
||||
convenient for most applications since it allows the overall structure of
|
||||
the document to be decoded easily, but in some applications it is desirable
|
||||
to allow dynamic block generation within certain portions of the configuration.
|
||||
|
||||
Dynamic block generation is performed using the `dynamic` block type:
|
||||
|
||||
```hcl
|
||||
toplevel {
|
||||
nested {
|
||||
foo = "static block 1"
|
||||
}
|
||||
|
||||
dynamic "nested" {
|
||||
for_each = ["a", "b", "c"]
|
||||
iterator = nested
|
||||
content {
|
||||
foo = "dynamic block ${nested.value}"
|
||||
}
|
||||
}
|
||||
|
||||
nested {
|
||||
foo = "static block 2"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
The above is interpreted as if it were written as follows:
|
||||
|
||||
```hcl
|
||||
toplevel {
|
||||
nested {
|
||||
foo = "static block 1"
|
||||
}
|
||||
|
||||
nested {
|
||||
foo = "dynamic block a"
|
||||
}
|
||||
|
||||
nested {
|
||||
foo = "dynamic block b"
|
||||
}
|
||||
|
||||
nested {
|
||||
foo = "dynamic block c"
|
||||
}
|
||||
|
||||
nested {
|
||||
foo = "static block 2"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Since HCL block syntax is not normally exposed to the possibility of unknown
|
||||
values, this extension must make some compromises when asked to iterate over
|
||||
an unknown collection. If the length of the collection cannot be statically
|
||||
recognized (because it is an unknown value of list, map, or set type) then
|
||||
the `dynamic` construct will generate a _single_ dynamic block whose iterator
|
||||
key and value are both unknown values of the dynamic pseudo-type, thus causing
|
||||
any attribute values derived from iteration to appear as unknown values. There
|
||||
is no explicit representation of the fact that the length of the collection may
|
||||
eventually be different than one.
|
||||
|
||||
## Usage
|
||||
|
||||
Pass a body to function `Expand` to obtain a new body that will, on access
|
||||
to its content, evaluate and expand any nested `dynamic` blocks.
|
||||
Dynamic block processing is also automatically propagated into any nested
|
||||
blocks that are returned, allowing users to nest dynamic blocks inside
|
||||
one another and to nest dynamic blocks inside other static blocks.
|
||||
|
||||
HCL structural decoding does not normally have access to an `EvalContext`, so
|
||||
any variables and functions that should be available to the `for_each`
|
||||
and `labels` expressions must be passed in when calling `Expand`. Expressions
|
||||
within the `content` block are evaluated separately and so can be passed a
|
||||
separate `EvalContext` if desired, during normal attribute expression
|
||||
evaluation.
|
||||
|
||||
## Detecting Variables
|
||||
|
||||
Some applications dynamically generate an `EvalContext` by analyzing which
|
||||
variables are referenced by an expression before evaluating it.
|
||||
|
||||
This unfortunately requires some extra effort when this analysis is required
|
||||
for the context passed to `Expand`: the HCL API requires a schema to be
|
||||
provided in order to do any analysis of the blocks in a body, but the low-level
|
||||
schema model provides a description of only one level of nested blocks at
|
||||
a time, and thus a new schema must be provided for each additional level of
|
||||
nesting.
|
||||
|
||||
To make this arduous process as convenient as possbile, this package provides
|
||||
a helper function `WalkForEachVariables`, which returns a `WalkVariablesNode`
|
||||
instance that can be used to find variables directly in a given body and also
|
||||
determine which nested blocks require recursive calls. Using this mechanism
|
||||
requires that the caller be able to look up a schema given a nested block type.
|
||||
For _simple_ formats where a specific block type name always has the same schema
|
||||
regardless of context, a walk can be implemented as follows:
|
||||
|
||||
```go
|
||||
func walkVariables(node dynblock.WalkVariablesNode, schema *hcl.BodySchema) []hcl.Traversal {
|
||||
vars, children := node.Visit(schema)
|
||||
|
||||
for _, child := range children {
|
||||
var childSchema *hcl.BodySchema
|
||||
switch child.BlockTypeName {
|
||||
case "a":
|
||||
childSchema = &hcl.BodySchema{
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "b",
|
||||
LabelNames: []string{"key"},
|
||||
},
|
||||
},
|
||||
}
|
||||
case "b":
|
||||
childSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "val",
|
||||
Required: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
default:
|
||||
// Should never happen, because the above cases should be exhaustive
|
||||
// for the application's configuration format.
|
||||
panic(fmt.Errorf("can't find schema for unknown block type %q", child.BlockTypeName))
|
||||
}
|
||||
|
||||
vars = append(vars, testWalkAndAccumVars(child.Node, childSchema)...)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Detecting Variables with `hcldec` Specifications
|
||||
|
||||
For applications that use the higher-level `hcldec` package to decode nested
|
||||
configuration structures into `cty` values, the same specification can be used
|
||||
to automatically drive the recursive variable-detection walk described above.
|
||||
|
||||
The helper function `ForEachVariablesHCLDec` allows an entire recursive
|
||||
configuration structure to be analyzed in a single call given a `hcldec.Spec`
|
||||
that describes the nested block structure. This means a `hcldec`-based
|
||||
application can support dynamic blocks with only a little additional effort:
|
||||
|
||||
```go
|
||||
func decodeBody(body hcl.Body, spec hcldec.Spec) (cty.Value, hcl.Diagnostics) {
|
||||
// Determine which variables are needed to expand dynamic blocks
|
||||
neededForDynamic := dynblock.ForEachVariablesHCLDec(body, spec)
|
||||
|
||||
// Build a suitable EvalContext and expand dynamic blocks
|
||||
dynCtx := buildEvalContext(neededForDynamic)
|
||||
dynBody := dynblock.Expand(body, dynCtx)
|
||||
|
||||
// Determine which variables are needed to fully decode the expanded body
|
||||
// This will analyze expressions that came both from static blocks in the
|
||||
// original body and from blocks that were dynamically added by Expand.
|
||||
neededForDecode := hcldec.Variables(dynBody, spec)
|
||||
|
||||
// Build a suitable EvalContext and then fully decode the body as per the
|
||||
// hcldec specification.
|
||||
decCtx := buildEvalContext(neededForDecode)
|
||||
return hcldec.Decode(dynBody, spec, decCtx)
|
||||
}
|
||||
|
||||
func buildEvalContext(needed []hcl.Traversal) *hcl.EvalContext {
|
||||
// (to be implemented by your application)
|
||||
}
|
||||
```
|
||||
|
||||
# Performance
|
||||
|
||||
This extension is going quite harshly against the grain of the HCL API, and
|
||||
so it uses lots of wrapping objects and temporary data structures to get its
|
||||
work done. HCL in general is not suitable for use in high-performance situations
|
||||
or situations sensitive to memory pressure, but that is _especially_ true for
|
||||
this extension.
|
||||
251
vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_body.go
generated
vendored
Normal file
251
vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_body.go
generated
vendored
Normal file
|
|
@ -0,0 +1,251 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// expandBody wraps another hcl.Body and expands any "dynamic" blocks found
|
||||
// inside whenever Content or PartialContent is called.
|
||||
type expandBody struct {
|
||||
original hcl.Body
|
||||
forEachCtx *hcl.EvalContext
|
||||
iteration *iteration // non-nil if we're nested inside another "dynamic" block
|
||||
|
||||
// These are used with PartialContent to produce a "remaining items"
|
||||
// body to return. They are nil on all bodies fresh out of the transformer.
|
||||
//
|
||||
// Note that this is re-implemented here rather than delegating to the
|
||||
// existing support required by the underlying body because we need to
|
||||
// retain access to the entire original body on subsequent decode operations
|
||||
// so we can retain any "dynamic" blocks for types we didn't take consume
|
||||
// on the first pass.
|
||||
hiddenAttrs map[string]struct{}
|
||||
hiddenBlocks map[string]hcl.BlockHeaderSchema
|
||||
}
|
||||
|
||||
func (b *expandBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
|
||||
extSchema := b.extendSchema(schema)
|
||||
rawContent, diags := b.original.Content(extSchema)
|
||||
|
||||
blocks, blockDiags := b.expandBlocks(schema, rawContent.Blocks, false)
|
||||
diags = append(diags, blockDiags...)
|
||||
attrs := b.prepareAttributes(rawContent.Attributes)
|
||||
|
||||
content := &hcl.BodyContent{
|
||||
Attributes: attrs,
|
||||
Blocks: blocks,
|
||||
MissingItemRange: b.original.MissingItemRange(),
|
||||
}
|
||||
|
||||
return content, diags
|
||||
}
|
||||
|
||||
func (b *expandBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
|
||||
extSchema := b.extendSchema(schema)
|
||||
rawContent, _, diags := b.original.PartialContent(extSchema)
|
||||
// We discard the "remain" argument above because we're going to construct
|
||||
// our own remain that also takes into account remaining "dynamic" blocks.
|
||||
|
||||
blocks, blockDiags := b.expandBlocks(schema, rawContent.Blocks, true)
|
||||
diags = append(diags, blockDiags...)
|
||||
attrs := b.prepareAttributes(rawContent.Attributes)
|
||||
|
||||
content := &hcl.BodyContent{
|
||||
Attributes: attrs,
|
||||
Blocks: blocks,
|
||||
MissingItemRange: b.original.MissingItemRange(),
|
||||
}
|
||||
|
||||
remain := &expandBody{
|
||||
original: b.original,
|
||||
forEachCtx: b.forEachCtx,
|
||||
iteration: b.iteration,
|
||||
hiddenAttrs: make(map[string]struct{}),
|
||||
hiddenBlocks: make(map[string]hcl.BlockHeaderSchema),
|
||||
}
|
||||
for name := range b.hiddenAttrs {
|
||||
remain.hiddenAttrs[name] = struct{}{}
|
||||
}
|
||||
for typeName, blockS := range b.hiddenBlocks {
|
||||
remain.hiddenBlocks[typeName] = blockS
|
||||
}
|
||||
for _, attrS := range schema.Attributes {
|
||||
remain.hiddenAttrs[attrS.Name] = struct{}{}
|
||||
}
|
||||
for _, blockS := range schema.Blocks {
|
||||
remain.hiddenBlocks[blockS.Type] = blockS
|
||||
}
|
||||
|
||||
return content, remain, diags
|
||||
}
|
||||
|
||||
func (b *expandBody) extendSchema(schema *hcl.BodySchema) *hcl.BodySchema {
|
||||
// We augment the requested schema to also include our special "dynamic"
|
||||
// block type, since then we'll get instances of it interleaved with
|
||||
// all of the literal child blocks we must also include.
|
||||
extSchema := &hcl.BodySchema{
|
||||
Attributes: schema.Attributes,
|
||||
Blocks: make([]hcl.BlockHeaderSchema, len(schema.Blocks), len(schema.Blocks)+len(b.hiddenBlocks)+1),
|
||||
}
|
||||
copy(extSchema.Blocks, schema.Blocks)
|
||||
extSchema.Blocks = append(extSchema.Blocks, dynamicBlockHeaderSchema)
|
||||
|
||||
// If we have any hiddenBlocks then we also need to register those here
|
||||
// so that a call to "Content" on the underlying body won't fail.
|
||||
// (We'll filter these out again once we process the result of either
|
||||
// Content or PartialContent.)
|
||||
for _, blockS := range b.hiddenBlocks {
|
||||
extSchema.Blocks = append(extSchema.Blocks, blockS)
|
||||
}
|
||||
|
||||
// If we have any hiddenAttrs then we also need to register these, for
|
||||
// the same reason as we deal with hiddenBlocks above.
|
||||
if len(b.hiddenAttrs) != 0 {
|
||||
newAttrs := make([]hcl.AttributeSchema, len(schema.Attributes), len(schema.Attributes)+len(b.hiddenAttrs))
|
||||
copy(newAttrs, extSchema.Attributes)
|
||||
for name := range b.hiddenAttrs {
|
||||
newAttrs = append(newAttrs, hcl.AttributeSchema{
|
||||
Name: name,
|
||||
Required: false,
|
||||
})
|
||||
}
|
||||
extSchema.Attributes = newAttrs
|
||||
}
|
||||
|
||||
return extSchema
|
||||
}
|
||||
|
||||
func (b *expandBody) prepareAttributes(rawAttrs hcl.Attributes) hcl.Attributes {
|
||||
if len(b.hiddenAttrs) == 0 && b.iteration == nil {
|
||||
// Easy path: just pass through the attrs from the original body verbatim
|
||||
return rawAttrs
|
||||
}
|
||||
|
||||
// Otherwise we have some work to do: we must filter out any attributes
|
||||
// that are hidden (since a previous PartialContent call already saw these)
|
||||
// and wrap the expressions of the inner attributes so that they will
|
||||
// have access to our iteration variables.
|
||||
attrs := make(hcl.Attributes, len(rawAttrs))
|
||||
for name, rawAttr := range rawAttrs {
|
||||
if _, hidden := b.hiddenAttrs[name]; hidden {
|
||||
continue
|
||||
}
|
||||
if b.iteration != nil {
|
||||
attr := *rawAttr // shallow copy so we can mutate it
|
||||
attr.Expr = exprWrap{
|
||||
Expression: attr.Expr,
|
||||
i: b.iteration,
|
||||
}
|
||||
attrs[name] = &attr
|
||||
} else {
|
||||
// If we have no active iteration then no wrapping is required.
|
||||
attrs[name] = rawAttr
|
||||
}
|
||||
}
|
||||
return attrs
|
||||
}
|
||||
|
||||
func (b *expandBody) expandBlocks(schema *hcl.BodySchema, rawBlocks hcl.Blocks, partial bool) (hcl.Blocks, hcl.Diagnostics) {
|
||||
var blocks hcl.Blocks
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
for _, rawBlock := range rawBlocks {
|
||||
switch rawBlock.Type {
|
||||
case "dynamic":
|
||||
realBlockType := rawBlock.Labels[0]
|
||||
if _, hidden := b.hiddenBlocks[realBlockType]; hidden {
|
||||
continue
|
||||
}
|
||||
|
||||
var blockS *hcl.BlockHeaderSchema
|
||||
for _, candidate := range schema.Blocks {
|
||||
if candidate.Type == realBlockType {
|
||||
blockS = &candidate
|
||||
break
|
||||
}
|
||||
}
|
||||
if blockS == nil {
|
||||
// Not a block type that the caller requested.
|
||||
if !partial {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported block type",
|
||||
Detail: fmt.Sprintf("Blocks of type %q are not expected here.", realBlockType),
|
||||
Subject: &rawBlock.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
spec, specDiags := b.decodeSpec(blockS, rawBlock)
|
||||
diags = append(diags, specDiags...)
|
||||
if specDiags.HasErrors() {
|
||||
continue
|
||||
}
|
||||
|
||||
if spec.forEachVal.IsKnown() {
|
||||
for it := spec.forEachVal.ElementIterator(); it.Next(); {
|
||||
key, value := it.Element()
|
||||
i := b.iteration.MakeChild(spec.iteratorName, key, value)
|
||||
|
||||
block, blockDiags := spec.newBlock(i, b.forEachCtx)
|
||||
diags = append(diags, blockDiags...)
|
||||
if block != nil {
|
||||
// Attach our new iteration context so that attributes
|
||||
// and other nested blocks can refer to our iterator.
|
||||
block.Body = b.expandChild(block.Body, i)
|
||||
blocks = append(blocks, block)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// If our top-level iteration value isn't known then we're forced
|
||||
// to compromise since HCL doesn't have any concept of an
|
||||
// "unknown block". In this case then, we'll produce a single
|
||||
// dynamic block with the iterator values set to DynamicVal,
|
||||
// which at least makes the potential for a block visible
|
||||
// in our result, even though it's not represented in a fully-accurate
|
||||
// way.
|
||||
i := b.iteration.MakeChild(spec.iteratorName, cty.DynamicVal, cty.DynamicVal)
|
||||
block, blockDiags := spec.newBlock(i, b.forEachCtx)
|
||||
diags = append(diags, blockDiags...)
|
||||
if block != nil {
|
||||
block.Body = b.expandChild(block.Body, i)
|
||||
blocks = append(blocks, block)
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
if _, hidden := b.hiddenBlocks[rawBlock.Type]; !hidden {
|
||||
// A static block doesn't create a new iteration context, but
|
||||
// it does need to inherit _our own_ iteration context in
|
||||
// case it contains expressions that refer to our inherited
|
||||
// iterators, or nested "dynamic" blocks.
|
||||
expandedBlock := *rawBlock // shallow copy
|
||||
expandedBlock.Body = b.expandChild(rawBlock.Body, b.iteration)
|
||||
blocks = append(blocks, &expandedBlock)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return blocks, diags
|
||||
}
|
||||
|
||||
func (b *expandBody) expandChild(child hcl.Body, i *iteration) hcl.Body {
|
||||
ret := Expand(child, b.forEachCtx)
|
||||
ret.(*expandBody).iteration = i
|
||||
return ret
|
||||
}
|
||||
|
||||
func (b *expandBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
|
||||
// blocks aren't allowed in JustAttributes mode and this body can
|
||||
// only produce blocks, so we'll just pass straight through to our
|
||||
// underlying body here.
|
||||
return b.original.JustAttributes()
|
||||
}
|
||||
|
||||
func (b *expandBody) MissingItemRange() hcl.Range {
|
||||
return b.original.MissingItemRange()
|
||||
}
|
||||
212
vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_spec.go
generated
vendored
Normal file
212
vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_spec.go
generated
vendored
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
)
|
||||
|
||||
type expandSpec struct {
|
||||
blockType string
|
||||
blockTypeRange hcl.Range
|
||||
defRange hcl.Range
|
||||
forEachVal cty.Value
|
||||
iteratorName string
|
||||
labelExprs []hcl.Expression
|
||||
contentBody hcl.Body
|
||||
inherited map[string]*iteration
|
||||
}
|
||||
|
||||
func (b *expandBody) decodeSpec(blockS *hcl.BlockHeaderSchema, rawSpec *hcl.Block) (*expandSpec, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
var schema *hcl.BodySchema
|
||||
if len(blockS.LabelNames) != 0 {
|
||||
schema = dynamicBlockBodySchemaLabels
|
||||
} else {
|
||||
schema = dynamicBlockBodySchemaNoLabels
|
||||
}
|
||||
|
||||
specContent, specDiags := rawSpec.Body.Content(schema)
|
||||
diags = append(diags, specDiags...)
|
||||
if specDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
//// for_each attribute
|
||||
|
||||
eachAttr := specContent.Attributes["for_each"]
|
||||
eachVal, eachDiags := eachAttr.Expr.Value(b.forEachCtx)
|
||||
diags = append(diags, eachDiags...)
|
||||
|
||||
if !eachVal.CanIterateElements() {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic for_each value",
|
||||
Detail: fmt.Sprintf("Cannot use a value of type %s in for_each. An iterable collection is required.", eachVal.Type()),
|
||||
Subject: eachAttr.Expr.Range().Ptr(),
|
||||
Expression: eachAttr.Expr,
|
||||
EvalContext: b.forEachCtx,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
if eachVal.IsNull() {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic for_each value",
|
||||
Detail: "Cannot use a null value in for_each.",
|
||||
Subject: eachAttr.Expr.Range().Ptr(),
|
||||
Expression: eachAttr.Expr,
|
||||
EvalContext: b.forEachCtx,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
//// iterator attribute
|
||||
|
||||
iteratorName := blockS.Type
|
||||
if iteratorAttr := specContent.Attributes["iterator"]; iteratorAttr != nil {
|
||||
itTraversal, itDiags := hcl.AbsTraversalForExpr(iteratorAttr.Expr)
|
||||
diags = append(diags, itDiags...)
|
||||
if itDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
if len(itTraversal) != 1 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic iterator name",
|
||||
Detail: "Dynamic iterator must be a single variable name.",
|
||||
Subject: itTraversal.SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
iteratorName = itTraversal.RootName()
|
||||
}
|
||||
|
||||
var labelExprs []hcl.Expression
|
||||
if labelsAttr := specContent.Attributes["labels"]; labelsAttr != nil {
|
||||
var labelDiags hcl.Diagnostics
|
||||
labelExprs, labelDiags = hcl.ExprList(labelsAttr.Expr)
|
||||
diags = append(diags, labelDiags...)
|
||||
if labelDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
if len(labelExprs) > len(blockS.LabelNames) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Extraneous dynamic block label",
|
||||
Detail: fmt.Sprintf("Blocks of type %q require %d label(s).", blockS.Type, len(blockS.LabelNames)),
|
||||
Subject: labelExprs[len(blockS.LabelNames)].Range().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
} else if len(labelExprs) < len(blockS.LabelNames) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Insufficient dynamic block labels",
|
||||
Detail: fmt.Sprintf("Blocks of type %q require %d label(s).", blockS.Type, len(blockS.LabelNames)),
|
||||
Subject: labelsAttr.Expr.Range().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
}
|
||||
|
||||
// Since our schema requests only blocks of type "content", we can assume
|
||||
// that all entries in specContent.Blocks are content blocks.
|
||||
if len(specContent.Blocks) == 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing dynamic content block",
|
||||
Detail: "A dynamic block must have a nested block of type \"content\" to describe the body of each generated block.",
|
||||
Subject: &specContent.MissingItemRange,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
if len(specContent.Blocks) > 1 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Extraneous dynamic content block",
|
||||
Detail: "Only one nested content block is allowed for each dynamic block.",
|
||||
Subject: &specContent.Blocks[1].DefRange,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
return &expandSpec{
|
||||
blockType: blockS.Type,
|
||||
blockTypeRange: rawSpec.LabelRanges[0],
|
||||
defRange: rawSpec.DefRange,
|
||||
forEachVal: eachVal,
|
||||
iteratorName: iteratorName,
|
||||
labelExprs: labelExprs,
|
||||
contentBody: specContent.Blocks[0].Body,
|
||||
}, diags
|
||||
}
|
||||
|
||||
func (s *expandSpec) newBlock(i *iteration, ctx *hcl.EvalContext) (*hcl.Block, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
var labels []string
|
||||
var labelRanges []hcl.Range
|
||||
lCtx := i.EvalContext(ctx)
|
||||
for _, labelExpr := range s.labelExprs {
|
||||
labelVal, labelDiags := labelExpr.Value(lCtx)
|
||||
diags = append(diags, labelDiags...)
|
||||
if labelDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
var convErr error
|
||||
labelVal, convErr = convert.Convert(labelVal, cty.String)
|
||||
if convErr != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic block label",
|
||||
Detail: fmt.Sprintf("Cannot use this value as a dynamic block label: %s.", convErr),
|
||||
Subject: labelExpr.Range().Ptr(),
|
||||
Expression: labelExpr,
|
||||
EvalContext: lCtx,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
if labelVal.IsNull() {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic block label",
|
||||
Detail: "Cannot use a null value as a dynamic block label.",
|
||||
Subject: labelExpr.Range().Ptr(),
|
||||
Expression: labelExpr,
|
||||
EvalContext: lCtx,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
if !labelVal.IsKnown() {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid dynamic block label",
|
||||
Detail: "This value is not yet known. Dynamic block labels must be immediately-known values.",
|
||||
Subject: labelExpr.Range().Ptr(),
|
||||
Expression: labelExpr,
|
||||
EvalContext: lCtx,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
labels = append(labels, labelVal.AsString())
|
||||
labelRanges = append(labelRanges, labelExpr.Range())
|
||||
}
|
||||
|
||||
block := &hcl.Block{
|
||||
Type: s.blockType,
|
||||
TypeRange: s.blockTypeRange,
|
||||
Labels: labels,
|
||||
LabelRanges: labelRanges,
|
||||
DefRange: s.defRange,
|
||||
Body: s.contentBody,
|
||||
}
|
||||
|
||||
return block, diags
|
||||
}
|
||||
42
vendor/github.com/hashicorp/hcl2/ext/dynblock/expr_wrap.go
generated
vendored
Normal file
42
vendor/github.com/hashicorp/hcl2/ext/dynblock/expr_wrap.go
generated
vendored
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
type exprWrap struct {
|
||||
hcl.Expression
|
||||
i *iteration
|
||||
}
|
||||
|
||||
func (e exprWrap) Variables() []hcl.Traversal {
|
||||
raw := e.Expression.Variables()
|
||||
ret := make([]hcl.Traversal, 0, len(raw))
|
||||
|
||||
// Filter out traversals that refer to our iterator name or any
|
||||
// iterator we've inherited; we're going to provide those in
|
||||
// our Value wrapper, so the caller doesn't need to know about them.
|
||||
for _, traversal := range raw {
|
||||
rootName := traversal.RootName()
|
||||
if rootName == e.i.IteratorName {
|
||||
continue
|
||||
}
|
||||
if _, inherited := e.i.Inherited[rootName]; inherited {
|
||||
continue
|
||||
}
|
||||
ret = append(ret, traversal)
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func (e exprWrap) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
|
||||
extCtx := e.i.EvalContext(ctx)
|
||||
return e.Expression.Value(extCtx)
|
||||
}
|
||||
|
||||
// UnwrapExpression returns the expression being wrapped by this instance.
|
||||
// This allows the original expression to be recovered by hcl.UnwrapExpression.
|
||||
func (e exprWrap) UnwrapExpression() hcl.Expression {
|
||||
return e.Expression
|
||||
}
|
||||
64
vendor/github.com/hashicorp/hcl2/ext/dynblock/iteration.go
generated
vendored
Normal file
64
vendor/github.com/hashicorp/hcl2/ext/dynblock/iteration.go
generated
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
type iteration struct {
|
||||
IteratorName string
|
||||
Key cty.Value
|
||||
Value cty.Value
|
||||
Inherited map[string]*iteration
|
||||
}
|
||||
|
||||
func (s *expandSpec) MakeIteration(key, value cty.Value) *iteration {
|
||||
return &iteration{
|
||||
IteratorName: s.iteratorName,
|
||||
Key: key,
|
||||
Value: value,
|
||||
Inherited: s.inherited,
|
||||
}
|
||||
}
|
||||
|
||||
func (i *iteration) Object() cty.Value {
|
||||
return cty.ObjectVal(map[string]cty.Value{
|
||||
"key": i.Key,
|
||||
"value": i.Value,
|
||||
})
|
||||
}
|
||||
|
||||
func (i *iteration) EvalContext(base *hcl.EvalContext) *hcl.EvalContext {
|
||||
new := base.NewChild()
|
||||
new.Variables = map[string]cty.Value{}
|
||||
|
||||
for name, otherIt := range i.Inherited {
|
||||
new.Variables[name] = otherIt.Object()
|
||||
}
|
||||
new.Variables[i.IteratorName] = i.Object()
|
||||
|
||||
return new
|
||||
}
|
||||
|
||||
func (i *iteration) MakeChild(iteratorName string, key, value cty.Value) *iteration {
|
||||
if i == nil {
|
||||
// Create entirely new root iteration, then
|
||||
return &iteration{
|
||||
IteratorName: iteratorName,
|
||||
Key: key,
|
||||
Value: value,
|
||||
}
|
||||
}
|
||||
|
||||
inherited := map[string]*iteration{}
|
||||
for name, otherIt := range i.Inherited {
|
||||
inherited[name] = otherIt
|
||||
}
|
||||
inherited[i.IteratorName] = i
|
||||
return &iteration{
|
||||
IteratorName: iteratorName,
|
||||
Key: key,
|
||||
Value: value,
|
||||
Inherited: inherited,
|
||||
}
|
||||
}
|
||||
44
vendor/github.com/hashicorp/hcl2/ext/dynblock/public.go
generated
vendored
Normal file
44
vendor/github.com/hashicorp/hcl2/ext/dynblock/public.go
generated
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
// Expand "dynamic" blocks in the given body, returning a new body that
|
||||
// has those blocks expanded.
|
||||
//
|
||||
// The given EvalContext is used when evaluating "for_each" and "labels"
|
||||
// attributes within dynamic blocks, allowing those expressions access to
|
||||
// variables and functions beyond the iterator variable created by the
|
||||
// iteration.
|
||||
//
|
||||
// Expand returns no diagnostics because no blocks are actually expanded
|
||||
// until a call to Content or PartialContent on the returned body, which
|
||||
// will then expand only the blocks selected by the schema.
|
||||
//
|
||||
// "dynamic" blocks are also expanded automatically within nested blocks
|
||||
// in the given body, including within other dynamic blocks, thus allowing
|
||||
// multi-dimensional iteration. However, it is not possible to
|
||||
// dynamically-generate the "dynamic" blocks themselves except through nesting.
|
||||
//
|
||||
// parent {
|
||||
// dynamic "child" {
|
||||
// for_each = child_objs
|
||||
// content {
|
||||
// dynamic "grandchild" {
|
||||
// for_each = child.value.children
|
||||
// labels = [grandchild.key]
|
||||
// content {
|
||||
// parent_key = child.key
|
||||
// value = grandchild.value
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
func Expand(body hcl.Body, ctx *hcl.EvalContext) hcl.Body {
|
||||
return &expandBody{
|
||||
original: body,
|
||||
forEachCtx: ctx,
|
||||
}
|
||||
}
|
||||
50
vendor/github.com/hashicorp/hcl2/ext/dynblock/schema.go
generated
vendored
Normal file
50
vendor/github.com/hashicorp/hcl2/ext/dynblock/schema.go
generated
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
package dynblock
|
||||
|
||||
import "github.com/hashicorp/hcl2/hcl"
|
||||
|
||||
var dynamicBlockHeaderSchema = hcl.BlockHeaderSchema{
|
||||
Type: "dynamic",
|
||||
LabelNames: []string{"type"},
|
||||
}
|
||||
|
||||
var dynamicBlockBodySchemaLabels = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "for_each",
|
||||
Required: true,
|
||||
},
|
||||
{
|
||||
Name: "iterator",
|
||||
Required: false,
|
||||
},
|
||||
{
|
||||
Name: "labels",
|
||||
Required: true,
|
||||
},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "content",
|
||||
LabelNames: nil,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var dynamicBlockBodySchemaNoLabels = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "for_each",
|
||||
Required: true,
|
||||
},
|
||||
{
|
||||
Name: "iterator",
|
||||
Required: false,
|
||||
},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "content",
|
||||
LabelNames: nil,
|
||||
},
|
||||
},
|
||||
}
|
||||
165
vendor/github.com/hashicorp/hcl2/ext/dynblock/variables.go
generated
vendored
Normal file
165
vendor/github.com/hashicorp/hcl2/ext/dynblock/variables.go
generated
vendored
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// WalkVariables begins the recursive process of walking the variables in the
|
||||
// given body that are needed by any "for_each" or "labels" attributes in
|
||||
// "dynamic" blocks. The result is a WalkVariablesNode, which can extract
|
||||
// root-level variable traversals and produce a list of child nodes that
|
||||
// also need to be processed by calling Visit.
|
||||
//
|
||||
// This function requires that the caller walk through the nested block
|
||||
// structure in the given body level-by-level so that an appropriate schema
|
||||
// can be provided at each level to inform further processing. This workflow
|
||||
// is thus easiest to use for calling applications that have some higher-level
|
||||
// schema representation available with which to drive this multi-step
|
||||
// process.
|
||||
func WalkForEachVariables(body hcl.Body) WalkVariablesNode {
|
||||
return WalkVariablesNode{
|
||||
body: body,
|
||||
}
|
||||
}
|
||||
|
||||
type WalkVariablesNode struct {
|
||||
body hcl.Body
|
||||
it *iteration
|
||||
}
|
||||
|
||||
type WalkVariablesChild struct {
|
||||
BlockTypeName string
|
||||
Node WalkVariablesNode
|
||||
}
|
||||
|
||||
// Visit returns the variable traversals required for any "dynamic" blocks
|
||||
// directly in the body associated with this node, and also returns any child
|
||||
// nodes that must be visited in order to continue the walk.
|
||||
//
|
||||
// Each child node has its associated block type name given in its BlockTypeName
|
||||
// field, which the calling application should use to determine the appropriate
|
||||
// schema for the content of each child node and pass it to the child node's
|
||||
// own Visit method to continue the walk recursively.
|
||||
func (n WalkVariablesNode) Visit(schema *hcl.BodySchema) (vars []hcl.Traversal, children []WalkVariablesChild) {
|
||||
extSchema := n.extendSchema(schema)
|
||||
container, _, _ := n.body.PartialContent(extSchema)
|
||||
if container == nil {
|
||||
return vars, children
|
||||
}
|
||||
|
||||
children = make([]WalkVariablesChild, 0, len(container.Blocks))
|
||||
|
||||
for _, block := range container.Blocks {
|
||||
switch block.Type {
|
||||
|
||||
case "dynamic":
|
||||
blockTypeName := block.Labels[0]
|
||||
inner, _, _ := block.Body.PartialContent(variableDetectionInnerSchema)
|
||||
if inner == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
iteratorName := blockTypeName
|
||||
if attr, exists := inner.Attributes["iterator"]; exists {
|
||||
iterTraversal, _ := hcl.AbsTraversalForExpr(attr.Expr)
|
||||
if len(iterTraversal) == 0 {
|
||||
// Ignore this invalid dynamic block, since it'll produce
|
||||
// an error if someone tries to extract content from it
|
||||
// later anyway.
|
||||
continue
|
||||
}
|
||||
iteratorName = iterTraversal.RootName()
|
||||
}
|
||||
blockIt := n.it.MakeChild(iteratorName, cty.DynamicVal, cty.DynamicVal)
|
||||
|
||||
if attr, exists := inner.Attributes["for_each"]; exists {
|
||||
// Filter out iterator names inherited from parent blocks
|
||||
for _, traversal := range attr.Expr.Variables() {
|
||||
if _, inherited := blockIt.Inherited[traversal.RootName()]; !inherited {
|
||||
vars = append(vars, traversal)
|
||||
}
|
||||
}
|
||||
}
|
||||
if attr, exists := inner.Attributes["labels"]; exists {
|
||||
// Filter out both our own iterator name _and_ those inherited
|
||||
// from parent blocks, since we provide _both_ of these to the
|
||||
// label expressions.
|
||||
for _, traversal := range attr.Expr.Variables() {
|
||||
ours := traversal.RootName() == iteratorName
|
||||
_, inherited := blockIt.Inherited[traversal.RootName()]
|
||||
|
||||
if !(ours || inherited) {
|
||||
vars = append(vars, traversal)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for _, contentBlock := range inner.Blocks {
|
||||
// We only request "content" blocks in our schema, so we know
|
||||
// any blocks we find here will be content blocks. We require
|
||||
// exactly one content block for actual expansion, but we'll
|
||||
// be more liberal here so that callers can still collect
|
||||
// variables from erroneous "dynamic" blocks.
|
||||
children = append(children, WalkVariablesChild{
|
||||
BlockTypeName: blockTypeName,
|
||||
Node: WalkVariablesNode{
|
||||
body: contentBlock.Body,
|
||||
it: blockIt,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
default:
|
||||
children = append(children, WalkVariablesChild{
|
||||
BlockTypeName: block.Type,
|
||||
Node: WalkVariablesNode{
|
||||
body: block.Body,
|
||||
it: n.it,
|
||||
},
|
||||
})
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return vars, children
|
||||
}
|
||||
|
||||
func (n WalkVariablesNode) extendSchema(schema *hcl.BodySchema) *hcl.BodySchema {
|
||||
// We augment the requested schema to also include our special "dynamic"
|
||||
// block type, since then we'll get instances of it interleaved with
|
||||
// all of the literal child blocks we must also include.
|
||||
extSchema := &hcl.BodySchema{
|
||||
Attributes: schema.Attributes,
|
||||
Blocks: make([]hcl.BlockHeaderSchema, len(schema.Blocks), len(schema.Blocks)+1),
|
||||
}
|
||||
copy(extSchema.Blocks, schema.Blocks)
|
||||
extSchema.Blocks = append(extSchema.Blocks, dynamicBlockHeaderSchema)
|
||||
|
||||
return extSchema
|
||||
}
|
||||
|
||||
// This is a more relaxed schema than what's in schema.go, since we
|
||||
// want to maximize the amount of variables we can find even if there
|
||||
// are erroneous blocks.
|
||||
var variableDetectionInnerSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "for_each",
|
||||
Required: false,
|
||||
},
|
||||
{
|
||||
Name: "labels",
|
||||
Required: false,
|
||||
},
|
||||
{
|
||||
Name: "iterator",
|
||||
Required: false,
|
||||
},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "content",
|
||||
},
|
||||
},
|
||||
}
|
||||
33
vendor/github.com/hashicorp/hcl2/ext/dynblock/variables_hcldec.go
generated
vendored
Normal file
33
vendor/github.com/hashicorp/hcl2/ext/dynblock/variables_hcldec.go
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
package dynblock
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcldec"
|
||||
)
|
||||
|
||||
// ForEachVariablesHCLDec is a wrapper around WalkForEachVariables that
|
||||
// uses the given hcldec specification to automatically drive the recursive
|
||||
// walk through nested blocks in the given body.
|
||||
//
|
||||
// This provides more convenient access to all of the "for_each" and "labels"
|
||||
// dependencies in a body for applications that are already using hcldec
|
||||
// as a more convenient way to recursively decode body contents.
|
||||
func ForEachVariablesHCLDec(body hcl.Body, spec hcldec.Spec) []hcl.Traversal {
|
||||
rootNode := WalkForEachVariables(body)
|
||||
return walkVariablesWithHCLDec(rootNode, spec)
|
||||
}
|
||||
|
||||
func walkVariablesWithHCLDec(node WalkVariablesNode, spec hcldec.Spec) []hcl.Traversal {
|
||||
vars, children := node.Visit(hcldec.ImpliedSchema(spec))
|
||||
|
||||
if len(children) > 0 {
|
||||
childSpecs := hcldec.ChildBlockTypes(spec)
|
||||
for _, child := range children {
|
||||
if childSpec, exists := childSpecs[child.BlockTypeName]; exists {
|
||||
vars = append(vars, walkVariablesWithHCLDec(child.Node, childSpec)...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return vars
|
||||
}
|
||||
67
vendor/github.com/hashicorp/hcl2/ext/typeexpr/README.md
generated
vendored
Normal file
67
vendor/github.com/hashicorp/hcl2/ext/typeexpr/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
# HCL Type Expressions Extension
|
||||
|
||||
This HCL extension defines a convention for describing HCL types using function
|
||||
call and variable reference syntax, allowing configuration formats to include
|
||||
type information provided by users.
|
||||
|
||||
The type syntax is processed statically from a hcl.Expression, so it cannot
|
||||
use any of the usual language operators. This is similar to type expressions
|
||||
in statically-typed programming languages.
|
||||
|
||||
```hcl
|
||||
variable "example" {
|
||||
type = list(string)
|
||||
}
|
||||
```
|
||||
|
||||
The extension is built using the `hcl.ExprAsKeyword` and `hcl.ExprCall`
|
||||
functions, and so it relies on the underlying syntax to define how "keyword"
|
||||
and "call" are interpreted. The above shows how they are interpreted in
|
||||
the HCL native syntax, while the following shows the same information
|
||||
expressed in JSON:
|
||||
|
||||
```json
|
||||
{
|
||||
"variable": {
|
||||
"example": {
|
||||
"type": "list(string)"
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Notice that since we have additional contextual information that we intend
|
||||
to allow only calls and keywords the JSON syntax is able to parse the given
|
||||
string directly as an expression, rather than as a template as would be
|
||||
the case for normal expression evaluation.
|
||||
|
||||
For more information, see [the godoc reference](http://godoc.org/github.com/hashicorp/hcl2/ext/typeexpr).
|
||||
|
||||
## Type Expression Syntax
|
||||
|
||||
When expressed in the native syntax, the following expressions are permitted
|
||||
in a type expression:
|
||||
|
||||
* `string` - string
|
||||
* `bool` - boolean
|
||||
* `number` - number
|
||||
* `any` - `cty.DynamicPseudoType` (in function `TypeConstraint` only)
|
||||
* `list(<type_expr>)` - list of the type given as an argument
|
||||
* `set(<type_expr>)` - set of the type given as an argument
|
||||
* `map(<type_expr>)` - map of the type given as an argument
|
||||
* `tuple([<type_exprs...>])` - tuple with the element types given in the single list argument
|
||||
* `object({<attr_name>=<type_expr>, ...}` - object with the attributes and corresponding types given in the single map argument
|
||||
|
||||
For example:
|
||||
|
||||
* `list(string)`
|
||||
* `object({name=string,age=number})`
|
||||
* `map(object({name=string,age=number}))`
|
||||
|
||||
Note that the object constructor syntax is not fully-general for all possible
|
||||
object types because it requires the attribute names to be valid identifiers.
|
||||
In practice it is expected that any time an object type is being fixed for
|
||||
type checking it will be one that has identifiers as its attributes; object
|
||||
types with weird attributes generally show up only from arbitrary object
|
||||
constructors in configuration files, which are usually treated either as maps
|
||||
or as the dynamic pseudo-type.
|
||||
11
vendor/github.com/hashicorp/hcl2/ext/typeexpr/doc.go
generated
vendored
Normal file
11
vendor/github.com/hashicorp/hcl2/ext/typeexpr/doc.go
generated
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
// Package typeexpr extends HCL with a convention for describing HCL types
|
||||
// within configuration files.
|
||||
//
|
||||
// The type syntax is processed statically from a hcl.Expression, so it cannot
|
||||
// use any of the usual language operators. This is similar to type expressions
|
||||
// in statically-typed programming languages.
|
||||
//
|
||||
// variable "example" {
|
||||
// type = list(string)
|
||||
// }
|
||||
package typeexpr
|
||||
196
vendor/github.com/hashicorp/hcl2/ext/typeexpr/get_type.go
generated
vendored
Normal file
196
vendor/github.com/hashicorp/hcl2/ext/typeexpr/get_type.go
generated
vendored
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
package typeexpr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
const invalidTypeSummary = "Invalid type specification"
|
||||
|
||||
// getType is the internal implementation of both Type and TypeConstraint,
|
||||
// using the passed flag to distinguish. When constraint is false, the "any"
|
||||
// keyword will produce an error.
|
||||
func getType(expr hcl.Expression, constraint bool) (cty.Type, hcl.Diagnostics) {
|
||||
// First we'll try for one of our keywords
|
||||
kw := hcl.ExprAsKeyword(expr)
|
||||
switch kw {
|
||||
case "bool":
|
||||
return cty.Bool, nil
|
||||
case "string":
|
||||
return cty.String, nil
|
||||
case "number":
|
||||
return cty.Number, nil
|
||||
case "any":
|
||||
if constraint {
|
||||
return cty.DynamicPseudoType, nil
|
||||
}
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("The keyword %q cannot be used in this type specification: an exact type is required.", kw),
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
case "list", "map", "set":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("The %s type constructor requires one argument specifying the element type.", kw),
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
case "object":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "The object type constructor requires one argument specifying the attribute types and values as a map.",
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
case "tuple":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "The tuple type constructor requires one argument specifying the element types as a list.",
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
case "":
|
||||
// okay! we'll fall through and try processing as a call, then.
|
||||
default:
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("The keyword %q is not a valid type specification.", kw),
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
|
||||
// If we get down here then our expression isn't just a keyword, so we'll
|
||||
// try to process it as a call instead.
|
||||
call, diags := hcl.ExprCall(expr)
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "A type specification is either a primitive type keyword (bool, number, string) or a complex type constructor call, like list(string).",
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
|
||||
switch call.Name {
|
||||
case "bool", "string", "number", "any":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("Primitive type keyword %q does not expect arguments.", call.Name),
|
||||
Subject: &call.ArgsRange,
|
||||
}}
|
||||
}
|
||||
|
||||
if len(call.Arguments) != 1 {
|
||||
contextRange := call.ArgsRange
|
||||
subjectRange := call.ArgsRange
|
||||
if len(call.Arguments) > 1 {
|
||||
// If we have too many arguments (as opposed to too _few_) then
|
||||
// we'll highlight the extraneous arguments as the diagnostic
|
||||
// subject.
|
||||
subjectRange = hcl.RangeBetween(call.Arguments[1].Range(), call.Arguments[len(call.Arguments)-1].Range())
|
||||
}
|
||||
|
||||
switch call.Name {
|
||||
case "list", "set", "map":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("The %s type constructor requires one argument specifying the element type.", call.Name),
|
||||
Subject: &subjectRange,
|
||||
Context: &contextRange,
|
||||
}}
|
||||
case "object":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "The object type constructor requires one argument specifying the attribute types and values as a map.",
|
||||
Subject: &subjectRange,
|
||||
Context: &contextRange,
|
||||
}}
|
||||
case "tuple":
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "The tuple type constructor requires one argument specifying the element types as a list.",
|
||||
Subject: &subjectRange,
|
||||
Context: &contextRange,
|
||||
}}
|
||||
}
|
||||
}
|
||||
|
||||
switch call.Name {
|
||||
|
||||
case "list":
|
||||
ety, diags := getType(call.Arguments[0], constraint)
|
||||
return cty.List(ety), diags
|
||||
case "set":
|
||||
ety, diags := getType(call.Arguments[0], constraint)
|
||||
return cty.Set(ety), diags
|
||||
case "map":
|
||||
ety, diags := getType(call.Arguments[0], constraint)
|
||||
return cty.Map(ety), diags
|
||||
case "object":
|
||||
attrDefs, diags := hcl.ExprMap(call.Arguments[0])
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "Object type constructor requires a map whose keys are attribute names and whose values are the corresponding attribute types.",
|
||||
Subject: call.Arguments[0].Range().Ptr(),
|
||||
Context: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
|
||||
atys := make(map[string]cty.Type)
|
||||
for _, attrDef := range attrDefs {
|
||||
attrName := hcl.ExprAsKeyword(attrDef.Key)
|
||||
if attrName == "" {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "Object constructor map keys must be attribute names.",
|
||||
Subject: attrDef.Key.Range().Ptr(),
|
||||
Context: expr.Range().Ptr(),
|
||||
})
|
||||
continue
|
||||
}
|
||||
aty, attrDiags := getType(attrDef.Value, constraint)
|
||||
diags = append(diags, attrDiags...)
|
||||
atys[attrName] = aty
|
||||
}
|
||||
return cty.Object(atys), diags
|
||||
case "tuple":
|
||||
elemDefs, diags := hcl.ExprList(call.Arguments[0])
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: "Tuple type constructor requires a list of element types.",
|
||||
Subject: call.Arguments[0].Range().Ptr(),
|
||||
Context: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
etys := make([]cty.Type, len(elemDefs))
|
||||
for i, defExpr := range elemDefs {
|
||||
ety, elemDiags := getType(defExpr, constraint)
|
||||
diags = append(diags, elemDiags...)
|
||||
etys[i] = ety
|
||||
}
|
||||
return cty.Tuple(etys), diags
|
||||
default:
|
||||
// Can't access call.Arguments in this path because we've not validated
|
||||
// that it contains exactly one expression here.
|
||||
return cty.DynamicPseudoType, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: invalidTypeSummary,
|
||||
Detail: fmt.Sprintf("Keyword %q is not a valid type constructor.", call.Name),
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
}
|
||||
129
vendor/github.com/hashicorp/hcl2/ext/typeexpr/public.go
generated
vendored
Normal file
129
vendor/github.com/hashicorp/hcl2/ext/typeexpr/public.go
generated
vendored
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
package typeexpr
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"sort"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// Type attempts to process the given expression as a type expression and, if
|
||||
// successful, returns the resulting type. If unsuccessful, error diagnostics
|
||||
// are returned.
|
||||
func Type(expr hcl.Expression) (cty.Type, hcl.Diagnostics) {
|
||||
return getType(expr, false)
|
||||
}
|
||||
|
||||
// TypeConstraint attempts to parse the given expression as a type constraint
|
||||
// and, if successful, returns the resulting type. If unsuccessful, error
|
||||
// diagnostics are returned.
|
||||
//
|
||||
// A type constraint has the same structure as a type, but it additionally
|
||||
// allows the keyword "any" to represent cty.DynamicPseudoType, which is often
|
||||
// used as a wildcard in type checking and type conversion operations.
|
||||
func TypeConstraint(expr hcl.Expression) (cty.Type, hcl.Diagnostics) {
|
||||
return getType(expr, true)
|
||||
}
|
||||
|
||||
// TypeString returns a string rendering of the given type as it would be
|
||||
// expected to appear in the HCL native syntax.
|
||||
//
|
||||
// This is primarily intended for showing types to the user in an application
|
||||
// that uses typexpr, where the user can be assumed to be familiar with the
|
||||
// type expression syntax. In applications that do not use typeexpr these
|
||||
// results may be confusing to the user and so type.FriendlyName may be
|
||||
// preferable, even though it's less precise.
|
||||
//
|
||||
// TypeString produces reasonable results only for types like what would be
|
||||
// produced by the Type and TypeConstraint functions. In particular, it cannot
|
||||
// support capsule types.
|
||||
func TypeString(ty cty.Type) string {
|
||||
// Easy cases first
|
||||
switch ty {
|
||||
case cty.String:
|
||||
return "string"
|
||||
case cty.Bool:
|
||||
return "bool"
|
||||
case cty.Number:
|
||||
return "number"
|
||||
case cty.DynamicPseudoType:
|
||||
return "any"
|
||||
}
|
||||
|
||||
if ty.IsCapsuleType() {
|
||||
panic("TypeString does not support capsule types")
|
||||
}
|
||||
|
||||
if ty.IsCollectionType() {
|
||||
ety := ty.ElementType()
|
||||
etyString := TypeString(ety)
|
||||
switch {
|
||||
case ty.IsListType():
|
||||
return fmt.Sprintf("list(%s)", etyString)
|
||||
case ty.IsSetType():
|
||||
return fmt.Sprintf("set(%s)", etyString)
|
||||
case ty.IsMapType():
|
||||
return fmt.Sprintf("map(%s)", etyString)
|
||||
default:
|
||||
// Should never happen because the above is exhaustive
|
||||
panic("unsupported collection type")
|
||||
}
|
||||
}
|
||||
|
||||
if ty.IsObjectType() {
|
||||
var buf bytes.Buffer
|
||||
buf.WriteString("object({")
|
||||
atys := ty.AttributeTypes()
|
||||
names := make([]string, 0, len(atys))
|
||||
for name := range atys {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
first := true
|
||||
for _, name := range names {
|
||||
aty := atys[name]
|
||||
if !first {
|
||||
buf.WriteByte(',')
|
||||
}
|
||||
if !hclsyntax.ValidIdentifier(name) {
|
||||
// Should never happen for any type produced by this package,
|
||||
// but we'll do something reasonable here just so we don't
|
||||
// produce garbage if someone gives us a hand-assembled object
|
||||
// type that has weird attribute names.
|
||||
// Using Go-style quoting here isn't perfect, since it doesn't
|
||||
// exactly match HCL syntax, but it's fine for an edge-case.
|
||||
buf.WriteString(fmt.Sprintf("%q", name))
|
||||
} else {
|
||||
buf.WriteString(name)
|
||||
}
|
||||
buf.WriteByte('=')
|
||||
buf.WriteString(TypeString(aty))
|
||||
first = false
|
||||
}
|
||||
buf.WriteString("})")
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
if ty.IsTupleType() {
|
||||
var buf bytes.Buffer
|
||||
buf.WriteString("tuple([")
|
||||
etys := ty.TupleElementTypes()
|
||||
first := true
|
||||
for _, ety := range etys {
|
||||
if !first {
|
||||
buf.WriteByte(',')
|
||||
}
|
||||
buf.WriteString(TypeString(ety))
|
||||
first = false
|
||||
}
|
||||
buf.WriteString("])")
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// Should never happen because we covered all cases above.
|
||||
panic(fmt.Errorf("unsupported type %#v", ty))
|
||||
}
|
||||
12
vendor/github.com/hashicorp/terraform/addrs/count_attr.go
generated
vendored
Normal file
12
vendor/github.com/hashicorp/terraform/addrs/count_attr.go
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
package addrs
|
||||
|
||||
// CountAttr is the address of an attribute of the "count" object in
|
||||
// the interpolation scope, like "count.index".
|
||||
type CountAttr struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (ca CountAttr) String() string {
|
||||
return "count." + ca.Name
|
||||
}
|
||||
17
vendor/github.com/hashicorp/terraform/addrs/doc.go
generated
vendored
Normal file
17
vendor/github.com/hashicorp/terraform/addrs/doc.go
generated
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
// Package addrs contains types that represent "addresses", which are
|
||||
// references to specific objects within a Terraform configuration or
|
||||
// state.
|
||||
//
|
||||
// All addresses have string representations based on HCL traversal syntax
|
||||
// which should be used in the user-interface, and also in-memory
|
||||
// representations that can be used internally.
|
||||
//
|
||||
// For object types that exist within Terraform modules a pair of types is
|
||||
// used. The "local" part of the address is represented by a type, and then
|
||||
// an absolute path to that object in the context of its module is represented
|
||||
// by a type of the same name with an "Abs" prefix added, for "absolute".
|
||||
//
|
||||
// All types within this package should be treated as immutable, even if this
|
||||
// is not enforced by the Go compiler. It is always an implementation error
|
||||
// to modify an address object in-place after it is initially constructed.
|
||||
package addrs
|
||||
41
vendor/github.com/hashicorp/terraform/addrs/input_variable.go
generated
vendored
Normal file
41
vendor/github.com/hashicorp/terraform/addrs/input_variable.go
generated
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// InputVariable is the address of an input variable.
|
||||
type InputVariable struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (v InputVariable) String() string {
|
||||
return "var." + v.Name
|
||||
}
|
||||
|
||||
// AbsInputVariableInstance is the address of an input variable within a
|
||||
// particular module instance.
|
||||
type AbsInputVariableInstance struct {
|
||||
Module ModuleInstance
|
||||
Variable InputVariable
|
||||
}
|
||||
|
||||
// InputVariable returns the absolute address of the input variable of the
|
||||
// given name inside the receiving module instance.
|
||||
func (m ModuleInstance) InputVariable(name string) AbsInputVariableInstance {
|
||||
return AbsInputVariableInstance{
|
||||
Module: m,
|
||||
Variable: InputVariable{
|
||||
Name: name,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (v AbsInputVariableInstance) String() string {
|
||||
if len(v.Module) == 0 {
|
||||
return v.String()
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%s.%s", v.Module.String(), v.Variable.String())
|
||||
}
|
||||
123
vendor/github.com/hashicorp/terraform/addrs/instance_key.go
generated
vendored
Normal file
123
vendor/github.com/hashicorp/terraform/addrs/instance_key.go
generated
vendored
Normal file
|
|
@ -0,0 +1,123 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/gocty"
|
||||
)
|
||||
|
||||
// InstanceKey represents the key of an instance within an object that
|
||||
// contains multiple instances due to using "count" or "for_each" arguments
|
||||
// in configuration.
|
||||
//
|
||||
// IntKey and StringKey are the two implementations of this type. No other
|
||||
// implementations are allowed. The single instance of an object that _isn't_
|
||||
// using "count" or "for_each" is represented by NoKey, which is a nil
|
||||
// InstanceKey.
|
||||
type InstanceKey interface {
|
||||
instanceKeySigil()
|
||||
String() string
|
||||
}
|
||||
|
||||
// ParseInstanceKey returns the instance key corresponding to the given value,
|
||||
// which must be known and non-null.
|
||||
//
|
||||
// If an unknown or null value is provided then this function will panic. This
|
||||
// function is intended to deal with the values that would naturally be found
|
||||
// in a hcl.TraverseIndex, which (when parsed from source, at least) can never
|
||||
// contain unknown or null values.
|
||||
func ParseInstanceKey(key cty.Value) (InstanceKey, error) {
|
||||
switch key.Type() {
|
||||
case cty.String:
|
||||
return StringKey(key.AsString()), nil
|
||||
case cty.Number:
|
||||
var idx int
|
||||
err := gocty.FromCtyValue(key, &idx)
|
||||
return IntKey(idx), err
|
||||
default:
|
||||
return NoKey, fmt.Errorf("either a string or an integer is required")
|
||||
}
|
||||
}
|
||||
|
||||
// NoKey represents the absense of an InstanceKey, for the single instance
|
||||
// of a configuration object that does not use "count" or "for_each" at all.
|
||||
var NoKey InstanceKey
|
||||
|
||||
// IntKey is the InstanceKey representation representing integer indices, as
|
||||
// used when the "count" argument is specified or if for_each is used with
|
||||
// a sequence type.
|
||||
type IntKey int
|
||||
|
||||
func (k IntKey) instanceKeySigil() {
|
||||
}
|
||||
|
||||
func (k IntKey) String() string {
|
||||
return fmt.Sprintf("[%d]", int(k))
|
||||
}
|
||||
|
||||
// StringKey is the InstanceKey representation representing string indices, as
|
||||
// used when the "for_each" argument is specified with a map or object type.
|
||||
type StringKey string
|
||||
|
||||
func (k StringKey) instanceKeySigil() {
|
||||
}
|
||||
|
||||
func (k StringKey) String() string {
|
||||
// FIXME: This isn't _quite_ right because Go's quoted string syntax is
|
||||
// slightly different than HCL's, but we'll accept it for now.
|
||||
return fmt.Sprintf("[%q]", string(k))
|
||||
}
|
||||
|
||||
// InstanceKeyLess returns true if the first given instance key i should sort
|
||||
// before the second key j, and false otherwise.
|
||||
func InstanceKeyLess(i, j InstanceKey) bool {
|
||||
iTy := instanceKeyType(i)
|
||||
jTy := instanceKeyType(j)
|
||||
|
||||
switch {
|
||||
case i == j:
|
||||
return false
|
||||
case i == NoKey:
|
||||
return true
|
||||
case j == NoKey:
|
||||
return false
|
||||
case iTy != jTy:
|
||||
// The ordering here is arbitrary except that we want NoKeyType
|
||||
// to sort before the others, so we'll just use the enum values
|
||||
// of InstanceKeyType here (where NoKey is zero, sorting before
|
||||
// any other).
|
||||
return uint32(iTy) < uint32(jTy)
|
||||
case iTy == IntKeyType:
|
||||
return int(i.(IntKey)) < int(j.(IntKey))
|
||||
case iTy == StringKeyType:
|
||||
return string(i.(StringKey)) < string(j.(StringKey))
|
||||
default:
|
||||
// Shouldn't be possible to get down here in practice, since the
|
||||
// above is exhaustive.
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func instanceKeyType(k InstanceKey) InstanceKeyType {
|
||||
if _, ok := k.(StringKey); ok {
|
||||
return StringKeyType
|
||||
}
|
||||
if _, ok := k.(IntKey); ok {
|
||||
return IntKeyType
|
||||
}
|
||||
return NoKeyType
|
||||
}
|
||||
|
||||
// InstanceKeyType represents the different types of instance key that are
|
||||
// supported. Usually it is sufficient to simply type-assert an InstanceKey
|
||||
// value to either IntKey or StringKey, but this type and its values can be
|
||||
// used to represent the types themselves, rather than specific values
|
||||
// of those types.
|
||||
type InstanceKeyType rune
|
||||
|
||||
const (
|
||||
NoKeyType InstanceKeyType = 0
|
||||
IntKeyType InstanceKeyType = 'I'
|
||||
StringKeyType InstanceKeyType = 'S'
|
||||
)
|
||||
48
vendor/github.com/hashicorp/terraform/addrs/local_value.go
generated
vendored
Normal file
48
vendor/github.com/hashicorp/terraform/addrs/local_value.go
generated
vendored
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// LocalValue is the address of a local value.
|
||||
type LocalValue struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (v LocalValue) String() string {
|
||||
return "local." + v.Name
|
||||
}
|
||||
|
||||
// Absolute converts the receiver into an absolute address within the given
|
||||
// module instance.
|
||||
func (v LocalValue) Absolute(m ModuleInstance) AbsLocalValue {
|
||||
return AbsLocalValue{
|
||||
Module: m,
|
||||
LocalValue: v,
|
||||
}
|
||||
}
|
||||
|
||||
// AbsLocalValue is the absolute address of a local value within a module instance.
|
||||
type AbsLocalValue struct {
|
||||
Module ModuleInstance
|
||||
LocalValue LocalValue
|
||||
}
|
||||
|
||||
// LocalValue returns the absolute address of a local value of the given
|
||||
// name within the receiving module instance.
|
||||
func (m ModuleInstance) LocalValue(name string) AbsLocalValue {
|
||||
return AbsLocalValue{
|
||||
Module: m,
|
||||
LocalValue: LocalValue{
|
||||
Name: name,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (v AbsLocalValue) String() string {
|
||||
if len(v.Module) == 0 {
|
||||
return v.LocalValue.String()
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", v.Module.String(), v.LocalValue.String())
|
||||
}
|
||||
75
vendor/github.com/hashicorp/terraform/addrs/module.go
generated
vendored
Normal file
75
vendor/github.com/hashicorp/terraform/addrs/module.go
generated
vendored
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Module is an address for a module call within configuration. This is
|
||||
// the static counterpart of ModuleInstance, representing a traversal through
|
||||
// the static module call tree in configuration and does not take into account
|
||||
// the potentially-multiple instances of a module that might be created by
|
||||
// "count" and "for_each" arguments within those calls.
|
||||
//
|
||||
// This type should be used only in very specialized cases when working with
|
||||
// the static module call tree. Type ModuleInstance is appropriate in more cases.
|
||||
//
|
||||
// Although Module is a slice, it should be treated as immutable after creation.
|
||||
type Module []string
|
||||
|
||||
// RootModule is the module address representing the root of the static module
|
||||
// call tree, which is also the zero value of Module.
|
||||
//
|
||||
// Note that this is not the root of the dynamic module tree, which is instead
|
||||
// represented by RootModuleInstance.
|
||||
var RootModule Module
|
||||
|
||||
// IsRoot returns true if the receiver is the address of the root module,
|
||||
// or false otherwise.
|
||||
func (m Module) IsRoot() bool {
|
||||
return len(m) == 0
|
||||
}
|
||||
|
||||
func (m Module) String() string {
|
||||
if len(m) == 0 {
|
||||
return ""
|
||||
}
|
||||
return strings.Join([]string(m), ".")
|
||||
}
|
||||
|
||||
// Child returns the address of a child call in the receiver, identified by the
|
||||
// given name.
|
||||
func (m Module) Child(name string) Module {
|
||||
ret := make(Module, 0, len(m)+1)
|
||||
ret = append(ret, m...)
|
||||
return append(ret, name)
|
||||
}
|
||||
|
||||
// Parent returns the address of the parent module of the receiver, or the
|
||||
// receiver itself if there is no parent (if it's the root module address).
|
||||
func (m Module) Parent() Module {
|
||||
if len(m) == 0 {
|
||||
return m
|
||||
}
|
||||
return m[:len(m)-1]
|
||||
}
|
||||
|
||||
// Call returns the module call address that corresponds to the given module
|
||||
// instance, along with the address of the module that contains it.
|
||||
//
|
||||
// There is no call for the root module, so this method will panic if called
|
||||
// on the root module address.
|
||||
//
|
||||
// In practice, this just turns the last element of the receiver into a
|
||||
// ModuleCall and then returns a slice of the receiever that excludes that
|
||||
// last part. This is just a convenience for situations where a call address
|
||||
// is required, such as when dealing with *Reference and Referencable values.
|
||||
func (m Module) Call() (Module, ModuleCall) {
|
||||
if len(m) == 0 {
|
||||
panic("cannot produce ModuleCall for root module")
|
||||
}
|
||||
|
||||
caller, callName := m[:len(m)-1], m[len(m)-1]
|
||||
return caller, ModuleCall{
|
||||
Name: callName,
|
||||
}
|
||||
}
|
||||
81
vendor/github.com/hashicorp/terraform/addrs/module_call.go
generated
vendored
Normal file
81
vendor/github.com/hashicorp/terraform/addrs/module_call.go
generated
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// ModuleCall is the address of a call from the current module to a child
|
||||
// module.
|
||||
//
|
||||
// There is no "Abs" version of ModuleCall because an absolute module path
|
||||
// is represented by ModuleInstance.
|
||||
type ModuleCall struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (c ModuleCall) String() string {
|
||||
return "module." + c.Name
|
||||
}
|
||||
|
||||
// Instance returns the address of an instance of the receiver identified by
|
||||
// the given key.
|
||||
func (c ModuleCall) Instance(key InstanceKey) ModuleCallInstance {
|
||||
return ModuleCallInstance{
|
||||
Call: c,
|
||||
Key: key,
|
||||
}
|
||||
}
|
||||
|
||||
// ModuleCallInstance is the address of one instance of a module created from
|
||||
// a module call, which might create multiple instances using "count" or
|
||||
// "for_each" arguments.
|
||||
type ModuleCallInstance struct {
|
||||
referenceable
|
||||
Call ModuleCall
|
||||
Key InstanceKey
|
||||
}
|
||||
|
||||
func (c ModuleCallInstance) String() string {
|
||||
if c.Key == NoKey {
|
||||
return c.Call.String()
|
||||
}
|
||||
return fmt.Sprintf("module.%s%s", c.Call.Name, c.Key)
|
||||
}
|
||||
|
||||
// ModuleInstance returns the address of the module instance that corresponds
|
||||
// to the receiving call instance when resolved in the given calling module.
|
||||
// In other words, it returns the child module instance that the receving
|
||||
// call instance creates.
|
||||
func (c ModuleCallInstance) ModuleInstance(caller ModuleInstance) ModuleInstance {
|
||||
return caller.Child(c.Call.Name, c.Key)
|
||||
}
|
||||
|
||||
// Output returns the address of an output of the receiver identified by its
|
||||
// name.
|
||||
func (c ModuleCallInstance) Output(name string) ModuleCallOutput {
|
||||
return ModuleCallOutput{
|
||||
Call: c,
|
||||
Name: name,
|
||||
}
|
||||
}
|
||||
|
||||
// ModuleCallOutput is the address of a particular named output produced by
|
||||
// an instance of a module call.
|
||||
type ModuleCallOutput struct {
|
||||
referenceable
|
||||
Call ModuleCallInstance
|
||||
Name string
|
||||
}
|
||||
|
||||
func (co ModuleCallOutput) String() string {
|
||||
return fmt.Sprintf("%s.%s", co.Call.String(), co.Name)
|
||||
}
|
||||
|
||||
// AbsOutputValue returns the absolute output value address that corresponds
|
||||
// to the receving module call output address, once resolved in the given
|
||||
// calling module.
|
||||
func (co ModuleCallOutput) AbsOutputValue(caller ModuleInstance) AbsOutputValue {
|
||||
moduleAddr := co.Call.ModuleInstance(caller)
|
||||
return moduleAddr.OutputValue(co.Name)
|
||||
}
|
||||
415
vendor/github.com/hashicorp/terraform/addrs/module_instance.go
generated
vendored
Normal file
415
vendor/github.com/hashicorp/terraform/addrs/module_instance.go
generated
vendored
Normal file
|
|
@ -0,0 +1,415 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/gocty"
|
||||
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// ModuleInstance is an address for a particular module instance within the
|
||||
// dynamic module tree. This is an extension of the static traversals
|
||||
// represented by type Module that deals with the possibility of a single
|
||||
// module call producing multiple instances via the "count" and "for_each"
|
||||
// arguments.
|
||||
//
|
||||
// Although ModuleInstance is a slice, it should be treated as immutable after
|
||||
// creation.
|
||||
type ModuleInstance []ModuleInstanceStep
|
||||
|
||||
var (
|
||||
_ Targetable = ModuleInstance(nil)
|
||||
)
|
||||
|
||||
func ParseModuleInstance(traversal hcl.Traversal) (ModuleInstance, tfdiags.Diagnostics) {
|
||||
mi, remain, diags := parseModuleInstancePrefix(traversal)
|
||||
if len(remain) != 0 {
|
||||
if len(remain) == len(traversal) {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid module instance address",
|
||||
Detail: "A module instance address must begin with \"module.\".",
|
||||
Subject: remain.SourceRange().Ptr(),
|
||||
})
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid module instance address",
|
||||
Detail: "The module instance address is followed by additional invalid content.",
|
||||
Subject: remain.SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
}
|
||||
return mi, diags
|
||||
}
|
||||
|
||||
// ParseModuleInstanceStr is a helper wrapper around ParseModuleInstance
|
||||
// that takes a string and parses it with the HCL native syntax traversal parser
|
||||
// before interpreting it.
|
||||
//
|
||||
// This should be used only in specialized situations since it will cause the
|
||||
// created references to not have any meaningful source location information.
|
||||
// If a reference string is coming from a source that should be identified in
|
||||
// error messages then the caller should instead parse it directly using a
|
||||
// suitable function from the HCL API and pass the traversal itself to
|
||||
// ParseProviderConfigCompact.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// then the returned address is invalid.
|
||||
func ParseModuleInstanceStr(str string) (ModuleInstance, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
addr, addrDiags := ParseModuleInstance(traversal)
|
||||
diags = diags.Append(addrDiags)
|
||||
return addr, diags
|
||||
}
|
||||
|
||||
func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Traversal, tfdiags.Diagnostics) {
|
||||
remain := traversal
|
||||
var mi ModuleInstance
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
for len(remain) > 0 {
|
||||
var next string
|
||||
switch tt := remain[0].(type) {
|
||||
case hcl.TraverseRoot:
|
||||
next = tt.Name
|
||||
case hcl.TraverseAttr:
|
||||
next = tt.Name
|
||||
default:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address operator",
|
||||
Detail: "Module address prefix must be followed by dot and then a name.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
if next != "module" {
|
||||
break
|
||||
}
|
||||
|
||||
kwRange := remain[0].SourceRange()
|
||||
remain = remain[1:]
|
||||
// If we have the prefix "module" then we should be followed by an
|
||||
// module call name, as an attribute, and then optionally an index step
|
||||
// giving the instance key.
|
||||
if len(remain) == 0 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address operator",
|
||||
Detail: "Prefix \"module.\" must be followed by a module name.",
|
||||
Subject: &kwRange,
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
var moduleName string
|
||||
switch tt := remain[0].(type) {
|
||||
case hcl.TraverseAttr:
|
||||
moduleName = tt.Name
|
||||
default:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address operator",
|
||||
Detail: "Prefix \"module.\" must be followed by a module name.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
break
|
||||
}
|
||||
remain = remain[1:]
|
||||
step := ModuleInstanceStep{
|
||||
Name: moduleName,
|
||||
}
|
||||
|
||||
if len(remain) > 0 {
|
||||
if idx, ok := remain[0].(hcl.TraverseIndex); ok {
|
||||
remain = remain[1:]
|
||||
|
||||
switch idx.Key.Type() {
|
||||
case cty.String:
|
||||
step.InstanceKey = StringKey(idx.Key.AsString())
|
||||
case cty.Number:
|
||||
var idxInt int
|
||||
err := gocty.FromCtyValue(idx.Key, &idxInt)
|
||||
if err == nil {
|
||||
step.InstanceKey = IntKey(idxInt)
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address operator",
|
||||
Detail: fmt.Sprintf("Invalid module index: %s.", err),
|
||||
Subject: idx.SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
default:
|
||||
// Should never happen, because no other types are allowed in traversal indices.
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address operator",
|
||||
Detail: "Invalid module key: must be either a string or an integer.",
|
||||
Subject: idx.SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mi = append(mi, step)
|
||||
}
|
||||
|
||||
var retRemain hcl.Traversal
|
||||
if len(remain) > 0 {
|
||||
retRemain = make(hcl.Traversal, len(remain))
|
||||
copy(retRemain, remain)
|
||||
// The first element here might be either a TraverseRoot or a
|
||||
// TraverseAttr, depending on whether we had a module address on the
|
||||
// front. To make life easier for callers, we'll normalize to always
|
||||
// start with a TraverseRoot.
|
||||
if tt, ok := retRemain[0].(hcl.TraverseAttr); ok {
|
||||
retRemain[0] = hcl.TraverseRoot{
|
||||
Name: tt.Name,
|
||||
SrcRange: tt.SrcRange,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return mi, retRemain, diags
|
||||
}
|
||||
|
||||
// UnkeyedInstanceShim is a shim method for converting a Module address to the
|
||||
// equivalent ModuleInstance address that assumes that no modules have
|
||||
// keyed instances.
|
||||
//
|
||||
// This is a temporary allowance for the fact that Terraform does not presently
|
||||
// support "count" and "for_each" on modules, and thus graph building code that
|
||||
// derives graph nodes from configuration must just assume unkeyed modules
|
||||
// in order to construct the graph. At a later time when "count" and "for_each"
|
||||
// support is added for modules, all callers of this method will need to be
|
||||
// reworked to allow for keyed module instances.
|
||||
func (m Module) UnkeyedInstanceShim() ModuleInstance {
|
||||
path := make(ModuleInstance, len(m))
|
||||
for i, name := range m {
|
||||
path[i] = ModuleInstanceStep{Name: name}
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
// ModuleInstanceStep is a single traversal step through the dynamic module
|
||||
// tree. It is used only as part of ModuleInstance.
|
||||
type ModuleInstanceStep struct {
|
||||
Name string
|
||||
InstanceKey InstanceKey
|
||||
}
|
||||
|
||||
// RootModuleInstance is the module instance address representing the root
|
||||
// module, which is also the zero value of ModuleInstance.
|
||||
var RootModuleInstance ModuleInstance
|
||||
|
||||
// IsRoot returns true if the receiver is the address of the root module instance,
|
||||
// or false otherwise.
|
||||
func (m ModuleInstance) IsRoot() bool {
|
||||
return len(m) == 0
|
||||
}
|
||||
|
||||
// Child returns the address of a child module instance of the receiver,
|
||||
// identified by the given name and key.
|
||||
func (m ModuleInstance) Child(name string, key InstanceKey) ModuleInstance {
|
||||
ret := make(ModuleInstance, 0, len(m)+1)
|
||||
ret = append(ret, m...)
|
||||
return append(ret, ModuleInstanceStep{
|
||||
Name: name,
|
||||
InstanceKey: key,
|
||||
})
|
||||
}
|
||||
|
||||
// Parent returns the address of the parent module instance of the receiver, or
|
||||
// the receiver itself if there is no parent (if it's the root module address).
|
||||
func (m ModuleInstance) Parent() ModuleInstance {
|
||||
if len(m) == 0 {
|
||||
return m
|
||||
}
|
||||
return m[:len(m)-1]
|
||||
}
|
||||
|
||||
// String returns a string representation of the receiver, in the format used
|
||||
// within e.g. user-provided resource addresses.
|
||||
//
|
||||
// The address of the root module has the empty string as its representation.
|
||||
func (m ModuleInstance) String() string {
|
||||
var buf bytes.Buffer
|
||||
sep := ""
|
||||
for _, step := range m {
|
||||
buf.WriteString(sep)
|
||||
buf.WriteString("module.")
|
||||
buf.WriteString(step.Name)
|
||||
if step.InstanceKey != NoKey {
|
||||
buf.WriteString(step.InstanceKey.String())
|
||||
}
|
||||
sep = "."
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// Equal returns true if the receiver and the given other value
|
||||
// contains the exact same parts.
|
||||
func (m ModuleInstance) Equal(o ModuleInstance) bool {
|
||||
return m.String() == o.String()
|
||||
}
|
||||
|
||||
// Less returns true if the receiver should sort before the given other value
|
||||
// in a sorted list of addresses.
|
||||
func (m ModuleInstance) Less(o ModuleInstance) bool {
|
||||
if len(m) != len(o) {
|
||||
// Shorter path sorts first.
|
||||
return len(m) < len(o)
|
||||
}
|
||||
|
||||
for i := range m {
|
||||
mS, oS := m[i], o[i]
|
||||
switch {
|
||||
case mS.Name != oS.Name:
|
||||
return mS.Name < oS.Name
|
||||
case mS.InstanceKey != oS.InstanceKey:
|
||||
return InstanceKeyLess(mS.InstanceKey, oS.InstanceKey)
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// Ancestors returns a slice containing the receiver and all of its ancestor
|
||||
// module instances, all the way up to (and including) the root module.
|
||||
// The result is ordered by depth, with the root module always first.
|
||||
//
|
||||
// Since the result always includes the root module, a caller may choose to
|
||||
// ignore it by slicing the result with [1:].
|
||||
func (m ModuleInstance) Ancestors() []ModuleInstance {
|
||||
ret := make([]ModuleInstance, 0, len(m)+1)
|
||||
for i := 0; i <= len(m); i++ {
|
||||
ret = append(ret, m[:i])
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// IsAncestor returns true if the receiver is an ancestor of the given
|
||||
// other value.
|
||||
func (m ModuleInstance) IsAncestor(o ModuleInstance) bool {
|
||||
// Longer or equal sized paths means the receiver cannot
|
||||
// be an ancestor of the given module insatnce.
|
||||
if len(m) >= len(o) {
|
||||
return false
|
||||
}
|
||||
|
||||
for i, ms := range m {
|
||||
if ms.Name != o[i].Name {
|
||||
return false
|
||||
}
|
||||
if ms.InstanceKey != NoKey && ms.InstanceKey != o[i].InstanceKey {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Call returns the module call address that corresponds to the given module
|
||||
// instance, along with the address of the module instance that contains it.
|
||||
//
|
||||
// There is no call for the root module, so this method will panic if called
|
||||
// on the root module address.
|
||||
//
|
||||
// A single module call can produce potentially many module instances, so the
|
||||
// result discards any instance key that might be present on the last step
|
||||
// of the instance. To retain this, use CallInstance instead.
|
||||
//
|
||||
// In practice, this just turns the last element of the receiver into a
|
||||
// ModuleCall and then returns a slice of the receiever that excludes that
|
||||
// last part. This is just a convenience for situations where a call address
|
||||
// is required, such as when dealing with *Reference and Referencable values.
|
||||
func (m ModuleInstance) Call() (ModuleInstance, ModuleCall) {
|
||||
if len(m) == 0 {
|
||||
panic("cannot produce ModuleCall for root module")
|
||||
}
|
||||
|
||||
inst, lastStep := m[:len(m)-1], m[len(m)-1]
|
||||
return inst, ModuleCall{
|
||||
Name: lastStep.Name,
|
||||
}
|
||||
}
|
||||
|
||||
// CallInstance returns the module call instance address that corresponds to
|
||||
// the given module instance, along with the address of the module instance
|
||||
// that contains it.
|
||||
//
|
||||
// There is no call for the root module, so this method will panic if called
|
||||
// on the root module address.
|
||||
//
|
||||
// In practice, this just turns the last element of the receiver into a
|
||||
// ModuleCallInstance and then returns a slice of the receiever that excludes
|
||||
// that last part. This is just a convenience for situations where a call\
|
||||
// address is required, such as when dealing with *Reference and Referencable
|
||||
// values.
|
||||
func (m ModuleInstance) CallInstance() (ModuleInstance, ModuleCallInstance) {
|
||||
if len(m) == 0 {
|
||||
panic("cannot produce ModuleCallInstance for root module")
|
||||
}
|
||||
|
||||
inst, lastStep := m[:len(m)-1], m[len(m)-1]
|
||||
return inst, ModuleCallInstance{
|
||||
Call: ModuleCall{
|
||||
Name: lastStep.Name,
|
||||
},
|
||||
Key: lastStep.InstanceKey,
|
||||
}
|
||||
}
|
||||
|
||||
// TargetContains implements Targetable by returning true if the given other
|
||||
// address either matches the receiver, is a sub-module-instance of the
|
||||
// receiver, or is a targetable absolute address within a module that
|
||||
// is contained within the reciever.
|
||||
func (m ModuleInstance) TargetContains(other Targetable) bool {
|
||||
switch to := other.(type) {
|
||||
|
||||
case ModuleInstance:
|
||||
if len(to) < len(m) {
|
||||
// Can't be contained if the path is shorter
|
||||
return false
|
||||
}
|
||||
// Other is contained if its steps match for the length of our own path.
|
||||
for i, ourStep := range m {
|
||||
otherStep := to[i]
|
||||
if ourStep != otherStep {
|
||||
return false
|
||||
}
|
||||
}
|
||||
// If we fall out here then the prefixed matched, so it's contained.
|
||||
return true
|
||||
|
||||
case AbsResource:
|
||||
return m.TargetContains(to.Module)
|
||||
|
||||
case AbsResourceInstance:
|
||||
return m.TargetContains(to.Module)
|
||||
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (m ModuleInstance) targetableSigil() {
|
||||
// ModuleInstance is targetable
|
||||
}
|
||||
75
vendor/github.com/hashicorp/terraform/addrs/output_value.go
generated
vendored
Normal file
75
vendor/github.com/hashicorp/terraform/addrs/output_value.go
generated
vendored
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// OutputValue is the address of an output value, in the context of the module
|
||||
// that is defining it.
|
||||
//
|
||||
// This is related to but separate from ModuleCallOutput, which represents
|
||||
// a module output from the perspective of its parent module. Since output
|
||||
// values cannot be represented from the module where they are defined,
|
||||
// OutputValue is not Referenceable, while ModuleCallOutput is.
|
||||
type OutputValue struct {
|
||||
Name string
|
||||
}
|
||||
|
||||
func (v OutputValue) String() string {
|
||||
return "output." + v.Name
|
||||
}
|
||||
|
||||
// Absolute converts the receiver into an absolute address within the given
|
||||
// module instance.
|
||||
func (v OutputValue) Absolute(m ModuleInstance) AbsOutputValue {
|
||||
return AbsOutputValue{
|
||||
Module: m,
|
||||
OutputValue: v,
|
||||
}
|
||||
}
|
||||
|
||||
// AbsOutputValue is the absolute address of an output value within a module instance.
|
||||
//
|
||||
// This represents an output globally within the namespace of a particular
|
||||
// configuration. It is related to but separate from ModuleCallOutput, which
|
||||
// represents a module output from the perspective of its parent module.
|
||||
type AbsOutputValue struct {
|
||||
Module ModuleInstance
|
||||
OutputValue OutputValue
|
||||
}
|
||||
|
||||
// OutputValue returns the absolute address of an output value of the given
|
||||
// name within the receiving module instance.
|
||||
func (m ModuleInstance) OutputValue(name string) AbsOutputValue {
|
||||
return AbsOutputValue{
|
||||
Module: m,
|
||||
OutputValue: OutputValue{
|
||||
Name: name,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (v AbsOutputValue) String() string {
|
||||
if v.Module.IsRoot() {
|
||||
return v.OutputValue.String()
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", v.Module.String(), v.OutputValue.String())
|
||||
}
|
||||
|
||||
// ModuleCallOutput converts an AbsModuleOutput into a ModuleCallOutput,
|
||||
// returning also the module instance that the ModuleCallOutput is relative
|
||||
// to.
|
||||
//
|
||||
// The root module does not have a call, and so this method cannot be used
|
||||
// with outputs in the root module, and will panic in that case.
|
||||
func (v AbsOutputValue) ModuleCallOutput() (ModuleInstance, ModuleCallOutput) {
|
||||
if v.Module.IsRoot() {
|
||||
panic("ReferenceFromCall used with root module output")
|
||||
}
|
||||
|
||||
caller, call := v.Module.CallInstance()
|
||||
return caller, ModuleCallOutput{
|
||||
Call: call,
|
||||
Name: v.OutputValue.Name,
|
||||
}
|
||||
}
|
||||
338
vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
generated
vendored
Normal file
338
vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
generated
vendored
Normal file
|
|
@ -0,0 +1,338 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// Reference describes a reference to an address with source location
|
||||
// information.
|
||||
type Reference struct {
|
||||
Subject Referenceable
|
||||
SourceRange tfdiags.SourceRange
|
||||
Remaining hcl.Traversal
|
||||
}
|
||||
|
||||
// ParseRef attempts to extract a referencable address from the prefix of the
|
||||
// given traversal, which must be an absolute traversal or this function
|
||||
// will panic.
|
||||
//
|
||||
// If no error diagnostics are returned, the returned reference includes the
|
||||
// address that was extracted, the source range it was extracted from, and any
|
||||
// remaining relative traversal that was not consumed as part of the
|
||||
// reference.
|
||||
//
|
||||
// If error diagnostics are returned then the Reference value is invalid and
|
||||
// must not be used.
|
||||
func ParseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
|
||||
ref, diags := parseRef(traversal)
|
||||
|
||||
// Normalize a little to make life easier for callers.
|
||||
if ref != nil {
|
||||
if len(ref.Remaining) == 0 {
|
||||
ref.Remaining = nil
|
||||
}
|
||||
}
|
||||
|
||||
return ref, diags
|
||||
}
|
||||
|
||||
// ParseRefStr is a helper wrapper around ParseRef that takes a string
|
||||
// and parses it with the HCL native syntax traversal parser before
|
||||
// interpreting it.
|
||||
//
|
||||
// This should be used only in specialized situations since it will cause the
|
||||
// created references to not have any meaningful source location information.
|
||||
// If a reference string is coming from a source that should be identified in
|
||||
// error messages then the caller should instead parse it directly using a
|
||||
// suitable function from the HCL API and pass the traversal itself to
|
||||
// ParseRef.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// the returned reference may be nil or incomplete.
|
||||
func ParseRefStr(str string) (*Reference, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
ref, targetDiags := ParseRef(traversal)
|
||||
diags = diags.Append(targetDiags)
|
||||
return ref, diags
|
||||
}
|
||||
|
||||
func parseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
root := traversal.RootName()
|
||||
rootRange := traversal[0].SourceRange()
|
||||
|
||||
switch root {
|
||||
|
||||
case "count":
|
||||
name, rng, remain, diags := parseSingleAttrRef(traversal)
|
||||
return &Reference{
|
||||
Subject: CountAttr{Name: name},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
|
||||
case "data":
|
||||
if len(traversal) < 3 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: `The "data" object must be followed by two attribute names: the data source type and the resource name.`,
|
||||
Subject: traversal.SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
remain := traversal[1:] // trim off "data" so we can use our shared resource reference parser
|
||||
return parseResourceRef(DataResourceMode, rootRange, remain)
|
||||
|
||||
case "local":
|
||||
name, rng, remain, diags := parseSingleAttrRef(traversal)
|
||||
return &Reference{
|
||||
Subject: LocalValue{Name: name},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
|
||||
case "module":
|
||||
callName, callRange, remain, diags := parseSingleAttrRef(traversal)
|
||||
if diags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
// A traversal starting with "module" can either be a reference to
|
||||
// an entire module instance or to a single output from a module
|
||||
// instance, depending on what we find after this introducer.
|
||||
|
||||
callInstance := ModuleCallInstance{
|
||||
Call: ModuleCall{
|
||||
Name: callName,
|
||||
},
|
||||
Key: NoKey,
|
||||
}
|
||||
|
||||
if len(remain) == 0 {
|
||||
// Reference to an entire module instance. Might alternatively
|
||||
// be a reference to a collection of instances of a particular
|
||||
// module, but the caller will need to deal with that ambiguity
|
||||
// since we don't have enough context here.
|
||||
return &Reference{
|
||||
Subject: callInstance,
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(callRange),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
}
|
||||
|
||||
if idxTrav, ok := remain[0].(hcl.TraverseIndex); ok {
|
||||
var err error
|
||||
callInstance.Key, err = ParseInstanceKey(idxTrav.Key)
|
||||
if err != nil {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid index key",
|
||||
Detail: fmt.Sprintf("Invalid index for module instance: %s.", err),
|
||||
Subject: &idxTrav.SrcRange,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
remain = remain[1:]
|
||||
|
||||
if len(remain) == 0 {
|
||||
// Also a reference to an entire module instance, but we have a key
|
||||
// now.
|
||||
return &Reference{
|
||||
Subject: callInstance,
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(hcl.RangeBetween(callRange, idxTrav.SrcRange)),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
}
|
||||
}
|
||||
|
||||
if attrTrav, ok := remain[0].(hcl.TraverseAttr); ok {
|
||||
remain = remain[1:]
|
||||
return &Reference{
|
||||
Subject: ModuleCallOutput{
|
||||
Name: attrTrav.Name,
|
||||
Call: callInstance,
|
||||
},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(hcl.RangeBetween(callRange, attrTrav.SrcRange)),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
}
|
||||
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: "Module instance objects do not support this operation.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
|
||||
case "path":
|
||||
name, rng, remain, diags := parseSingleAttrRef(traversal)
|
||||
return &Reference{
|
||||
Subject: PathAttr{Name: name},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
|
||||
case "self":
|
||||
return &Reference{
|
||||
Subject: Self,
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rootRange),
|
||||
Remaining: traversal[1:],
|
||||
}, diags
|
||||
|
||||
case "terraform":
|
||||
name, rng, remain, diags := parseSingleAttrRef(traversal)
|
||||
return &Reference{
|
||||
Subject: TerraformAttr{Name: name},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
|
||||
case "var":
|
||||
name, rng, remain, diags := parseSingleAttrRef(traversal)
|
||||
return &Reference{
|
||||
Subject: InputVariable{Name: name},
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
|
||||
default:
|
||||
return parseResourceRef(ManagedResourceMode, rootRange, traversal)
|
||||
}
|
||||
}
|
||||
|
||||
func parseResourceRef(mode ResourceMode, startRange hcl.Range, traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
if len(traversal) < 2 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: `A reference to a resource type must be followed by at least one attribute access, specifying the resource name.`,
|
||||
Subject: hcl.RangeBetween(traversal[0].SourceRange(), traversal[len(traversal)-1].SourceRange()).Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
var typeName, name string
|
||||
switch tt := traversal[0].(type) { // Could be either root or attr, depending on our resource mode
|
||||
case hcl.TraverseRoot:
|
||||
typeName = tt.Name
|
||||
case hcl.TraverseAttr:
|
||||
typeName = tt.Name
|
||||
default:
|
||||
// If it isn't a TraverseRoot then it must be a "data" reference.
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: `The "data" object does not support this operation.`,
|
||||
Subject: traversal[0].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
attrTrav, ok := traversal[1].(hcl.TraverseAttr)
|
||||
if !ok {
|
||||
var what string
|
||||
switch mode {
|
||||
case DataResourceMode:
|
||||
what = "data source"
|
||||
default:
|
||||
what = "resource type"
|
||||
}
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: fmt.Sprintf(`A reference to a %s must be followed by at least one attribute access, specifying the resource name.`, what),
|
||||
Subject: traversal[1].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
name = attrTrav.Name
|
||||
rng := hcl.RangeBetween(startRange, attrTrav.SrcRange)
|
||||
remain := traversal[2:]
|
||||
|
||||
resourceAddr := Resource{
|
||||
Mode: mode,
|
||||
Type: typeName,
|
||||
Name: name,
|
||||
}
|
||||
resourceInstAddr := ResourceInstance{
|
||||
Resource: resourceAddr,
|
||||
Key: NoKey,
|
||||
}
|
||||
|
||||
if len(remain) == 0 {
|
||||
// This might actually be a reference to the collection of all instances
|
||||
// of the resource, but we don't have enough context here to decide
|
||||
// so we'll let the caller resolve that ambiguity.
|
||||
return &Reference{
|
||||
Subject: resourceInstAddr,
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
}, diags
|
||||
}
|
||||
|
||||
if idxTrav, ok := remain[0].(hcl.TraverseIndex); ok {
|
||||
var err error
|
||||
resourceInstAddr.Key, err = ParseInstanceKey(idxTrav.Key)
|
||||
if err != nil {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid index key",
|
||||
Detail: fmt.Sprintf("Invalid index for resource instance: %s.", err),
|
||||
Subject: &idxTrav.SrcRange,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
remain = remain[1:]
|
||||
rng = hcl.RangeBetween(rng, idxTrav.SrcRange)
|
||||
}
|
||||
|
||||
return &Reference{
|
||||
Subject: resourceInstAddr,
|
||||
SourceRange: tfdiags.SourceRangeFromHCL(rng),
|
||||
Remaining: remain,
|
||||
}, diags
|
||||
}
|
||||
|
||||
func parseSingleAttrRef(traversal hcl.Traversal) (string, hcl.Range, hcl.Traversal, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
root := traversal.RootName()
|
||||
rootRange := traversal[0].SourceRange()
|
||||
|
||||
if len(traversal) < 2 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: fmt.Sprintf("The %q object cannot be accessed directly. Instead, access one of its attributes.", root),
|
||||
Subject: &rootRange,
|
||||
})
|
||||
return "", hcl.Range{}, nil, diags
|
||||
}
|
||||
if attrTrav, ok := traversal[1].(hcl.TraverseAttr); ok {
|
||||
return attrTrav.Name, hcl.RangeBetween(rootRange, attrTrav.SrcRange), traversal[2:], diags
|
||||
}
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid reference",
|
||||
Detail: fmt.Sprintf("The %q object does not support this operation.", root),
|
||||
Subject: traversal[1].SourceRange().Ptr(),
|
||||
})
|
||||
return "", hcl.Range{}, nil, diags
|
||||
}
|
||||
318
vendor/github.com/hashicorp/terraform/addrs/parse_target.go
generated
vendored
Normal file
318
vendor/github.com/hashicorp/terraform/addrs/parse_target.go
generated
vendored
Normal file
|
|
@ -0,0 +1,318 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// Target describes a targeted address with source location information.
|
||||
type Target struct {
|
||||
Subject Targetable
|
||||
SourceRange tfdiags.SourceRange
|
||||
}
|
||||
|
||||
// ParseTarget attempts to interpret the given traversal as a targetable
|
||||
// address. The given traversal must be absolute, or this function will
|
||||
// panic.
|
||||
//
|
||||
// If no error diagnostics are returned, the returned target includes the
|
||||
// address that was extracted and the source range it was extracted from.
|
||||
//
|
||||
// If error diagnostics are returned then the Target value is invalid and
|
||||
// must not be used.
|
||||
func ParseTarget(traversal hcl.Traversal) (*Target, tfdiags.Diagnostics) {
|
||||
path, remain, diags := parseModuleInstancePrefix(traversal)
|
||||
if diags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
rng := tfdiags.SourceRangeFromHCL(traversal.SourceRange())
|
||||
|
||||
if len(remain) == 0 {
|
||||
return &Target{
|
||||
Subject: path,
|
||||
SourceRange: rng,
|
||||
}, diags
|
||||
}
|
||||
|
||||
mode := ManagedResourceMode
|
||||
if remain.RootName() == "data" {
|
||||
mode = DataResourceMode
|
||||
remain = remain[1:]
|
||||
}
|
||||
|
||||
if len(remain) < 2 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "Resource specification must include a resource type and name.",
|
||||
Subject: remain.SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
var typeName, name string
|
||||
switch tt := remain[0].(type) {
|
||||
case hcl.TraverseRoot:
|
||||
typeName = tt.Name
|
||||
case hcl.TraverseAttr:
|
||||
typeName = tt.Name
|
||||
default:
|
||||
switch mode {
|
||||
case ManagedResourceMode:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource type name is required.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
case DataResourceMode:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A data source name is required.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
default:
|
||||
panic("unknown mode")
|
||||
}
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
switch tt := remain[1].(type) {
|
||||
case hcl.TraverseAttr:
|
||||
name = tt.Name
|
||||
default:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource name is required.",
|
||||
Subject: remain[1].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
var subject Targetable
|
||||
remain = remain[2:]
|
||||
switch len(remain) {
|
||||
case 0:
|
||||
subject = path.Resource(mode, typeName, name)
|
||||
case 1:
|
||||
if tt, ok := remain[0].(hcl.TraverseIndex); ok {
|
||||
key, err := ParseInstanceKey(tt.Key)
|
||||
if err != nil {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: fmt.Sprintf("Invalid resource instance key: %s.", err),
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
subject = path.ResourceInstance(mode, typeName, name, key)
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "Resource instance key must be given in square brackets.",
|
||||
Subject: remain[0].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
default:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "Unexpected extra operators after address.",
|
||||
Subject: remain[1].SourceRange().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
return &Target{
|
||||
Subject: subject,
|
||||
SourceRange: rng,
|
||||
}, diags
|
||||
}
|
||||
|
||||
// ParseTargetStr is a helper wrapper around ParseTarget that takes a string
|
||||
// and parses it with the HCL native syntax traversal parser before
|
||||
// interpreting it.
|
||||
//
|
||||
// This should be used only in specialized situations since it will cause the
|
||||
// created references to not have any meaningful source location information.
|
||||
// If a target string is coming from a source that should be identified in
|
||||
// error messages then the caller should instead parse it directly using a
|
||||
// suitable function from the HCL API and pass the traversal itself to
|
||||
// ParseTarget.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// the returned target may be nil or incomplete.
|
||||
func ParseTargetStr(str string) (*Target, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
target, targetDiags := ParseTarget(traversal)
|
||||
diags = diags.Append(targetDiags)
|
||||
return target, diags
|
||||
}
|
||||
|
||||
// ParseAbsResource attempts to interpret the given traversal as an absolute
|
||||
// resource address, using the same syntax as expected by ParseTarget.
|
||||
//
|
||||
// If no error diagnostics are returned, the returned target includes the
|
||||
// address that was extracted and the source range it was extracted from.
|
||||
//
|
||||
// If error diagnostics are returned then the AbsResource value is invalid and
|
||||
// must not be used.
|
||||
func ParseAbsResource(traversal hcl.Traversal) (AbsResource, tfdiags.Diagnostics) {
|
||||
addr, diags := ParseTarget(traversal)
|
||||
if diags.HasErrors() {
|
||||
return AbsResource{}, diags
|
||||
}
|
||||
|
||||
switch tt := addr.Subject.(type) {
|
||||
|
||||
case AbsResource:
|
||||
return tt, diags
|
||||
|
||||
case AbsResourceInstance: // Catch likely user error with specialized message
|
||||
// Assume that the last element of the traversal must be the index,
|
||||
// since that's required for a valid resource instance address.
|
||||
indexStep := traversal[len(traversal)-1]
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource address is required. This instance key identifies a specific resource instance, which is not expected here.",
|
||||
Subject: indexStep.SourceRange().Ptr(),
|
||||
})
|
||||
return AbsResource{}, diags
|
||||
|
||||
case ModuleInstance: // Catch likely user error with specialized message
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource address is required here. The module path must be followed by a resource specification.",
|
||||
Subject: traversal.SourceRange().Ptr(),
|
||||
})
|
||||
return AbsResource{}, diags
|
||||
|
||||
default: // Generic message for other address types
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource address is required here.",
|
||||
Subject: traversal.SourceRange().Ptr(),
|
||||
})
|
||||
return AbsResource{}, diags
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// ParseAbsResourceStr is a helper wrapper around ParseAbsResource that takes a
|
||||
// string and parses it with the HCL native syntax traversal parser before
|
||||
// interpreting it.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// the returned address may be incomplete.
|
||||
//
|
||||
// Since this function has no context about the source of the given string,
|
||||
// any returned diagnostics will not have meaningful source location
|
||||
// information.
|
||||
func ParseAbsResourceStr(str string) (AbsResource, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return AbsResource{}, diags
|
||||
}
|
||||
|
||||
addr, addrDiags := ParseAbsResource(traversal)
|
||||
diags = diags.Append(addrDiags)
|
||||
return addr, diags
|
||||
}
|
||||
|
||||
// ParseAbsResourceInstance attempts to interpret the given traversal as an
|
||||
// absolute resource instance address, using the same syntax as expected by
|
||||
// ParseTarget.
|
||||
//
|
||||
// If no error diagnostics are returned, the returned target includes the
|
||||
// address that was extracted and the source range it was extracted from.
|
||||
//
|
||||
// If error diagnostics are returned then the AbsResource value is invalid and
|
||||
// must not be used.
|
||||
func ParseAbsResourceInstance(traversal hcl.Traversal) (AbsResourceInstance, tfdiags.Diagnostics) {
|
||||
addr, diags := ParseTarget(traversal)
|
||||
if diags.HasErrors() {
|
||||
return AbsResourceInstance{}, diags
|
||||
}
|
||||
|
||||
switch tt := addr.Subject.(type) {
|
||||
|
||||
case AbsResource:
|
||||
return tt.Instance(NoKey), diags
|
||||
|
||||
case AbsResourceInstance:
|
||||
return tt, diags
|
||||
|
||||
case ModuleInstance: // Catch likely user error with specialized message
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource instance address is required here. The module path must be followed by a resource instance specification.",
|
||||
Subject: traversal.SourceRange().Ptr(),
|
||||
})
|
||||
return AbsResourceInstance{}, diags
|
||||
|
||||
default: // Generic message for other address types
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid address",
|
||||
Detail: "A resource address is required here.",
|
||||
Subject: traversal.SourceRange().Ptr(),
|
||||
})
|
||||
return AbsResourceInstance{}, diags
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// ParseAbsResourceInstanceStr is a helper wrapper around
|
||||
// ParseAbsResourceInstance that takes a string and parses it with the HCL
|
||||
// native syntax traversal parser before interpreting it.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// the returned address may be incomplete.
|
||||
//
|
||||
// Since this function has no context about the source of the given string,
|
||||
// any returned diagnostics will not have meaningful source location
|
||||
// information.
|
||||
func ParseAbsResourceInstanceStr(str string) (AbsResourceInstance, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return AbsResourceInstance{}, diags
|
||||
}
|
||||
|
||||
addr, addrDiags := ParseAbsResourceInstance(traversal)
|
||||
diags = diags.Append(addrDiags)
|
||||
return addr, diags
|
||||
}
|
||||
12
vendor/github.com/hashicorp/terraform/addrs/path_attr.go
generated
vendored
Normal file
12
vendor/github.com/hashicorp/terraform/addrs/path_attr.go
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
package addrs
|
||||
|
||||
// PathAttr is the address of an attribute of the "path" object in
|
||||
// the interpolation scope, like "path.module".
|
||||
type PathAttr struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (pa PathAttr) String() string {
|
||||
return "path." + pa.Name
|
||||
}
|
||||
297
vendor/github.com/hashicorp/terraform/addrs/provider_config.go
generated
vendored
Normal file
297
vendor/github.com/hashicorp/terraform/addrs/provider_config.go
generated
vendored
Normal file
|
|
@ -0,0 +1,297 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
)
|
||||
|
||||
// ProviderConfig is the address of a provider configuration.
|
||||
type ProviderConfig struct {
|
||||
Type string
|
||||
|
||||
// If not empty, Alias identifies which non-default (aliased) provider
|
||||
// configuration this address refers to.
|
||||
Alias string
|
||||
}
|
||||
|
||||
// NewDefaultProviderConfig returns the address of the default (un-aliased)
|
||||
// configuration for the provider with the given type name.
|
||||
func NewDefaultProviderConfig(typeName string) ProviderConfig {
|
||||
return ProviderConfig{
|
||||
Type: typeName,
|
||||
}
|
||||
}
|
||||
|
||||
// ParseProviderConfigCompact parses the given absolute traversal as a relative
|
||||
// provider address in compact form. The following are examples of traversals
|
||||
// that can be successfully parsed as compact relative provider configuration
|
||||
// addresses:
|
||||
//
|
||||
// aws
|
||||
// aws.foo
|
||||
//
|
||||
// This function will panic if given a relative traversal.
|
||||
//
|
||||
// If the returned diagnostics contains errors then the result value is invalid
|
||||
// and must not be used.
|
||||
func ParseProviderConfigCompact(traversal hcl.Traversal) (ProviderConfig, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
ret := ProviderConfig{
|
||||
Type: traversal.RootName(),
|
||||
}
|
||||
|
||||
if len(traversal) < 2 {
|
||||
// Just a type name, then.
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
aliasStep := traversal[1]
|
||||
switch ts := aliasStep.(type) {
|
||||
case hcl.TraverseAttr:
|
||||
ret.Alias = ts.Name
|
||||
return ret, diags
|
||||
default:
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "The provider type name must either stand alone or be followed by an alias name separated with a dot.",
|
||||
Subject: aliasStep.SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
|
||||
if len(traversal) > 2 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "Extraneous extra operators after provider configuration address.",
|
||||
Subject: traversal[2:].SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
// ParseProviderConfigCompactStr is a helper wrapper around ParseProviderConfigCompact
|
||||
// that takes a string and parses it with the HCL native syntax traversal parser
|
||||
// before interpreting it.
|
||||
//
|
||||
// This should be used only in specialized situations since it will cause the
|
||||
// created references to not have any meaningful source location information.
|
||||
// If a reference string is coming from a source that should be identified in
|
||||
// error messages then the caller should instead parse it directly using a
|
||||
// suitable function from the HCL API and pass the traversal itself to
|
||||
// ParseProviderConfigCompact.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// then the returned address is invalid.
|
||||
func ParseProviderConfigCompactStr(str string) (ProviderConfig, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return ProviderConfig{}, diags
|
||||
}
|
||||
|
||||
addr, addrDiags := ParseProviderConfigCompact(traversal)
|
||||
diags = diags.Append(addrDiags)
|
||||
return addr, diags
|
||||
}
|
||||
|
||||
// Absolute returns an AbsProviderConfig from the receiver and the given module
|
||||
// instance address.
|
||||
func (pc ProviderConfig) Absolute(module ModuleInstance) AbsProviderConfig {
|
||||
return AbsProviderConfig{
|
||||
Module: module,
|
||||
ProviderConfig: pc,
|
||||
}
|
||||
}
|
||||
|
||||
func (pc ProviderConfig) String() string {
|
||||
if pc.Type == "" {
|
||||
// Should never happen; always indicates a bug
|
||||
return "provider.<invalid>"
|
||||
}
|
||||
|
||||
if pc.Alias != "" {
|
||||
return fmt.Sprintf("provider.%s.%s", pc.Type, pc.Alias)
|
||||
}
|
||||
|
||||
return "provider." + pc.Type
|
||||
}
|
||||
|
||||
// StringCompact is an alternative to String that returns the form that can
|
||||
// be parsed by ParseProviderConfigCompact, without the "provider." prefix.
|
||||
func (pc ProviderConfig) StringCompact() string {
|
||||
if pc.Alias != "" {
|
||||
return fmt.Sprintf("%s.%s", pc.Type, pc.Alias)
|
||||
}
|
||||
return pc.Type
|
||||
}
|
||||
|
||||
// AbsProviderConfig is the absolute address of a provider configuration
|
||||
// within a particular module instance.
|
||||
type AbsProviderConfig struct {
|
||||
Module ModuleInstance
|
||||
ProviderConfig ProviderConfig
|
||||
}
|
||||
|
||||
// ParseAbsProviderConfig parses the given traversal as an absolute provider
|
||||
// address. The following are examples of traversals that can be successfully
|
||||
// parsed as absolute provider configuration addresses:
|
||||
//
|
||||
// provider.aws
|
||||
// provider.aws.foo
|
||||
// module.bar.provider.aws
|
||||
// module.bar.module.baz.provider.aws.foo
|
||||
// module.foo[1].provider.aws.foo
|
||||
//
|
||||
// This type of address is used, for example, to record the relationships
|
||||
// between resources and provider configurations in the state structure.
|
||||
// This type of address is not generally used in the UI, except in error
|
||||
// messages that refer to provider configurations.
|
||||
func ParseAbsProviderConfig(traversal hcl.Traversal) (AbsProviderConfig, tfdiags.Diagnostics) {
|
||||
modInst, remain, diags := parseModuleInstancePrefix(traversal)
|
||||
ret := AbsProviderConfig{
|
||||
Module: modInst,
|
||||
}
|
||||
if len(remain) < 2 || remain.RootName() != "provider" {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "Provider address must begin with \"provider.\", followed by a provider type name.",
|
||||
Subject: remain.SourceRange().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
if len(remain) > 3 {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "Extraneous operators after provider configuration alias.",
|
||||
Subject: hcl.Traversal(remain[3:]).SourceRange().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
if tt, ok := remain[1].(hcl.TraverseAttr); ok {
|
||||
ret.ProviderConfig.Type = tt.Name
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "The prefix \"provider.\" must be followed by a provider type name.",
|
||||
Subject: remain[1].SourceRange().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
if len(remain) == 3 {
|
||||
if tt, ok := remain[2].(hcl.TraverseAttr); ok {
|
||||
ret.ProviderConfig.Alias = tt.Name
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration address",
|
||||
Detail: "Provider type name must be followed by a configuration alias name.",
|
||||
Subject: remain[2].SourceRange().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
// ParseAbsProviderConfigStr is a helper wrapper around ParseAbsProviderConfig
|
||||
// that takes a string and parses it with the HCL native syntax traversal parser
|
||||
// before interpreting it.
|
||||
//
|
||||
// This should be used only in specialized situations since it will cause the
|
||||
// created references to not have any meaningful source location information.
|
||||
// If a reference string is coming from a source that should be identified in
|
||||
// error messages then the caller should instead parse it directly using a
|
||||
// suitable function from the HCL API and pass the traversal itself to
|
||||
// ParseAbsProviderConfig.
|
||||
//
|
||||
// Error diagnostics are returned if either the parsing fails or the analysis
|
||||
// of the traversal fails. There is no way for the caller to distinguish the
|
||||
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
||||
// the returned address is invalid.
|
||||
func ParseAbsProviderConfigStr(str string) (AbsProviderConfig, tfdiags.Diagnostics) {
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
||||
diags = diags.Append(parseDiags)
|
||||
if parseDiags.HasErrors() {
|
||||
return AbsProviderConfig{}, diags
|
||||
}
|
||||
|
||||
addr, addrDiags := ParseAbsProviderConfig(traversal)
|
||||
diags = diags.Append(addrDiags)
|
||||
return addr, diags
|
||||
}
|
||||
|
||||
// ProviderConfigDefault returns the address of the default provider config
|
||||
// of the given type inside the recieving module instance.
|
||||
func (m ModuleInstance) ProviderConfigDefault(name string) AbsProviderConfig {
|
||||
return AbsProviderConfig{
|
||||
Module: m,
|
||||
ProviderConfig: ProviderConfig{
|
||||
Type: name,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ProviderConfigAliased returns the address of an aliased provider config
|
||||
// of with given type and alias inside the recieving module instance.
|
||||
func (m ModuleInstance) ProviderConfigAliased(name, alias string) AbsProviderConfig {
|
||||
return AbsProviderConfig{
|
||||
Module: m,
|
||||
ProviderConfig: ProviderConfig{
|
||||
Type: name,
|
||||
Alias: alias,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Inherited returns an address that the receiving configuration address might
|
||||
// inherit from in a parent module. The second bool return value indicates if
|
||||
// such inheritance is possible, and thus whether the returned address is valid.
|
||||
//
|
||||
// Inheritance is possible only for default (un-aliased) providers in modules
|
||||
// other than the root module. Even if a valid address is returned, inheritence
|
||||
// may not be performed for other reasons, such as if the calling module
|
||||
// provided explicit provider configurations within the call for this module.
|
||||
// The ProviderTransformer graph transform in the main terraform module has
|
||||
// the authoritative logic for provider inheritance, and this method is here
|
||||
// mainly just for its benefit.
|
||||
func (pc AbsProviderConfig) Inherited() (AbsProviderConfig, bool) {
|
||||
// Can't inherit if we're already in the root.
|
||||
if len(pc.Module) == 0 {
|
||||
return AbsProviderConfig{}, false
|
||||
}
|
||||
|
||||
// Can't inherit if we have an alias.
|
||||
if pc.ProviderConfig.Alias != "" {
|
||||
return AbsProviderConfig{}, false
|
||||
}
|
||||
|
||||
// Otherwise, we might inherit from a configuration with the same
|
||||
// provider name in the parent module instance.
|
||||
parentMod := pc.Module.Parent()
|
||||
return pc.ProviderConfig.Absolute(parentMod), true
|
||||
}
|
||||
|
||||
func (pc AbsProviderConfig) String() string {
|
||||
if len(pc.Module) == 0 {
|
||||
return pc.ProviderConfig.String()
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", pc.Module.String(), pc.ProviderConfig.String())
|
||||
}
|
||||
20
vendor/github.com/hashicorp/terraform/addrs/referenceable.go
generated
vendored
Normal file
20
vendor/github.com/hashicorp/terraform/addrs/referenceable.go
generated
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
package addrs
|
||||
|
||||
// Referenceable is an interface implemented by all address types that can
|
||||
// appear as references in configuration language expressions.
|
||||
type Referenceable interface {
|
||||
// All implementations of this interface must be covered by the type switch
|
||||
// in lang.Scope.buildEvalContext.
|
||||
referenceableSigil()
|
||||
|
||||
// String produces a string representation of the address that could be
|
||||
// parsed as a HCL traversal and passed to ParseRef to produce an identical
|
||||
// result.
|
||||
String() string
|
||||
}
|
||||
|
||||
type referenceable struct {
|
||||
}
|
||||
|
||||
func (r referenceable) referenceableSigil() {
|
||||
}
|
||||
270
vendor/github.com/hashicorp/terraform/addrs/resource.go
generated
vendored
Normal file
270
vendor/github.com/hashicorp/terraform/addrs/resource.go
generated
vendored
Normal file
|
|
@ -0,0 +1,270 @@
|
|||
package addrs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Resource is an address for a resource block within configuration, which
|
||||
// contains potentially-multiple resource instances if that configuration
|
||||
// block uses "count" or "for_each".
|
||||
type Resource struct {
|
||||
referenceable
|
||||
Mode ResourceMode
|
||||
Type string
|
||||
Name string
|
||||
}
|
||||
|
||||
func (r Resource) String() string {
|
||||
switch r.Mode {
|
||||
case ManagedResourceMode:
|
||||
return fmt.Sprintf("%s.%s", r.Type, r.Name)
|
||||
case DataResourceMode:
|
||||
return fmt.Sprintf("data.%s.%s", r.Type, r.Name)
|
||||
default:
|
||||
// Should never happen, but we'll return a string here rather than
|
||||
// crashing just in case it does.
|
||||
return fmt.Sprintf("<invalid>.%s.%s", r.Type, r.Name)
|
||||
}
|
||||
}
|
||||
|
||||
func (r Resource) Equal(o Resource) bool {
|
||||
return r.String() == o.String()
|
||||
}
|
||||
|
||||
// Instance produces the address for a specific instance of the receiver
|
||||
// that is idenfied by the given key.
|
||||
func (r Resource) Instance(key InstanceKey) ResourceInstance {
|
||||
return ResourceInstance{
|
||||
Resource: r,
|
||||
Key: key,
|
||||
}
|
||||
}
|
||||
|
||||
// Absolute returns an AbsResource from the receiver and the given module
|
||||
// instance address.
|
||||
func (r Resource) Absolute(module ModuleInstance) AbsResource {
|
||||
return AbsResource{
|
||||
Module: module,
|
||||
Resource: r,
|
||||
}
|
||||
}
|
||||
|
||||
// DefaultProviderConfig returns the address of the provider configuration
|
||||
// that should be used for the resource identified by the reciever if it
|
||||
// does not have a provider configuration address explicitly set in
|
||||
// configuration.
|
||||
//
|
||||
// This method is not able to verify that such a configuration exists, nor
|
||||
// represent the behavior of automatically inheriting certain provider
|
||||
// configurations from parent modules. It just does a static analysis of the
|
||||
// receiving address and returns an address to start from, relative to the
|
||||
// same module that contains the resource.
|
||||
func (r Resource) DefaultProviderConfig() ProviderConfig {
|
||||
typeName := r.Type
|
||||
if under := strings.Index(typeName, "_"); under != -1 {
|
||||
typeName = typeName[:under]
|
||||
}
|
||||
return ProviderConfig{
|
||||
Type: typeName,
|
||||
}
|
||||
}
|
||||
|
||||
// ResourceInstance is an address for a specific instance of a resource.
|
||||
// When a resource is defined in configuration with "count" or "for_each" it
|
||||
// produces zero or more instances, which can be addressed using this type.
|
||||
type ResourceInstance struct {
|
||||
referenceable
|
||||
Resource Resource
|
||||
Key InstanceKey
|
||||
}
|
||||
|
||||
func (r ResourceInstance) ContainingResource() Resource {
|
||||
return r.Resource
|
||||
}
|
||||
|
||||
func (r ResourceInstance) String() string {
|
||||
if r.Key == NoKey {
|
||||
return r.Resource.String()
|
||||
}
|
||||
return r.Resource.String() + r.Key.String()
|
||||
}
|
||||
|
||||
func (r ResourceInstance) Equal(o ResourceInstance) bool {
|
||||
return r.String() == o.String()
|
||||
}
|
||||
|
||||
// Absolute returns an AbsResourceInstance from the receiver and the given module
|
||||
// instance address.
|
||||
func (r ResourceInstance) Absolute(module ModuleInstance) AbsResourceInstance {
|
||||
return AbsResourceInstance{
|
||||
Module: module,
|
||||
Resource: r,
|
||||
}
|
||||
}
|
||||
|
||||
// AbsResource is an absolute address for a resource under a given module path.
|
||||
type AbsResource struct {
|
||||
targetable
|
||||
Module ModuleInstance
|
||||
Resource Resource
|
||||
}
|
||||
|
||||
// Resource returns the address of a particular resource within the receiver.
|
||||
func (m ModuleInstance) Resource(mode ResourceMode, typeName string, name string) AbsResource {
|
||||
return AbsResource{
|
||||
Module: m,
|
||||
Resource: Resource{
|
||||
Mode: mode,
|
||||
Type: typeName,
|
||||
Name: name,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Instance produces the address for a specific instance of the receiver
|
||||
// that is idenfied by the given key.
|
||||
func (r AbsResource) Instance(key InstanceKey) AbsResourceInstance {
|
||||
return AbsResourceInstance{
|
||||
Module: r.Module,
|
||||
Resource: r.Resource.Instance(key),
|
||||
}
|
||||
}
|
||||
|
||||
// TargetContains implements Targetable by returning true if the given other
|
||||
// address is either equal to the receiver or is an instance of the
|
||||
// receiver.
|
||||
func (r AbsResource) TargetContains(other Targetable) bool {
|
||||
switch to := other.(type) {
|
||||
|
||||
case AbsResource:
|
||||
// We'll use our stringification as a cheat-ish way to test for equality.
|
||||
return to.String() == r.String()
|
||||
|
||||
case AbsResourceInstance:
|
||||
return r.TargetContains(to.ContainingResource())
|
||||
|
||||
default:
|
||||
return false
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func (r AbsResource) String() string {
|
||||
if len(r.Module) == 0 {
|
||||
return r.Resource.String()
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", r.Module.String(), r.Resource.String())
|
||||
}
|
||||
|
||||
func (r AbsResource) Equal(o AbsResource) bool {
|
||||
return r.String() == o.String()
|
||||
}
|
||||
|
||||
// AbsResourceInstance is an absolute address for a resource instance under a
|
||||
// given module path.
|
||||
type AbsResourceInstance struct {
|
||||
targetable
|
||||
Module ModuleInstance
|
||||
Resource ResourceInstance
|
||||
}
|
||||
|
||||
// ResourceInstance returns the address of a particular resource instance within the receiver.
|
||||
func (m ModuleInstance) ResourceInstance(mode ResourceMode, typeName string, name string, key InstanceKey) AbsResourceInstance {
|
||||
return AbsResourceInstance{
|
||||
Module: m,
|
||||
Resource: ResourceInstance{
|
||||
Resource: Resource{
|
||||
Mode: mode,
|
||||
Type: typeName,
|
||||
Name: name,
|
||||
},
|
||||
Key: key,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ContainingResource returns the address of the resource that contains the
|
||||
// receving resource instance. In other words, it discards the key portion
|
||||
// of the address to produce an AbsResource value.
|
||||
func (r AbsResourceInstance) ContainingResource() AbsResource {
|
||||
return AbsResource{
|
||||
Module: r.Module,
|
||||
Resource: r.Resource.ContainingResource(),
|
||||
}
|
||||
}
|
||||
|
||||
// TargetContains implements Targetable by returning true if the given other
|
||||
// address is equal to the receiver.
|
||||
func (r AbsResourceInstance) TargetContains(other Targetable) bool {
|
||||
switch to := other.(type) {
|
||||
|
||||
case AbsResourceInstance:
|
||||
// We'll use our stringification as a cheat-ish way to test for equality.
|
||||
return to.String() == r.String()
|
||||
|
||||
default:
|
||||
return false
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func (r AbsResourceInstance) String() string {
|
||||
if len(r.Module) == 0 {
|
||||
return r.Resource.String()
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", r.Module.String(), r.Resource.String())
|
||||
}
|
||||
|
||||
func (r AbsResourceInstance) Equal(o AbsResourceInstance) bool {
|
||||
return r.String() == o.String()
|
||||
}
|
||||
|
||||
// Less returns true if the receiver should sort before the given other value
|
||||
// in a sorted list of addresses.
|
||||
func (r AbsResourceInstance) Less(o AbsResourceInstance) bool {
|
||||
switch {
|
||||
|
||||
case len(r.Module) != len(o.Module):
|
||||
return len(r.Module) < len(o.Module)
|
||||
|
||||
case r.Module.String() != o.Module.String():
|
||||
return r.Module.Less(o.Module)
|
||||
|
||||
case r.Resource.Resource.Mode != o.Resource.Resource.Mode:
|
||||
return r.Resource.Resource.Mode == DataResourceMode
|
||||
|
||||
case r.Resource.Resource.Type != o.Resource.Resource.Type:
|
||||
return r.Resource.Resource.Type < o.Resource.Resource.Type
|
||||
|
||||
case r.Resource.Resource.Name != o.Resource.Resource.Name:
|
||||
return r.Resource.Resource.Name < o.Resource.Resource.Name
|
||||
|
||||
case r.Resource.Key != o.Resource.Key:
|
||||
return InstanceKeyLess(r.Resource.Key, o.Resource.Key)
|
||||
|
||||
default:
|
||||
return false
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// ResourceMode defines which lifecycle applies to a given resource. Each
|
||||
// resource lifecycle has a slightly different address format.
|
||||
type ResourceMode rune
|
||||
|
||||
//go:generate stringer -type ResourceMode
|
||||
|
||||
const (
|
||||
// InvalidResourceMode is the zero value of ResourceMode and is not
|
||||
// a valid resource mode.
|
||||
InvalidResourceMode ResourceMode = 0
|
||||
|
||||
// ManagedResourceMode indicates a managed resource, as defined by
|
||||
// "resource" blocks in configuration.
|
||||
ManagedResourceMode ResourceMode = 'M'
|
||||
|
||||
// DataResourceMode indicates a data resource, as defined by
|
||||
// "data" blocks in configuration.
|
||||
DataResourceMode ResourceMode = 'D'
|
||||
)
|
||||
105
vendor/github.com/hashicorp/terraform/addrs/resource_phase.go
generated
vendored
Normal file
105
vendor/github.com/hashicorp/terraform/addrs/resource_phase.go
generated
vendored
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
package addrs
|
||||
|
||||
import "fmt"
|
||||
|
||||
// ResourceInstancePhase is a special kind of reference used only internally
|
||||
// during graph building to represent resource instances that are in a
|
||||
// non-primary state.
|
||||
//
|
||||
// Graph nodes can declare themselves referenceable via an instance phase
|
||||
// or can declare that they reference an instance phase in order to accomodate
|
||||
// secondary graph nodes dealing with, for example, destroy actions.
|
||||
//
|
||||
// This special reference type cannot be accessed directly by end-users, and
|
||||
// should never be shown in the UI.
|
||||
type ResourceInstancePhase struct {
|
||||
referenceable
|
||||
ResourceInstance ResourceInstance
|
||||
Phase ResourceInstancePhaseType
|
||||
}
|
||||
|
||||
var _ Referenceable = ResourceInstancePhase{}
|
||||
|
||||
// Phase returns a special "phase address" for the receving instance. See the
|
||||
// documentation of ResourceInstancePhase for the limited situations where this
|
||||
// is intended to be used.
|
||||
func (r ResourceInstance) Phase(rpt ResourceInstancePhaseType) ResourceInstancePhase {
|
||||
return ResourceInstancePhase{
|
||||
ResourceInstance: r,
|
||||
Phase: rpt,
|
||||
}
|
||||
}
|
||||
|
||||
// ContainingResource returns an address for the same phase of the resource
|
||||
// that this instance belongs to.
|
||||
func (rp ResourceInstancePhase) ContainingResource() ResourcePhase {
|
||||
return rp.ResourceInstance.Resource.Phase(rp.Phase)
|
||||
}
|
||||
|
||||
func (rp ResourceInstancePhase) String() string {
|
||||
// We use a different separator here than usual to ensure that we'll
|
||||
// never conflict with any non-phased resource instance string. This
|
||||
// is intentionally something that would fail parsing with ParseRef,
|
||||
// because this special address type should never be exposed in the UI.
|
||||
return fmt.Sprintf("%s#%s", rp.ResourceInstance, rp.Phase)
|
||||
}
|
||||
|
||||
// ResourceInstancePhaseType is an enumeration used with ResourceInstancePhase.
|
||||
type ResourceInstancePhaseType string
|
||||
|
||||
const (
|
||||
// ResourceInstancePhaseDestroy represents the "destroy" phase of a
|
||||
// resource instance.
|
||||
ResourceInstancePhaseDestroy ResourceInstancePhaseType = "destroy"
|
||||
|
||||
// ResourceInstancePhaseDestroyCBD is similar to ResourceInstancePhaseDestroy
|
||||
// but is used for resources that have "create_before_destroy" set, thus
|
||||
// requiring a different dependency ordering.
|
||||
ResourceInstancePhaseDestroyCBD ResourceInstancePhaseType = "destroy-cbd"
|
||||
)
|
||||
|
||||
func (rpt ResourceInstancePhaseType) String() string {
|
||||
return string(rpt)
|
||||
}
|
||||
|
||||
// ResourcePhase is a special kind of reference used only internally
|
||||
// during graph building to represent resources that are in a
|
||||
// non-primary state.
|
||||
//
|
||||
// Graph nodes can declare themselves referenceable via a resource phase
|
||||
// or can declare that they reference a resource phase in order to accomodate
|
||||
// secondary graph nodes dealing with, for example, destroy actions.
|
||||
//
|
||||
// Since resources (as opposed to instances) aren't actually phased, this
|
||||
// address type is used only as an approximation during initial construction
|
||||
// of the resource-oriented plan graph, under the assumption that resource
|
||||
// instances with ResourceInstancePhase addresses will be created in dynamic
|
||||
// subgraphs during the graph walk.
|
||||
//
|
||||
// This special reference type cannot be accessed directly by end-users, and
|
||||
// should never be shown in the UI.
|
||||
type ResourcePhase struct {
|
||||
referenceable
|
||||
Resource Resource
|
||||
Phase ResourceInstancePhaseType
|
||||
}
|
||||
|
||||
var _ Referenceable = ResourcePhase{}
|
||||
|
||||
// Phase returns a special "phase address" for the receving instance. See the
|
||||
// documentation of ResourceInstancePhase for the limited situations where this
|
||||
// is intended to be used.
|
||||
func (r Resource) Phase(rpt ResourceInstancePhaseType) ResourcePhase {
|
||||
return ResourcePhase{
|
||||
Resource: r,
|
||||
Phase: rpt,
|
||||
}
|
||||
}
|
||||
|
||||
func (rp ResourcePhase) String() string {
|
||||
// We use a different separator here than usual to ensure that we'll
|
||||
// never conflict with any non-phased resource instance string. This
|
||||
// is intentionally something that would fail parsing with ParseRef,
|
||||
// because this special address type should never be exposed in the UI.
|
||||
return fmt.Sprintf("%s#%s", rp.Resource, rp.Phase)
|
||||
}
|
||||
24
vendor/github.com/hashicorp/terraform/addrs/resourcemode_string.go
generated
vendored
Normal file
24
vendor/github.com/hashicorp/terraform/addrs/resourcemode_string.go
generated
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
// Code generated by "stringer -type ResourceMode"; DO NOT EDIT.
|
||||
|
||||
package addrs
|
||||
|
||||
import "strconv"
|
||||
|
||||
const (
|
||||
_ResourceMode_name_0 = "InvalidResourceMode"
|
||||
_ResourceMode_name_1 = "DataResourceMode"
|
||||
_ResourceMode_name_2 = "ManagedResourceMode"
|
||||
)
|
||||
|
||||
func (i ResourceMode) String() string {
|
||||
switch {
|
||||
case i == 0:
|
||||
return _ResourceMode_name_0
|
||||
case i == 68:
|
||||
return _ResourceMode_name_1
|
||||
case i == 77:
|
||||
return _ResourceMode_name_2
|
||||
default:
|
||||
return "ResourceMode(" + strconv.FormatInt(int64(i), 10) + ")"
|
||||
}
|
||||
}
|
||||
14
vendor/github.com/hashicorp/terraform/addrs/self.go
generated
vendored
Normal file
14
vendor/github.com/hashicorp/terraform/addrs/self.go
generated
vendored
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
package addrs
|
||||
|
||||
// Self is the address of the special object "self" that behaves as an alias
|
||||
// for a containing object currently in scope.
|
||||
const Self selfT = 0
|
||||
|
||||
type selfT int
|
||||
|
||||
func (s selfT) referenceableSigil() {
|
||||
}
|
||||
|
||||
func (s selfT) String() string {
|
||||
return "self"
|
||||
}
|
||||
26
vendor/github.com/hashicorp/terraform/addrs/targetable.go
generated
vendored
Normal file
26
vendor/github.com/hashicorp/terraform/addrs/targetable.go
generated
vendored
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
package addrs
|
||||
|
||||
// Targetable is an interface implemented by all address types that can be
|
||||
// used as "targets" for selecting sub-graphs of a graph.
|
||||
type Targetable interface {
|
||||
targetableSigil()
|
||||
|
||||
// TargetContains returns true if the receiver is considered to contain
|
||||
// the given other address. Containment, for the purpose of targeting,
|
||||
// means that if a container address is targeted then all of the
|
||||
// addresses within it are also implicitly targeted.
|
||||
//
|
||||
// A targetable address always contains at least itself.
|
||||
TargetContains(other Targetable) bool
|
||||
|
||||
// String produces a string representation of the address that could be
|
||||
// parsed as a HCL traversal and passed to ParseTarget to produce an
|
||||
// identical result.
|
||||
String() string
|
||||
}
|
||||
|
||||
type targetable struct {
|
||||
}
|
||||
|
||||
func (r targetable) targetableSigil() {
|
||||
}
|
||||
12
vendor/github.com/hashicorp/terraform/addrs/terraform_attr.go
generated
vendored
Normal file
12
vendor/github.com/hashicorp/terraform/addrs/terraform_attr.go
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
package addrs
|
||||
|
||||
// TerraformAttr is the address of an attribute of the "terraform" object in
|
||||
// the interpolation scope, like "terraform.workspace".
|
||||
type TerraformAttr struct {
|
||||
referenceable
|
||||
Name string
|
||||
}
|
||||
|
||||
func (ta TerraformAttr) String() string {
|
||||
return "terraform." + ta.Name
|
||||
}
|
||||
97
vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
generated
vendored
97
vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
generated
vendored
|
|
@ -1,97 +0,0 @@
|
|||
package configschema
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcldec"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
var mapLabelNames = []string{"key"}
|
||||
|
||||
// DecoderSpec returns a hcldec.Spec that can be used to decode a HCL Body
|
||||
// using the facilities in the hcldec package.
|
||||
//
|
||||
// The returned specification is guaranteed to return a value of the same type
|
||||
// returned by method ImpliedType, but it may contain null or unknown values if
|
||||
// any of the block attributes are defined as optional and/or computed
|
||||
// respectively.
|
||||
func (b *Block) DecoderSpec() hcldec.Spec {
|
||||
ret := hcldec.ObjectSpec{}
|
||||
if b == nil {
|
||||
return ret
|
||||
}
|
||||
|
||||
for name, attrS := range b.Attributes {
|
||||
switch {
|
||||
case attrS.Computed && attrS.Optional:
|
||||
// In this special case we use an unknown value as a default
|
||||
// to get the intended behavior that the result is computed
|
||||
// unless it has been explicitly set in config.
|
||||
ret[name] = &hcldec.DefaultSpec{
|
||||
Primary: &hcldec.AttrSpec{
|
||||
Name: name,
|
||||
Type: attrS.Type,
|
||||
},
|
||||
Default: &hcldec.LiteralSpec{
|
||||
Value: cty.UnknownVal(attrS.Type),
|
||||
},
|
||||
}
|
||||
case attrS.Computed:
|
||||
ret[name] = &hcldec.LiteralSpec{
|
||||
Value: cty.UnknownVal(attrS.Type),
|
||||
}
|
||||
default:
|
||||
ret[name] = &hcldec.AttrSpec{
|
||||
Name: name,
|
||||
Type: attrS.Type,
|
||||
Required: attrS.Required,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for name, blockS := range b.BlockTypes {
|
||||
if _, exists := ret[name]; exists {
|
||||
// This indicates an invalid schema, since it's not valid to
|
||||
// define both an attribute and a block type of the same name.
|
||||
// However, we don't raise this here since it's checked by
|
||||
// InternalValidate.
|
||||
continue
|
||||
}
|
||||
|
||||
childSpec := blockS.Block.DecoderSpec()
|
||||
|
||||
switch blockS.Nesting {
|
||||
case NestingSingle:
|
||||
ret[name] = &hcldec.BlockSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
Required: blockS.MinItems == 1 && blockS.MaxItems >= 1,
|
||||
}
|
||||
case NestingList:
|
||||
ret[name] = &hcldec.BlockListSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
MinItems: blockS.MinItems,
|
||||
MaxItems: blockS.MaxItems,
|
||||
}
|
||||
case NestingSet:
|
||||
ret[name] = &hcldec.BlockSetSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
MinItems: blockS.MinItems,
|
||||
MaxItems: blockS.MaxItems,
|
||||
}
|
||||
case NestingMap:
|
||||
ret[name] = &hcldec.BlockMapSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
LabelNames: mapLabelNames,
|
||||
}
|
||||
default:
|
||||
// Invalid nesting type is just ignored. It's checked by
|
||||
// InternalValidate.
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
402
vendor/github.com/hashicorp/terraform/config/hcl2shim/flatmap.go
generated
vendored
Normal file
402
vendor/github.com/hashicorp/terraform/config/hcl2shim/flatmap.go
generated
vendored
Normal file
|
|
@ -0,0 +1,402 @@
|
|||
package hcl2shim
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// FlatmapValueFromHCL2 converts a value from HCL2 (really, from the cty dynamic
|
||||
// types library that HCL2 uses) to a map compatible with what would be
|
||||
// produced by the "flatmap" package.
|
||||
//
|
||||
// The type of the given value informs the structure of the resulting map.
|
||||
// The value must be of an object type or this function will panic.
|
||||
//
|
||||
// Flatmap values can only represent maps when they are of primitive types,
|
||||
// so the given value must not have any maps of complex types or the result
|
||||
// is undefined.
|
||||
func FlatmapValueFromHCL2(v cty.Value) map[string]string {
|
||||
if v.IsNull() {
|
||||
return nil
|
||||
}
|
||||
|
||||
if !v.Type().IsObjectType() {
|
||||
panic(fmt.Sprintf("HCL2ValueFromFlatmap called on %#v", v.Type()))
|
||||
}
|
||||
|
||||
m := make(map[string]string)
|
||||
flatmapValueFromHCL2Map(m, "", v)
|
||||
return m
|
||||
}
|
||||
|
||||
func flatmapValueFromHCL2Value(m map[string]string, key string, val cty.Value) {
|
||||
ty := val.Type()
|
||||
switch {
|
||||
case ty.IsPrimitiveType() || ty == cty.DynamicPseudoType:
|
||||
flatmapValueFromHCL2Primitive(m, key, val)
|
||||
case ty.IsObjectType() || ty.IsMapType():
|
||||
flatmapValueFromHCL2Map(m, key+".", val)
|
||||
case ty.IsTupleType() || ty.IsListType() || ty.IsSetType():
|
||||
flatmapValueFromHCL2Seq(m, key+".", val)
|
||||
default:
|
||||
panic(fmt.Sprintf("cannot encode %s to flatmap", ty.FriendlyName()))
|
||||
}
|
||||
}
|
||||
|
||||
func flatmapValueFromHCL2Primitive(m map[string]string, key string, val cty.Value) {
|
||||
if !val.IsKnown() {
|
||||
m[key] = UnknownVariableValue
|
||||
return
|
||||
}
|
||||
if val.IsNull() {
|
||||
// Omit entirely
|
||||
return
|
||||
}
|
||||
|
||||
var err error
|
||||
val, err = convert.Convert(val, cty.String)
|
||||
if err != nil {
|
||||
// Should not be possible, since all primitive types can convert to string.
|
||||
panic(fmt.Sprintf("invalid primitive encoding to flatmap: %s", err))
|
||||
}
|
||||
m[key] = val.AsString()
|
||||
}
|
||||
|
||||
func flatmapValueFromHCL2Map(m map[string]string, prefix string, val cty.Value) {
|
||||
if val.IsNull() {
|
||||
// Omit entirely
|
||||
return
|
||||
}
|
||||
if !val.IsKnown() {
|
||||
switch {
|
||||
case val.Type().IsObjectType():
|
||||
// Whole objects can't be unknown in flatmap, so instead we'll
|
||||
// just write all of the attribute values out as unknown.
|
||||
for name, aty := range val.Type().AttributeTypes() {
|
||||
flatmapValueFromHCL2Value(m, prefix+name, cty.UnknownVal(aty))
|
||||
}
|
||||
default:
|
||||
m[prefix+"%"] = UnknownVariableValue
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
len := 0
|
||||
for it := val.ElementIterator(); it.Next(); {
|
||||
ak, av := it.Element()
|
||||
name := ak.AsString()
|
||||
flatmapValueFromHCL2Value(m, prefix+name, av)
|
||||
len++
|
||||
}
|
||||
if !val.Type().IsObjectType() { // objects don't have an explicit count included, since their attribute count is fixed
|
||||
m[prefix+"%"] = strconv.Itoa(len)
|
||||
}
|
||||
}
|
||||
|
||||
func flatmapValueFromHCL2Seq(m map[string]string, prefix string, val cty.Value) {
|
||||
if val.IsNull() {
|
||||
// Omit entirely
|
||||
return
|
||||
}
|
||||
if !val.IsKnown() {
|
||||
m[prefix+"#"] = UnknownVariableValue
|
||||
return
|
||||
}
|
||||
|
||||
// For sets this won't actually generate exactly what helper/schema would've
|
||||
// generated, because we don't have access to the set key function it
|
||||
// would've used. However, in practice it doesn't actually matter what the
|
||||
// keys are as long as they are unique, so we'll just generate sequential
|
||||
// indexes for them as if it were a list.
|
||||
//
|
||||
// An important implication of this, however, is that the set ordering will
|
||||
// not be consistent across mutations and so different keys may be assigned
|
||||
// to the same value when round-tripping. Since this shim is intended to
|
||||
// be short-lived and not used for round-tripping, we accept this.
|
||||
i := 0
|
||||
for it := val.ElementIterator(); it.Next(); {
|
||||
_, av := it.Element()
|
||||
key := prefix + strconv.Itoa(i)
|
||||
flatmapValueFromHCL2Value(m, key, av)
|
||||
i++
|
||||
}
|
||||
m[prefix+"#"] = strconv.Itoa(i)
|
||||
}
|
||||
|
||||
// HCL2ValueFromFlatmap converts a map compatible with what would be produced
|
||||
// by the "flatmap" package to a HCL2 (really, the cty dynamic types library
|
||||
// that HCL2 uses) object type.
|
||||
//
|
||||
// The intended result type must be provided in order to guide how the
|
||||
// map contents are decoded. This must be an object type or this function
|
||||
// will panic.
|
||||
//
|
||||
// Flatmap values can only represent maps when they are of primitive types,
|
||||
// so the given type must not have any maps of complex types or the result
|
||||
// is undefined.
|
||||
//
|
||||
// The result may contain null values if the given map does not contain keys
|
||||
// for all of the different key paths implied by the given type.
|
||||
func HCL2ValueFromFlatmap(m map[string]string, ty cty.Type) (cty.Value, error) {
|
||||
if m == nil {
|
||||
return cty.NullVal(ty), nil
|
||||
}
|
||||
if !ty.IsObjectType() {
|
||||
panic(fmt.Sprintf("HCL2ValueFromFlatmap called on %#v", ty))
|
||||
}
|
||||
|
||||
return hcl2ValueFromFlatmapObject(m, "", ty.AttributeTypes())
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapValue(m map[string]string, key string, ty cty.Type) (cty.Value, error) {
|
||||
var val cty.Value
|
||||
var err error
|
||||
switch {
|
||||
case ty.IsPrimitiveType():
|
||||
val, err = hcl2ValueFromFlatmapPrimitive(m, key, ty)
|
||||
case ty.IsObjectType():
|
||||
val, err = hcl2ValueFromFlatmapObject(m, key+".", ty.AttributeTypes())
|
||||
case ty.IsTupleType():
|
||||
val, err = hcl2ValueFromFlatmapTuple(m, key+".", ty.TupleElementTypes())
|
||||
case ty.IsMapType():
|
||||
val, err = hcl2ValueFromFlatmapMap(m, key+".", ty)
|
||||
case ty.IsListType():
|
||||
val, err = hcl2ValueFromFlatmapList(m, key+".", ty)
|
||||
case ty.IsSetType():
|
||||
val, err = hcl2ValueFromFlatmapSet(m, key+".", ty)
|
||||
default:
|
||||
err = fmt.Errorf("cannot decode %s from flatmap", ty.FriendlyName())
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
return val, nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapPrimitive(m map[string]string, key string, ty cty.Type) (cty.Value, error) {
|
||||
rawVal, exists := m[key]
|
||||
if !exists {
|
||||
return cty.NullVal(ty), nil
|
||||
}
|
||||
if rawVal == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
var err error
|
||||
val := cty.StringVal(rawVal)
|
||||
val, err = convert.Convert(val, ty)
|
||||
if err != nil {
|
||||
// This should never happen for _valid_ input, but flatmap data might
|
||||
// be tampered with by the user and become invalid.
|
||||
return cty.DynamicVal, fmt.Errorf("invalid value for %q in state: %s", key, err)
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapObject(m map[string]string, prefix string, atys map[string]cty.Type) (cty.Value, error) {
|
||||
vals := make(map[string]cty.Value)
|
||||
for name, aty := range atys {
|
||||
val, err := hcl2ValueFromFlatmapValue(m, prefix+name, aty)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
vals[name] = val
|
||||
}
|
||||
return cty.ObjectVal(vals), nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapTuple(m map[string]string, prefix string, etys []cty.Type) (cty.Value, error) {
|
||||
var vals []cty.Value
|
||||
|
||||
// if the container is unknown, there is no count string
|
||||
listName := strings.TrimRight(prefix, ".")
|
||||
if m[listName] == UnknownVariableValue {
|
||||
return cty.UnknownVal(cty.Tuple(etys)), nil
|
||||
}
|
||||
|
||||
countStr, exists := m[prefix+"#"]
|
||||
if !exists {
|
||||
return cty.NullVal(cty.Tuple(etys)), nil
|
||||
}
|
||||
if countStr == UnknownVariableValue {
|
||||
return cty.UnknownVal(cty.Tuple(etys)), nil
|
||||
}
|
||||
|
||||
count, err := strconv.Atoi(countStr)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, fmt.Errorf("invalid count value for %q in state: %s", prefix, err)
|
||||
}
|
||||
if count != len(etys) {
|
||||
return cty.DynamicVal, fmt.Errorf("wrong number of values for %q in state: got %d, but need %d", prefix, count, len(etys))
|
||||
}
|
||||
|
||||
vals = make([]cty.Value, len(etys))
|
||||
for i, ety := range etys {
|
||||
key := prefix + strconv.Itoa(i)
|
||||
val, err := hcl2ValueFromFlatmapValue(m, key, ety)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
vals[i] = val
|
||||
}
|
||||
return cty.TupleVal(vals), nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapMap(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) {
|
||||
vals := make(map[string]cty.Value)
|
||||
ety := ty.ElementType()
|
||||
|
||||
// if the container is unknown, there is no count string
|
||||
listName := strings.TrimRight(prefix, ".")
|
||||
if m[listName] == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
// We actually don't really care about the "count" of a map for our
|
||||
// purposes here, but we do need to check if it _exists_ in order to
|
||||
// recognize the difference between null (not set at all) and empty.
|
||||
if strCount, exists := m[prefix+"%"]; !exists {
|
||||
return cty.NullVal(ty), nil
|
||||
} else if strCount == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
for fullKey := range m {
|
||||
if !strings.HasPrefix(fullKey, prefix) {
|
||||
continue
|
||||
}
|
||||
|
||||
// The flatmap format doesn't allow us to distinguish between keys
|
||||
// that contain periods and nested objects, so by convention a
|
||||
// map is only ever of primitive type in flatmap, and we just assume
|
||||
// that the remainder of the raw key (dots and all) is the key we
|
||||
// want in the result value.
|
||||
key := fullKey[len(prefix):]
|
||||
if key == "%" {
|
||||
// Ignore the "count" key
|
||||
continue
|
||||
}
|
||||
|
||||
val, err := hcl2ValueFromFlatmapValue(m, fullKey, ety)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
vals[key] = val
|
||||
}
|
||||
|
||||
if len(vals) == 0 {
|
||||
return cty.MapValEmpty(ety), nil
|
||||
}
|
||||
return cty.MapVal(vals), nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapList(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) {
|
||||
var vals []cty.Value
|
||||
|
||||
// if the container is unknown, there is no count string
|
||||
listName := strings.TrimRight(prefix, ".")
|
||||
if m[listName] == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
countStr, exists := m[prefix+"#"]
|
||||
if !exists {
|
||||
return cty.NullVal(ty), nil
|
||||
}
|
||||
if countStr == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
count, err := strconv.Atoi(countStr)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, fmt.Errorf("invalid count value for %q in state: %s", prefix, err)
|
||||
}
|
||||
|
||||
ety := ty.ElementType()
|
||||
if count == 0 {
|
||||
return cty.ListValEmpty(ety), nil
|
||||
}
|
||||
|
||||
vals = make([]cty.Value, count)
|
||||
for i := 0; i < count; i++ {
|
||||
key := prefix + strconv.Itoa(i)
|
||||
val, err := hcl2ValueFromFlatmapValue(m, key, ety)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
vals[i] = val
|
||||
}
|
||||
|
||||
return cty.ListVal(vals), nil
|
||||
}
|
||||
|
||||
func hcl2ValueFromFlatmapSet(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) {
|
||||
var vals []cty.Value
|
||||
ety := ty.ElementType()
|
||||
|
||||
// if the container is unknown, there is no count string
|
||||
listName := strings.TrimRight(prefix, ".")
|
||||
if m[listName] == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
// We actually don't really care about the "count" of a set for our
|
||||
// purposes here, but we do need to check if it _exists_ in order to
|
||||
// recognize the difference between null (not set at all) and empty.
|
||||
if strCount, exists := m[prefix+"#"]; !exists {
|
||||
return cty.NullVal(ty), nil
|
||||
} else if strCount == UnknownVariableValue {
|
||||
return cty.UnknownVal(ty), nil
|
||||
}
|
||||
|
||||
// Keep track of keys we've seen, se we don't add the same set value
|
||||
// multiple times. The cty.Set will normally de-duplicate values, but we may
|
||||
// have unknown values that would not show as equivalent.
|
||||
seen := map[string]bool{}
|
||||
|
||||
for fullKey := range m {
|
||||
if !strings.HasPrefix(fullKey, prefix) {
|
||||
continue
|
||||
}
|
||||
subKey := fullKey[len(prefix):]
|
||||
if subKey == "#" {
|
||||
// Ignore the "count" key
|
||||
continue
|
||||
}
|
||||
key := fullKey
|
||||
if dot := strings.IndexByte(subKey, '.'); dot != -1 {
|
||||
key = fullKey[:dot+len(prefix)]
|
||||
}
|
||||
|
||||
if seen[key] {
|
||||
continue
|
||||
}
|
||||
|
||||
seen[key] = true
|
||||
|
||||
// The flatmap format doesn't allow us to distinguish between keys
|
||||
// that contain periods and nested objects, so by convention a
|
||||
// map is only ever of primitive type in flatmap, and we just assume
|
||||
// that the remainder of the raw key (dots and all) is the key we
|
||||
// want in the result value.
|
||||
|
||||
val, err := hcl2ValueFromFlatmapValue(m, key, ety)
|
||||
if err != nil {
|
||||
return cty.DynamicVal, err
|
||||
}
|
||||
vals = append(vals, val)
|
||||
}
|
||||
|
||||
if len(vals) == 0 {
|
||||
return cty.SetValEmpty(ety), nil
|
||||
}
|
||||
|
||||
return cty.SetVal(vals), nil
|
||||
}
|
||||
253
vendor/github.com/hashicorp/terraform/config/hcl2shim/paths.go
generated
vendored
Normal file
253
vendor/github.com/hashicorp/terraform/config/hcl2shim/paths.go
generated
vendored
Normal file
|
|
@ -0,0 +1,253 @@
|
|||
package hcl2shim
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// RequiresReplace takes a list of flatmapped paths from a
|
||||
// InstanceDiff.Attributes along with the corresponding cty.Type, and returns
|
||||
// the list of the cty.Paths that are flagged as causing the resource
|
||||
// replacement (RequiresNew).
|
||||
// This will filter out redundant paths, paths that refer to flatmapped indexes
|
||||
// (e.g. "#", "%"), and will return any changes within a set as the path to the
|
||||
// set itself.
|
||||
func RequiresReplace(attrs []string, ty cty.Type) ([]cty.Path, error) {
|
||||
var paths []cty.Path
|
||||
|
||||
for _, attr := range attrs {
|
||||
p, err := requiresReplacePath(attr, ty)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
paths = append(paths, p)
|
||||
}
|
||||
|
||||
// now trim off any trailing paths that aren't GetAttrSteps, since only an
|
||||
// attribute itself can require replacement
|
||||
paths = trimPaths(paths)
|
||||
|
||||
// There may be redundant paths due to set elements or index attributes
|
||||
// Do some ugly n^2 filtering, but these are always fairly small sets.
|
||||
for i := 0; i < len(paths)-1; i++ {
|
||||
for j := i + 1; j < len(paths); j++ {
|
||||
if reflect.DeepEqual(paths[i], paths[j]) {
|
||||
// swap the tail and slice it off
|
||||
paths[j], paths[len(paths)-1] = paths[len(paths)-1], paths[j]
|
||||
paths = paths[:len(paths)-1]
|
||||
j--
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return paths, nil
|
||||
}
|
||||
|
||||
// trimPaths removes any trailing steps that aren't of type GetAttrSet, since
|
||||
// only an attribute itself can require replacement
|
||||
func trimPaths(paths []cty.Path) []cty.Path {
|
||||
var trimmed []cty.Path
|
||||
for _, path := range paths {
|
||||
path = trimPath(path)
|
||||
if len(path) > 0 {
|
||||
trimmed = append(trimmed, path)
|
||||
}
|
||||
}
|
||||
return trimmed
|
||||
}
|
||||
|
||||
func trimPath(path cty.Path) cty.Path {
|
||||
for len(path) > 0 {
|
||||
_, isGetAttr := path[len(path)-1].(cty.GetAttrStep)
|
||||
if isGetAttr {
|
||||
break
|
||||
}
|
||||
path = path[:len(path)-1]
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
// requiresReplacePath takes a key from a flatmap along with the cty.Type
|
||||
// describing the structure, and returns the cty.Path that would be used to
|
||||
// reference the nested value in the data structure.
|
||||
// This is used specifically to record the RequiresReplace attributes from a
|
||||
// ResourceInstanceDiff.
|
||||
func requiresReplacePath(k string, ty cty.Type) (cty.Path, error) {
|
||||
if k == "" {
|
||||
return nil, nil
|
||||
}
|
||||
if !ty.IsObjectType() {
|
||||
panic(fmt.Sprintf("requires replace path on non-object type: %#v", ty))
|
||||
}
|
||||
|
||||
path, err := pathFromFlatmapKeyObject(k, ty.AttributeTypes())
|
||||
if err != nil {
|
||||
return path, fmt.Errorf("[%s] %s", k, err)
|
||||
}
|
||||
return path, nil
|
||||
}
|
||||
|
||||
func pathSplit(p string) (string, string) {
|
||||
parts := strings.SplitN(p, ".", 2)
|
||||
head := parts[0]
|
||||
rest := ""
|
||||
if len(parts) > 1 {
|
||||
rest = parts[1]
|
||||
}
|
||||
return head, rest
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeyObject(key string, atys map[string]cty.Type) (cty.Path, error) {
|
||||
k, rest := pathSplit(key)
|
||||
|
||||
path := cty.Path{cty.GetAttrStep{Name: k}}
|
||||
|
||||
ty, ok := atys[k]
|
||||
if !ok {
|
||||
return path, fmt.Errorf("attribute %q not found", k)
|
||||
}
|
||||
|
||||
if rest == "" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
p, err := pathFromFlatmapKeyValue(rest, ty)
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
return append(path, p...), nil
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeyValue(key string, ty cty.Type) (cty.Path, error) {
|
||||
var path cty.Path
|
||||
var err error
|
||||
|
||||
switch {
|
||||
case ty.IsPrimitiveType():
|
||||
err = fmt.Errorf("invalid step %q with type %#v", key, ty)
|
||||
case ty.IsObjectType():
|
||||
path, err = pathFromFlatmapKeyObject(key, ty.AttributeTypes())
|
||||
case ty.IsTupleType():
|
||||
path, err = pathFromFlatmapKeyTuple(key, ty.TupleElementTypes())
|
||||
case ty.IsMapType():
|
||||
path, err = pathFromFlatmapKeyMap(key, ty)
|
||||
case ty.IsListType():
|
||||
path, err = pathFromFlatmapKeyList(key, ty)
|
||||
case ty.IsSetType():
|
||||
path, err = pathFromFlatmapKeySet(key, ty)
|
||||
default:
|
||||
err = fmt.Errorf("unrecognized type: %s", ty.FriendlyName())
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
return path, nil
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeyTuple(key string, etys []cty.Type) (cty.Path, error) {
|
||||
var path cty.Path
|
||||
var err error
|
||||
|
||||
k, rest := pathSplit(key)
|
||||
|
||||
// we don't need to convert the index keys to paths
|
||||
if k == "#" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
idx, err := strconv.Atoi(k)
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
path = cty.Path{cty.IndexStep{Key: cty.NumberIntVal(int64(idx))}}
|
||||
|
||||
if idx >= len(etys) {
|
||||
return path, fmt.Errorf("index %s out of range in %#v", key, etys)
|
||||
}
|
||||
|
||||
if rest == "" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
ty := etys[idx]
|
||||
|
||||
p, err := pathFromFlatmapKeyValue(rest, ty.ElementType())
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
return append(path, p...), nil
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeyMap(key string, ty cty.Type) (cty.Path, error) {
|
||||
var path cty.Path
|
||||
var err error
|
||||
|
||||
k, rest := key, ""
|
||||
if !ty.ElementType().IsPrimitiveType() {
|
||||
k, rest = pathSplit(key)
|
||||
}
|
||||
|
||||
// we don't need to convert the index keys to paths
|
||||
if k == "%" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
path = cty.Path{cty.IndexStep{Key: cty.StringVal(k)}}
|
||||
|
||||
if rest == "" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
p, err := pathFromFlatmapKeyValue(rest, ty.ElementType())
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
return append(path, p...), nil
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeyList(key string, ty cty.Type) (cty.Path, error) {
|
||||
var path cty.Path
|
||||
var err error
|
||||
|
||||
k, rest := pathSplit(key)
|
||||
|
||||
// we don't need to convert the index keys to paths
|
||||
if key == "#" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
idx, err := strconv.Atoi(k)
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
path = cty.Path{cty.IndexStep{Key: cty.NumberIntVal(int64(idx))}}
|
||||
|
||||
if rest == "" {
|
||||
return path, nil
|
||||
}
|
||||
|
||||
p, err := pathFromFlatmapKeyValue(rest, ty.ElementType())
|
||||
if err != nil {
|
||||
return path, err
|
||||
}
|
||||
|
||||
return append(path, p...), nil
|
||||
}
|
||||
|
||||
func pathFromFlatmapKeySet(key string, ty cty.Type) (cty.Path, error) {
|
||||
// once we hit a set, we can't return consistent paths, so just mark the
|
||||
// set as a whole changed.
|
||||
return nil, nil
|
||||
}
|
||||
109
vendor/github.com/hashicorp/terraform/config/hcl2shim/values.go
generated
vendored
109
vendor/github.com/hashicorp/terraform/config/hcl2shim/values.go
generated
vendored
|
|
@ -6,6 +6,8 @@ import (
|
|||
|
||||
"github.com/hashicorp/hil/ast"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
)
|
||||
|
||||
// UnknownVariableValue is a sentinel value that can be used
|
||||
|
|
@ -14,6 +16,108 @@ import (
|
|||
// unknown keys.
|
||||
const UnknownVariableValue = "74D93920-ED26-11E3-AC10-0800200C9A66"
|
||||
|
||||
// ConfigValueFromHCL2Block is like ConfigValueFromHCL2 but it works only for
|
||||
// known object values and uses the provided block schema to perform some
|
||||
// additional normalization to better mimic the shape of value that the old
|
||||
// HCL1/HIL-based codepaths would've produced.
|
||||
//
|
||||
// In particular, it discards the collections that we use to represent nested
|
||||
// blocks (other than NestingSingle) if they are empty, which better mimics
|
||||
// the HCL1 behavior because HCL1 had no knowledge of the schema and so didn't
|
||||
// know that an unspecified block _could_ exist.
|
||||
//
|
||||
// The given object value must conform to the schema's implied type or this
|
||||
// function will panic or produce incorrect results.
|
||||
//
|
||||
// This is primarily useful for the final transition from new-style values to
|
||||
// terraform.ResourceConfig before calling to a legacy provider, since
|
||||
// helper/schema (the old provider SDK) is particularly sensitive to these
|
||||
// subtle differences within its validation code.
|
||||
func ConfigValueFromHCL2Block(v cty.Value, schema *configschema.Block) map[string]interface{} {
|
||||
if v.IsNull() {
|
||||
return nil
|
||||
}
|
||||
if !v.IsKnown() {
|
||||
panic("ConfigValueFromHCL2Block used with unknown value")
|
||||
}
|
||||
if !v.Type().IsObjectType() {
|
||||
panic(fmt.Sprintf("ConfigValueFromHCL2Block used with non-object value %#v", v))
|
||||
}
|
||||
|
||||
atys := v.Type().AttributeTypes()
|
||||
ret := make(map[string]interface{})
|
||||
|
||||
for name := range schema.Attributes {
|
||||
if _, exists := atys[name]; !exists {
|
||||
continue
|
||||
}
|
||||
|
||||
av := v.GetAttr(name)
|
||||
if av.IsNull() {
|
||||
// Skip nulls altogether, to better mimic how HCL1 would behave
|
||||
continue
|
||||
}
|
||||
ret[name] = ConfigValueFromHCL2(av)
|
||||
}
|
||||
|
||||
for name, blockS := range schema.BlockTypes {
|
||||
if _, exists := atys[name]; !exists {
|
||||
continue
|
||||
}
|
||||
bv := v.GetAttr(name)
|
||||
if !bv.IsKnown() {
|
||||
ret[name] = UnknownVariableValue
|
||||
continue
|
||||
}
|
||||
if bv.IsNull() {
|
||||
continue
|
||||
}
|
||||
|
||||
switch blockS.Nesting {
|
||||
|
||||
case configschema.NestingSingle:
|
||||
ret[name] = ConfigValueFromHCL2Block(bv, &blockS.Block)
|
||||
|
||||
case configschema.NestingList, configschema.NestingSet:
|
||||
l := bv.LengthInt()
|
||||
if l == 0 {
|
||||
// skip empty collections to better mimic how HCL1 would behave
|
||||
continue
|
||||
}
|
||||
|
||||
elems := make([]interface{}, 0, l)
|
||||
for it := bv.ElementIterator(); it.Next(); {
|
||||
_, ev := it.Element()
|
||||
if !ev.IsKnown() {
|
||||
elems = append(elems, UnknownVariableValue)
|
||||
continue
|
||||
}
|
||||
elems = append(elems, ConfigValueFromHCL2Block(ev, &blockS.Block))
|
||||
}
|
||||
ret[name] = elems
|
||||
|
||||
case configschema.NestingMap:
|
||||
if bv.LengthInt() == 0 {
|
||||
// skip empty collections to better mimic how HCL1 would behave
|
||||
continue
|
||||
}
|
||||
|
||||
elems := make(map[string]interface{})
|
||||
for it := bv.ElementIterator(); it.Next(); {
|
||||
ek, ev := it.Element()
|
||||
if !ev.IsKnown() {
|
||||
elems[ek.AsString()] = UnknownVariableValue
|
||||
continue
|
||||
}
|
||||
elems[ek.AsString()] = ConfigValueFromHCL2Block(ev, &blockS.Block)
|
||||
}
|
||||
ret[name] = elems
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
// ConfigValueFromHCL2 converts a value from HCL2 (really, from the cty dynamic
|
||||
// types library that HCL2 uses) to a value type that matches what would've
|
||||
// been produced from the HCL-based interpolator for an equivalent structure.
|
||||
|
|
@ -73,7 +177,10 @@ func ConfigValueFromHCL2(v cty.Value) interface{} {
|
|||
it := v.ElementIterator()
|
||||
for it.Next() {
|
||||
ek, ev := it.Element()
|
||||
l[ek.AsString()] = ConfigValueFromHCL2(ev)
|
||||
cv := ConfigValueFromHCL2(ev)
|
||||
if cv != nil {
|
||||
l[ek.AsString()] = cv
|
||||
}
|
||||
}
|
||||
return l
|
||||
}
|
||||
|
|
|
|||
4
vendor/github.com/hashicorp/terraform/config/module/storage.go
generated
vendored
4
vendor/github.com/hashicorp/terraform/config/module/storage.go
generated
vendored
|
|
@ -312,7 +312,7 @@ func (s Storage) findRegistryModule(mSource, constraint string) (moduleRecord, e
|
|||
// we need to lookup available versions
|
||||
// Only on Get if it's not found, on unconditionally on Update
|
||||
if (s.Mode == GetModeGet && !found) || (s.Mode == GetModeUpdate) {
|
||||
resp, err := s.registry.Versions(mod)
|
||||
resp, err := s.registry.ModuleVersions(mod)
|
||||
if err != nil {
|
||||
return rec, err
|
||||
}
|
||||
|
|
@ -332,7 +332,7 @@ func (s Storage) findRegistryModule(mSource, constraint string) (moduleRecord, e
|
|||
|
||||
rec.Version = match.Version
|
||||
|
||||
rec.url, err = s.registry.Location(mod, rec.Version)
|
||||
rec.url, err = s.registry.ModuleLocation(mod, rec.Version)
|
||||
if err != nil {
|
||||
return rec, err
|
||||
}
|
||||
|
|
|
|||
55
vendor/github.com/hashicorp/terraform/configs/backend.go
generated
vendored
Normal file
55
vendor/github.com/hashicorp/terraform/configs/backend.go
generated
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcldec"
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// Backend represents a "backend" block inside a "terraform" block in a module
|
||||
// or file.
|
||||
type Backend struct {
|
||||
Type string
|
||||
Config hcl.Body
|
||||
|
||||
TypeRange hcl.Range
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeBackendBlock(block *hcl.Block) (*Backend, hcl.Diagnostics) {
|
||||
return &Backend{
|
||||
Type: block.Labels[0],
|
||||
TypeRange: block.LabelRanges[0],
|
||||
Config: block.Body,
|
||||
DeclRange: block.DefRange,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Hash produces a hash value for the reciever that covers the type and the
|
||||
// portions of the config that conform to the given schema.
|
||||
//
|
||||
// If the config does not conform to the schema then the result is not
|
||||
// meaningful for comparison since it will be based on an incomplete result.
|
||||
//
|
||||
// As an exception, required attributes in the schema are treated as optional
|
||||
// for the purpose of hashing, so that an incomplete configuration can still
|
||||
// be hashed. Other errors, such as extraneous attributes, have no such special
|
||||
// case.
|
||||
func (b *Backend) Hash(schema *configschema.Block) int {
|
||||
// Don't fail if required attributes are not set. Instead, we'll just
|
||||
// hash them as nulls.
|
||||
schema = schema.NoneRequired()
|
||||
spec := schema.DecoderSpec()
|
||||
val, _ := hcldec.Decode(b.Config, spec, nil)
|
||||
if val == cty.NilVal {
|
||||
val = cty.UnknownVal(schema.ImpliedType())
|
||||
}
|
||||
|
||||
toHash := cty.TupleVal([]cty.Value{
|
||||
cty.StringVal(b.Type),
|
||||
val,
|
||||
})
|
||||
|
||||
return toHash.Hash()
|
||||
}
|
||||
116
vendor/github.com/hashicorp/terraform/configs/compat_shim.go
generated
vendored
Normal file
116
vendor/github.com/hashicorp/terraform/configs/compat_shim.go
generated
vendored
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Functions in this file are compatibility shims intended to ease conversion
|
||||
// from the old configuration loader. Any use of these functions that makes
|
||||
// a change should generate a deprecation warning explaining to the user how
|
||||
// to update their code for new patterns.
|
||||
//
|
||||
// Shims are particularly important for any patterns that have been widely
|
||||
// documented in books, tutorials, etc. Users will still be starting from
|
||||
// these examples and we want to help them adopt the latest patterns rather
|
||||
// than leave them stranded.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// shimTraversalInString takes any arbitrary expression and checks if it is
|
||||
// a quoted string in the native syntax. If it _is_, then it is parsed as a
|
||||
// traversal and re-wrapped into a synthetic traversal expression and a
|
||||
// warning is generated. Otherwise, the given expression is just returned
|
||||
// verbatim.
|
||||
//
|
||||
// This function has no effect on expressions from the JSON syntax, since
|
||||
// traversals in strings are the required pattern in that syntax.
|
||||
//
|
||||
// If wantKeyword is set, the generated warning diagnostic will talk about
|
||||
// keywords rather than references. The behavior is otherwise unchanged, and
|
||||
// the caller remains responsible for checking that the result is indeed
|
||||
// a keyword, e.g. using hcl.ExprAsKeyword.
|
||||
func shimTraversalInString(expr hcl.Expression, wantKeyword bool) (hcl.Expression, hcl.Diagnostics) {
|
||||
// ObjectConsKeyExpr is a special wrapper type used for keys on object
|
||||
// constructors to deal with the fact that naked identifiers are normally
|
||||
// handled as "bareword" strings rather than as variable references. Since
|
||||
// we know we're interpreting as a traversal anyway (and thus it won't
|
||||
// matter whether it's a string or an identifier) we can safely just unwrap
|
||||
// here and then process whatever we find inside as normal.
|
||||
if ocke, ok := expr.(*hclsyntax.ObjectConsKeyExpr); ok {
|
||||
expr = ocke.Wrapped
|
||||
}
|
||||
|
||||
if !exprIsNativeQuotedString(expr) {
|
||||
return expr, nil
|
||||
}
|
||||
|
||||
strVal, diags := expr.Value(nil)
|
||||
if diags.HasErrors() || strVal.IsNull() || !strVal.IsKnown() {
|
||||
// Since we're not even able to attempt a shim here, we'll discard
|
||||
// the diagnostics we saw so far and let the caller's own error
|
||||
// handling take care of reporting the invalid expression.
|
||||
return expr, nil
|
||||
}
|
||||
|
||||
// The position handling here isn't _quite_ right because it won't
|
||||
// take into account any escape sequences in the literal string, but
|
||||
// it should be close enough for any error reporting to make sense.
|
||||
srcRange := expr.Range()
|
||||
startPos := srcRange.Start // copy
|
||||
startPos.Column++ // skip initial quote
|
||||
startPos.Byte++ // skip initial quote
|
||||
|
||||
traversal, tDiags := hclsyntax.ParseTraversalAbs(
|
||||
[]byte(strVal.AsString()),
|
||||
srcRange.Filename,
|
||||
startPos,
|
||||
)
|
||||
diags = append(diags, tDiags...)
|
||||
|
||||
// For initial release our deprecation warnings are disabled to allow
|
||||
// a period where modules can be compatible with both old and new
|
||||
// conventions.
|
||||
// FIXME: Re-enable these deprecation warnings in a release prior to
|
||||
// Terraform 0.13 and then remove the shims altogether for 0.13.
|
||||
/*
|
||||
if wantKeyword {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagWarning,
|
||||
Summary: "Quoted keywords are deprecated",
|
||||
Detail: "In this context, keywords are expected literally rather than in quotes. Previous versions of Terraform required quotes, but that usage is now deprecated. Remove the quotes surrounding this keyword to silence this warning.",
|
||||
Subject: &srcRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagWarning,
|
||||
Summary: "Quoted references are deprecated",
|
||||
Detail: "In this context, references are expected literally rather than in quotes. Previous versions of Terraform required quotes, but that usage is now deprecated. Remove the quotes surrounding this reference to silence this warning.",
|
||||
Subject: &srcRange,
|
||||
})
|
||||
}
|
||||
*/
|
||||
|
||||
return &hclsyntax.ScopeTraversalExpr{
|
||||
Traversal: traversal,
|
||||
SrcRange: srcRange,
|
||||
}, diags
|
||||
}
|
||||
|
||||
// shimIsIgnoreChangesStar returns true if the given expression seems to be
|
||||
// a string literal whose value is "*". This is used to support a legacy
|
||||
// form of ignore_changes = all .
|
||||
//
|
||||
// This function does not itself emit any diagnostics, so it's the caller's
|
||||
// responsibility to emit a warning diagnostic when this function returns true.
|
||||
func shimIsIgnoreChangesStar(expr hcl.Expression) bool {
|
||||
val, valDiags := expr.Value(nil)
|
||||
if valDiags.HasErrors() {
|
||||
return false
|
||||
}
|
||||
if val.Type() != cty.String || val.IsNull() || !val.IsKnown() {
|
||||
return false
|
||||
}
|
||||
return val.AsString() == "*"
|
||||
}
|
||||
205
vendor/github.com/hashicorp/terraform/configs/config.go
generated
vendored
Normal file
205
vendor/github.com/hashicorp/terraform/configs/config.go
generated
vendored
Normal file
|
|
@ -0,0 +1,205 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// A Config is a node in the tree of modules within a configuration.
|
||||
//
|
||||
// The module tree is constructed by following ModuleCall instances recursively
|
||||
// through the root module transitively into descendent modules.
|
||||
//
|
||||
// A module tree described in *this* package represents the static tree
|
||||
// represented by configuration. During evaluation a static ModuleNode may
|
||||
// expand into zero or more module instances depending on the use of count and
|
||||
// for_each configuration attributes within each call.
|
||||
type Config struct {
|
||||
// RootModule points to the Config for the root module within the same
|
||||
// module tree as this module. If this module _is_ the root module then
|
||||
// this is self-referential.
|
||||
Root *Config
|
||||
|
||||
// ParentModule points to the Config for the module that directly calls
|
||||
// this module. If this is the root module then this field is nil.
|
||||
Parent *Config
|
||||
|
||||
// Path is a sequence of module logical names that traverse from the root
|
||||
// module to this config. Path is empty for the root module.
|
||||
//
|
||||
// This should only be used to display paths to the end-user in rare cases
|
||||
// where we are talking about the static module tree, before module calls
|
||||
// have been resolved. In most cases, a addrs.ModuleInstance describing
|
||||
// a node in the dynamic module tree is better, since it will then include
|
||||
// any keys resulting from evaluating "count" and "for_each" arguments.
|
||||
Path addrs.Module
|
||||
|
||||
// ChildModules points to the Config for each of the direct child modules
|
||||
// called from this module. The keys in this map match the keys in
|
||||
// Module.ModuleCalls.
|
||||
Children map[string]*Config
|
||||
|
||||
// Module points to the object describing the configuration for the
|
||||
// various elements (variables, resources, etc) defined by this module.
|
||||
Module *Module
|
||||
|
||||
// CallRange is the source range for the header of the module block that
|
||||
// requested this module.
|
||||
//
|
||||
// This field is meaningless for the root module, where its contents are undefined.
|
||||
CallRange hcl.Range
|
||||
|
||||
// SourceAddr is the source address that the referenced module was requested
|
||||
// from, as specified in configuration.
|
||||
//
|
||||
// This field is meaningless for the root module, where its contents are undefined.
|
||||
SourceAddr string
|
||||
|
||||
// SourceAddrRange is the location in the configuration source where the
|
||||
// SourceAddr value was set, for use in diagnostic messages.
|
||||
//
|
||||
// This field is meaningless for the root module, where its contents are undefined.
|
||||
SourceAddrRange hcl.Range
|
||||
|
||||
// Version is the specific version that was selected for this module,
|
||||
// based on version constraints given in configuration.
|
||||
//
|
||||
// This field is nil if the module was loaded from a non-registry source,
|
||||
// since versions are not supported for other sources.
|
||||
//
|
||||
// This field is meaningless for the root module, where it will always
|
||||
// be nil.
|
||||
Version *version.Version
|
||||
}
|
||||
|
||||
// NewEmptyConfig constructs a single-node configuration tree with an empty
|
||||
// root module. This is generally a pretty useless thing to do, so most callers
|
||||
// should instead use BuildConfig.
|
||||
func NewEmptyConfig() *Config {
|
||||
ret := &Config{}
|
||||
ret.Root = ret
|
||||
ret.Children = make(map[string]*Config)
|
||||
ret.Module = &Module{}
|
||||
return ret
|
||||
}
|
||||
|
||||
// Depth returns the number of "hops" the receiver is from the root of its
|
||||
// module tree, with the root module having a depth of zero.
|
||||
func (c *Config) Depth() int {
|
||||
ret := 0
|
||||
this := c
|
||||
for this.Parent != nil {
|
||||
ret++
|
||||
this = this.Parent
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// DeepEach calls the given function once for each module in the tree, starting
|
||||
// with the receiver.
|
||||
//
|
||||
// A parent is always called before its children and children of a particular
|
||||
// node are visited in lexicographic order by their names.
|
||||
func (c *Config) DeepEach(cb func(c *Config)) {
|
||||
cb(c)
|
||||
|
||||
names := make([]string, 0, len(c.Children))
|
||||
for name := range c.Children {
|
||||
names = append(names, name)
|
||||
}
|
||||
|
||||
for _, name := range names {
|
||||
c.Children[name].DeepEach(cb)
|
||||
}
|
||||
}
|
||||
|
||||
// AllModules returns a slice of all the receiver and all of its descendent
|
||||
// nodes in the module tree, in the same order they would be visited by
|
||||
// DeepEach.
|
||||
func (c *Config) AllModules() []*Config {
|
||||
var ret []*Config
|
||||
c.DeepEach(func(c *Config) {
|
||||
ret = append(ret, c)
|
||||
})
|
||||
return ret
|
||||
}
|
||||
|
||||
// Descendent returns the descendent config that has the given path beneath
|
||||
// the receiver, or nil if there is no such module.
|
||||
//
|
||||
// The path traverses the static module tree, prior to any expansion to handle
|
||||
// count and for_each arguments.
|
||||
//
|
||||
// An empty path will just return the receiver, and is therefore pointless.
|
||||
func (c *Config) Descendent(path addrs.Module) *Config {
|
||||
current := c
|
||||
for _, name := range path {
|
||||
current = current.Children[name]
|
||||
if current == nil {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return current
|
||||
}
|
||||
|
||||
// DescendentForInstance is like Descendent except that it accepts a path
|
||||
// to a particular module instance in the dynamic module graph, returning
|
||||
// the node from the static module graph that corresponds to it.
|
||||
//
|
||||
// All instances created by a particular module call share the same
|
||||
// configuration, so the keys within the given path are disregarded.
|
||||
func (c *Config) DescendentForInstance(path addrs.ModuleInstance) *Config {
|
||||
current := c
|
||||
for _, step := range path {
|
||||
current = current.Children[step.Name]
|
||||
if current == nil {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return current
|
||||
}
|
||||
|
||||
// ProviderTypes returns the names of each distinct provider type referenced
|
||||
// in the receiving configuration.
|
||||
//
|
||||
// This is a helper for easily determining which provider types are required
|
||||
// to fully interpret the configuration, though it does not include version
|
||||
// information and so callers are expected to have already dealt with
|
||||
// provider version selection in an earlier step and have identified suitable
|
||||
// versions for each provider.
|
||||
func (c *Config) ProviderTypes() []string {
|
||||
m := make(map[string]struct{})
|
||||
c.gatherProviderTypes(m)
|
||||
|
||||
ret := make([]string, 0, len(m))
|
||||
for k := range m {
|
||||
ret = append(ret, k)
|
||||
}
|
||||
sort.Strings(ret)
|
||||
return ret
|
||||
}
|
||||
func (c *Config) gatherProviderTypes(m map[string]struct{}) {
|
||||
if c == nil {
|
||||
return
|
||||
}
|
||||
|
||||
for _, pc := range c.Module.ProviderConfigs {
|
||||
m[pc.Name] = struct{}{}
|
||||
}
|
||||
for _, rc := range c.Module.ManagedResources {
|
||||
providerAddr := rc.ProviderConfigAddr()
|
||||
m[providerAddr.Type] = struct{}{}
|
||||
}
|
||||
for _, rc := range c.Module.DataResources {
|
||||
providerAddr := rc.ProviderConfigAddr()
|
||||
m[providerAddr.Type] = struct{}{}
|
||||
}
|
||||
|
||||
// Must also visit our child modules, recursively.
|
||||
for _, cc := range c.Children {
|
||||
cc.gatherProviderTypes(m)
|
||||
}
|
||||
}
|
||||
179
vendor/github.com/hashicorp/terraform/configs/config_build.go
generated
vendored
Normal file
179
vendor/github.com/hashicorp/terraform/configs/config_build.go
generated
vendored
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// BuildConfig constructs a Config from a root module by loading all of its
|
||||
// descendent modules via the given ModuleWalker.
|
||||
//
|
||||
// The result is a module tree that has so far only had basic module- and
|
||||
// file-level invariants validated. If the returned diagnostics contains errors,
|
||||
// the returned module tree may be incomplete but can still be used carefully
|
||||
// for static analysis.
|
||||
func BuildConfig(root *Module, walker ModuleWalker) (*Config, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
cfg := &Config{
|
||||
Module: root,
|
||||
}
|
||||
cfg.Root = cfg // Root module is self-referential.
|
||||
cfg.Children, diags = buildChildModules(cfg, walker)
|
||||
return cfg, diags
|
||||
}
|
||||
|
||||
func buildChildModules(parent *Config, walker ModuleWalker) (map[string]*Config, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
ret := map[string]*Config{}
|
||||
|
||||
calls := parent.Module.ModuleCalls
|
||||
|
||||
// We'll sort the calls by their local names so that they'll appear in a
|
||||
// predictable order in any logging that's produced during the walk.
|
||||
callNames := make([]string, 0, len(calls))
|
||||
for k := range calls {
|
||||
callNames = append(callNames, k)
|
||||
}
|
||||
sort.Strings(callNames)
|
||||
|
||||
for _, callName := range callNames {
|
||||
call := calls[callName]
|
||||
path := make([]string, len(parent.Path)+1)
|
||||
copy(path, parent.Path)
|
||||
path[len(path)-1] = call.Name
|
||||
|
||||
req := ModuleRequest{
|
||||
Name: call.Name,
|
||||
Path: path,
|
||||
SourceAddr: call.SourceAddr,
|
||||
SourceAddrRange: call.SourceAddrRange,
|
||||
VersionConstraint: call.Version,
|
||||
Parent: parent,
|
||||
CallRange: call.DeclRange,
|
||||
}
|
||||
|
||||
mod, ver, modDiags := walker.LoadModule(&req)
|
||||
diags = append(diags, modDiags...)
|
||||
if mod == nil {
|
||||
// nil can be returned if the source address was invalid and so
|
||||
// nothing could be loaded whatsoever. LoadModule should've
|
||||
// returned at least one error diagnostic in that case.
|
||||
continue
|
||||
}
|
||||
|
||||
child := &Config{
|
||||
Parent: parent,
|
||||
Root: parent.Root,
|
||||
Path: path,
|
||||
Module: mod,
|
||||
CallRange: call.DeclRange,
|
||||
SourceAddr: call.SourceAddr,
|
||||
SourceAddrRange: call.SourceAddrRange,
|
||||
Version: ver,
|
||||
}
|
||||
|
||||
child.Children, modDiags = buildChildModules(child, walker)
|
||||
|
||||
ret[call.Name] = child
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
// A ModuleWalker knows how to find and load a child module given details about
|
||||
// the module to be loaded and a reference to its partially-loaded parent
|
||||
// Config.
|
||||
type ModuleWalker interface {
|
||||
// LoadModule finds and loads a requested child module.
|
||||
//
|
||||
// If errors are detected during loading, implementations should return them
|
||||
// in the diagnostics object. If the diagnostics object contains any errors
|
||||
// then the caller will tolerate the returned module being nil or incomplete.
|
||||
// If no errors are returned, it should be non-nil and complete.
|
||||
//
|
||||
// Full validation need not have been performed but an implementation should
|
||||
// ensure that the basic file- and module-validations performed by the
|
||||
// LoadConfigDir function (valid syntax, no namespace collisions, etc) have
|
||||
// been performed before returning a module.
|
||||
LoadModule(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics)
|
||||
}
|
||||
|
||||
// ModuleWalkerFunc is an implementation of ModuleWalker that directly wraps
|
||||
// a callback function, for more convenient use of that interface.
|
||||
type ModuleWalkerFunc func(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics)
|
||||
|
||||
// LoadModule implements ModuleWalker.
|
||||
func (f ModuleWalkerFunc) LoadModule(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics) {
|
||||
return f(req)
|
||||
}
|
||||
|
||||
// ModuleRequest is used with the ModuleWalker interface to describe a child
|
||||
// module that must be loaded.
|
||||
type ModuleRequest struct {
|
||||
// Name is the "logical name" of the module call within configuration.
|
||||
// This is provided in case the name is used as part of a storage key
|
||||
// for the module, but implementations must otherwise treat it as an
|
||||
// opaque string. It is guaranteed to have already been validated as an
|
||||
// HCL identifier and UTF-8 encoded.
|
||||
Name string
|
||||
|
||||
// Path is a list of logical names that traverse from the root module to
|
||||
// this module. This can be used, for example, to form a lookup key for
|
||||
// each distinct module call in a configuration, allowing for multiple
|
||||
// calls with the same name at different points in the tree.
|
||||
Path addrs.Module
|
||||
|
||||
// SourceAddr is the source address string provided by the user in
|
||||
// configuration.
|
||||
SourceAddr string
|
||||
|
||||
// SourceAddrRange is the source range for the SourceAddr value as it
|
||||
// was provided in configuration. This can and should be used to generate
|
||||
// diagnostics about the source address having invalid syntax, referring
|
||||
// to a non-existent object, etc.
|
||||
SourceAddrRange hcl.Range
|
||||
|
||||
// VersionConstraint is the version constraint applied to the module in
|
||||
// configuration. This data structure includes the source range for
|
||||
// the constraint, which can and should be used to generate diagnostics
|
||||
// about constraint-related issues, such as constraints that eliminate all
|
||||
// available versions of a module whose source is otherwise valid.
|
||||
VersionConstraint VersionConstraint
|
||||
|
||||
// Parent is the partially-constructed module tree node that the loaded
|
||||
// module will be added to. Callers may refer to any field of this
|
||||
// structure except Children, which is still under construction when
|
||||
// ModuleRequest objects are created and thus has undefined content.
|
||||
// The main reason this is provided is so that full module paths can
|
||||
// be constructed for uniqueness.
|
||||
Parent *Config
|
||||
|
||||
// CallRange is the source range for the header of the "module" block
|
||||
// in configuration that prompted this request. This can be used as the
|
||||
// subject of an error diagnostic that relates to the module call itself,
|
||||
// rather than to either its source address or its version number.
|
||||
CallRange hcl.Range
|
||||
}
|
||||
|
||||
// DisabledModuleWalker is a ModuleWalker that doesn't support
|
||||
// child modules at all, and so will return an error if asked to load one.
|
||||
//
|
||||
// This is provided primarily for testing. There is no good reason to use this
|
||||
// in the main application.
|
||||
var DisabledModuleWalker ModuleWalker
|
||||
|
||||
func init() {
|
||||
DisabledModuleWalker = ModuleWalkerFunc(func(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics) {
|
||||
return nil, nil, hcl.Diagnostics{
|
||||
{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Child modules are not supported",
|
||||
Detail: "Child module calls are not allowed in this context.",
|
||||
Subject: &req.CallRange,
|
||||
},
|
||||
}
|
||||
})
|
||||
}
|
||||
114
vendor/github.com/hashicorp/terraform/configs/configload/copy_dir.go
generated
vendored
Normal file
114
vendor/github.com/hashicorp/terraform/configs/configload/copy_dir.go
generated
vendored
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// copyDir copies the src directory contents into dst. Both directories
|
||||
// should already exist.
|
||||
func copyDir(dst, src string) error {
|
||||
src, err := filepath.EvalSymlinks(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
walkFn := func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if path == src {
|
||||
return nil
|
||||
}
|
||||
|
||||
if strings.HasPrefix(filepath.Base(path), ".") {
|
||||
// Skip any dot files
|
||||
if info.IsDir() {
|
||||
return filepath.SkipDir
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// The "path" has the src prefixed to it. We need to join our
|
||||
// destination with the path without the src on it.
|
||||
dstPath := filepath.Join(dst, path[len(src):])
|
||||
|
||||
// we don't want to try and copy the same file over itself.
|
||||
if eq, err := sameFile(path, dstPath); eq {
|
||||
return nil
|
||||
} else if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// If we have a directory, make that subdirectory, then continue
|
||||
// the walk.
|
||||
if info.IsDir() {
|
||||
if path == filepath.Join(src, dst) {
|
||||
// dst is in src; don't walk it.
|
||||
return nil
|
||||
}
|
||||
|
||||
if err := os.MkdirAll(dstPath, 0755); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// If we have a file, copy the contents.
|
||||
srcF, err := os.Open(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer srcF.Close()
|
||||
|
||||
dstF, err := os.Create(dstPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer dstF.Close()
|
||||
|
||||
if _, err := io.Copy(dstF, srcF); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Chmod it
|
||||
return os.Chmod(dstPath, info.Mode())
|
||||
}
|
||||
|
||||
return filepath.Walk(src, walkFn)
|
||||
}
|
||||
|
||||
// sameFile tried to determine if to paths are the same file.
|
||||
// If the paths don't match, we lookup the inode on supported systems.
|
||||
func sameFile(a, b string) (bool, error) {
|
||||
if a == b {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
aIno, err := inode(a)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return false, nil
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
|
||||
bIno, err := inode(b)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return false, nil
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
|
||||
if aIno > 0 && aIno == bIno {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
return false, nil
|
||||
}
|
||||
4
vendor/github.com/hashicorp/terraform/configs/configload/doc.go
generated
vendored
Normal file
4
vendor/github.com/hashicorp/terraform/configs/configload/doc.go
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
// Package configload knows how to install modules into the .terraform/modules
|
||||
// directory and to load modules from those installed locations. It is used
|
||||
// in conjunction with the LoadConfig function in the parent package.
|
||||
package configload
|
||||
150
vendor/github.com/hashicorp/terraform/configs/configload/getter.go
generated
vendored
Normal file
150
vendor/github.com/hashicorp/terraform/configs/configload/getter.go
generated
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
cleanhttp "github.com/hashicorp/go-cleanhttp"
|
||||
getter "github.com/hashicorp/go-getter"
|
||||
)
|
||||
|
||||
// We configure our own go-getter detector and getter sets here, because
|
||||
// the set of sources we support is part of Terraform's documentation and
|
||||
// so we don't want any new sources introduced in go-getter to sneak in here
|
||||
// and work even though they aren't documented. This also insulates us from
|
||||
// any meddling that might be done by other go-getter callers linked into our
|
||||
// executable.
|
||||
|
||||
var goGetterDetectors = []getter.Detector{
|
||||
new(getter.GitHubDetector),
|
||||
new(getter.BitBucketDetector),
|
||||
new(getter.S3Detector),
|
||||
new(getter.FileDetector),
|
||||
}
|
||||
|
||||
var goGetterNoDetectors = []getter.Detector{}
|
||||
|
||||
var goGetterDecompressors = map[string]getter.Decompressor{
|
||||
"bz2": new(getter.Bzip2Decompressor),
|
||||
"gz": new(getter.GzipDecompressor),
|
||||
"xz": new(getter.XzDecompressor),
|
||||
"zip": new(getter.ZipDecompressor),
|
||||
|
||||
"tar.bz2": new(getter.TarBzip2Decompressor),
|
||||
"tar.tbz2": new(getter.TarBzip2Decompressor),
|
||||
|
||||
"tar.gz": new(getter.TarGzipDecompressor),
|
||||
"tgz": new(getter.TarGzipDecompressor),
|
||||
|
||||
"tar.xz": new(getter.TarXzDecompressor),
|
||||
"txz": new(getter.TarXzDecompressor),
|
||||
}
|
||||
|
||||
var goGetterGetters = map[string]getter.Getter{
|
||||
"file": new(getter.FileGetter),
|
||||
"git": new(getter.GitGetter),
|
||||
"hg": new(getter.HgGetter),
|
||||
"s3": new(getter.S3Getter),
|
||||
"http": getterHTTPGetter,
|
||||
"https": getterHTTPGetter,
|
||||
}
|
||||
|
||||
var getterHTTPClient = cleanhttp.DefaultClient()
|
||||
|
||||
var getterHTTPGetter = &getter.HttpGetter{
|
||||
Client: getterHTTPClient,
|
||||
Netrc: true,
|
||||
}
|
||||
|
||||
// A reusingGetter is a helper for the module installer that remembers
|
||||
// the final resolved addresses of all of the sources it has already been
|
||||
// asked to install, and will copy from a prior installation directory if
|
||||
// it has the same resolved source address.
|
||||
//
|
||||
// The keys in a reusingGetter are resolved and trimmed source addresses
|
||||
// (with a scheme always present, and without any "subdir" component),
|
||||
// and the values are the paths where each source was previously installed.
|
||||
type reusingGetter map[string]string
|
||||
|
||||
// getWithGoGetter retrieves the package referenced in the given address
|
||||
// into the installation path and then returns the full path to any subdir
|
||||
// indicated in the address.
|
||||
//
|
||||
// The errors returned by this function are those surfaced by the underlying
|
||||
// go-getter library, which have very inconsistent quality as
|
||||
// end-user-actionable error messages. At this time we do not have any
|
||||
// reasonable way to improve these error messages at this layer because
|
||||
// the underlying errors are not separatelyr recognizable.
|
||||
func (g reusingGetter) getWithGoGetter(instPath, addr string) (string, error) {
|
||||
packageAddr, subDir := splitAddrSubdir(addr)
|
||||
|
||||
log.Printf("[DEBUG] will download %q to %s", packageAddr, instPath)
|
||||
|
||||
realAddr, err := getter.Detect(packageAddr, instPath, getter.Detectors)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
var realSubDir string
|
||||
realAddr, realSubDir = splitAddrSubdir(realAddr)
|
||||
if realSubDir != "" {
|
||||
subDir = filepath.Join(realSubDir, subDir)
|
||||
}
|
||||
|
||||
if realAddr != packageAddr {
|
||||
log.Printf("[TRACE] go-getter detectors rewrote %q to %q", packageAddr, realAddr)
|
||||
}
|
||||
|
||||
if prevDir, exists := g[realAddr]; exists {
|
||||
log.Printf("[TRACE] copying previous install %s to %s", prevDir, instPath)
|
||||
err := os.Mkdir(instPath, os.ModePerm)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("failed to create directory %s: %s", instPath, err)
|
||||
}
|
||||
err = copyDir(instPath, prevDir)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("failed to copy from %s to %s: %s", prevDir, instPath, err)
|
||||
}
|
||||
} else {
|
||||
log.Printf("[TRACE] fetching %q to %q", realAddr, instPath)
|
||||
client := getter.Client{
|
||||
Src: realAddr,
|
||||
Dst: instPath,
|
||||
Pwd: instPath,
|
||||
|
||||
Mode: getter.ClientModeDir,
|
||||
|
||||
Detectors: goGetterNoDetectors, // we already did detection above
|
||||
Decompressors: goGetterDecompressors,
|
||||
Getters: goGetterGetters,
|
||||
}
|
||||
err = client.Get()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
// Remember where we installed this so we might reuse this directory
|
||||
// on subsequent calls to avoid re-downloading.
|
||||
g[realAddr] = instPath
|
||||
}
|
||||
|
||||
// Our subDir string can contain wildcards until this point, so that
|
||||
// e.g. a subDir of * can expand to one top-level directory in a .tar.gz
|
||||
// archive. Now that we've expanded the archive successfully we must
|
||||
// resolve that into a concrete path.
|
||||
var finalDir string
|
||||
if subDir != "" {
|
||||
finalDir, err = getter.SubdirGlob(instPath, subDir)
|
||||
log.Printf("[TRACE] expanded %q to %q", subDir, finalDir)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
} else {
|
||||
finalDir = instPath
|
||||
}
|
||||
|
||||
// If we got this far then we have apparently succeeded in downloading
|
||||
// the requested object!
|
||||
return filepath.Clean(finalDir), nil
|
||||
}
|
||||
21
vendor/github.com/hashicorp/terraform/configs/configload/inode.go
generated
vendored
Normal file
21
vendor/github.com/hashicorp/terraform/configs/configload/inode.go
generated
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
// +build linux darwin openbsd netbsd solaris dragonfly
|
||||
|
||||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
// lookup the inode of a file on posix systems
|
||||
func inode(path string) (uint64, error) {
|
||||
stat, err := os.Stat(path)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if st, ok := stat.Sys().(*syscall.Stat_t); ok {
|
||||
return st.Ino, nil
|
||||
}
|
||||
return 0, fmt.Errorf("could not determine file inode")
|
||||
}
|
||||
21
vendor/github.com/hashicorp/terraform/configs/configload/inode_freebsd.go
generated
vendored
Normal file
21
vendor/github.com/hashicorp/terraform/configs/configload/inode_freebsd.go
generated
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
// +build freebsd
|
||||
|
||||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
// lookup the inode of a file on posix systems
|
||||
func inode(path string) (uint64, error) {
|
||||
stat, err := os.Stat(path)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if st, ok := stat.Sys().(*syscall.Stat_t); ok {
|
||||
return uint64(st.Ino), nil
|
||||
}
|
||||
return 0, fmt.Errorf("could not determine file inode")
|
||||
}
|
||||
8
vendor/github.com/hashicorp/terraform/configs/configload/inode_windows.go
generated
vendored
Normal file
8
vendor/github.com/hashicorp/terraform/configs/configload/inode_windows.go
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
// +build windows
|
||||
|
||||
package configload
|
||||
|
||||
// no syscall.Stat_t on windows, return 0 for inodes
|
||||
func inode(path string) (uint64, error) {
|
||||
return 0, nil
|
||||
}
|
||||
126
vendor/github.com/hashicorp/terraform/configs/configload/loader.go
generated
vendored
Normal file
126
vendor/github.com/hashicorp/terraform/configs/configload/loader.go
generated
vendored
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
"github.com/hashicorp/terraform/registry"
|
||||
"github.com/hashicorp/terraform/svchost/disco"
|
||||
"github.com/spf13/afero"
|
||||
)
|
||||
|
||||
// A Loader instance is the main entry-point for loading configurations via
|
||||
// this package.
|
||||
//
|
||||
// It extends the general config-loading functionality in the parent package
|
||||
// "configs" to support installation of modules from remote sources and
|
||||
// loading full configurations using modules that were previously installed.
|
||||
type Loader struct {
|
||||
// parser is used to read configuration
|
||||
parser *configs.Parser
|
||||
|
||||
// modules is used to install and locate descendent modules that are
|
||||
// referenced (directly or indirectly) from the root module.
|
||||
modules moduleMgr
|
||||
}
|
||||
|
||||
// Config is used with NewLoader to specify configuration arguments for the
|
||||
// loader.
|
||||
type Config struct {
|
||||
// ModulesDir is a path to a directory where descendent modules are
|
||||
// (or should be) installed. (This is usually the
|
||||
// .terraform/modules directory, in the common case where this package
|
||||
// is being loaded from the main Terraform CLI package.)
|
||||
ModulesDir string
|
||||
|
||||
// Services is the service discovery client to use when locating remote
|
||||
// module registry endpoints. If this is nil then registry sources are
|
||||
// not supported, which should be true only in specialized circumstances
|
||||
// such as in tests.
|
||||
Services *disco.Disco
|
||||
}
|
||||
|
||||
// NewLoader creates and returns a loader that reads configuration from the
|
||||
// real OS filesystem.
|
||||
//
|
||||
// The loader has some internal state about the modules that are currently
|
||||
// installed, which is read from disk as part of this function. If that
|
||||
// manifest cannot be read then an error will be returned.
|
||||
func NewLoader(config *Config) (*Loader, error) {
|
||||
fs := afero.NewOsFs()
|
||||
parser := configs.NewParser(fs)
|
||||
reg := registry.NewClient(config.Services, nil)
|
||||
|
||||
ret := &Loader{
|
||||
parser: parser,
|
||||
modules: moduleMgr{
|
||||
FS: afero.Afero{Fs: fs},
|
||||
CanInstall: true,
|
||||
Dir: config.ModulesDir,
|
||||
Services: config.Services,
|
||||
Registry: reg,
|
||||
},
|
||||
}
|
||||
|
||||
err := ret.modules.readModuleManifestSnapshot()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read module manifest: %s", err)
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
// Parser returns the underlying parser for this loader.
|
||||
//
|
||||
// This is useful for loading other sorts of files than the module directories
|
||||
// that a loader deals with, since then they will share the source code cache
|
||||
// for this loader and can thus be shown as snippets in diagnostic messages.
|
||||
func (l *Loader) Parser() *configs.Parser {
|
||||
return l.parser
|
||||
}
|
||||
|
||||
// Sources returns the source code cache for the underlying parser of this
|
||||
// loader. This is a shorthand for l.Parser().Sources().
|
||||
func (l *Loader) Sources() map[string][]byte {
|
||||
return l.parser.Sources()
|
||||
}
|
||||
|
||||
// IsConfigDir returns true if and only if the given directory contains at
|
||||
// least one Terraform configuration file. This is a wrapper around calling
|
||||
// the same method name on the loader's parser.
|
||||
func (l *Loader) IsConfigDir(path string) bool {
|
||||
return l.parser.IsConfigDir(path)
|
||||
}
|
||||
|
||||
// ImportSources writes into the receiver's source code the given source
|
||||
// code buffers.
|
||||
//
|
||||
// This is useful in the situation where an ancillary loader is created for
|
||||
// some reason (e.g. loading config from a plan file) but the cached source
|
||||
// code from that loader must be imported into the "main" loader in order
|
||||
// to return source code snapshots in diagnostic messages.
|
||||
//
|
||||
// loader.ImportSources(otherLoader.Sources())
|
||||
func (l *Loader) ImportSources(sources map[string][]byte) {
|
||||
p := l.Parser()
|
||||
for name, src := range sources {
|
||||
p.ForceFileSource(name, src)
|
||||
}
|
||||
}
|
||||
|
||||
// ImportSourcesFromSnapshot writes into the receiver's source code the
|
||||
// source files from the given snapshot.
|
||||
//
|
||||
// This is similar to ImportSources but knows how to unpack and flatten a
|
||||
// snapshot data structure to get the corresponding flat source file map.
|
||||
func (l *Loader) ImportSourcesFromSnapshot(snap *Snapshot) {
|
||||
p := l.Parser()
|
||||
for _, m := range snap.Modules {
|
||||
baseDir := m.Dir
|
||||
for fn, src := range m.Files {
|
||||
fullPath := filepath.Join(baseDir, fn)
|
||||
p.ForceFileSource(fullPath, src)
|
||||
}
|
||||
}
|
||||
}
|
||||
390
vendor/github.com/hashicorp/terraform/configs/configload/loader_init_from_module.go
generated
vendored
Normal file
390
vendor/github.com/hashicorp/terraform/configs/configload/loader_init_from_module.go
generated
vendored
Normal file
|
|
@ -0,0 +1,390 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
)
|
||||
|
||||
const initFromModuleRootCallName = "root"
|
||||
const initFromModuleRootKeyPrefix = initFromModuleRootCallName + "."
|
||||
|
||||
// InitDirFromModule populates the given directory (which must exist and be
|
||||
// empty) with the contents of the module at the given source address.
|
||||
//
|
||||
// It does this by installing the given module and all of its descendent
|
||||
// modules in a temporary root directory and then copying the installed
|
||||
// files into suitable locations. As a consequence, any diagnostics it
|
||||
// generates will reveal the location of this temporary directory to the
|
||||
// user.
|
||||
//
|
||||
// This rather roundabout installation approach is taken to ensure that
|
||||
// installation proceeds in a manner identical to normal module installation.
|
||||
//
|
||||
// If the given source address specifies a sub-directory of the given
|
||||
// package then only the sub-directory and its descendents will be copied
|
||||
// into the given root directory, which will cause any relative module
|
||||
// references using ../ from that module to be unresolvable. Error diagnostics
|
||||
// are produced in that case, to prompt the user to rewrite the source strings
|
||||
// to be absolute references to the original remote module.
|
||||
//
|
||||
// This can be installed only on a loder that can install modules, and will
|
||||
// panic otherwise. Use CanInstallModules to determine if this method can be
|
||||
// used, or refer to the documentation of that method for situations where
|
||||
// install ability is guaranteed.
|
||||
func (l *Loader) InitDirFromModule(rootDir, sourceAddr string, hooks InstallHooks) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
// The way this function works is pretty ugly, but we accept it because
|
||||
// -from-module is a less important case than normal module installation
|
||||
// and so it's better to keep this ugly complexity out here rather than
|
||||
// adding even more complexity to the normal module installer.
|
||||
|
||||
// The target directory must exist but be empty.
|
||||
{
|
||||
entries, err := l.modules.FS.ReadDir(rootDir)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Target directory does not exist",
|
||||
Detail: fmt.Sprintf("Cannot initialize non-existent directory %s.", rootDir),
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to read target directory",
|
||||
Detail: fmt.Sprintf("Error reading %s to ensure it is empty: %s.", rootDir, err),
|
||||
})
|
||||
}
|
||||
return diags
|
||||
}
|
||||
haveEntries := false
|
||||
for _, entry := range entries {
|
||||
if entry.Name() == "." || entry.Name() == ".." || entry.Name() == ".terraform" {
|
||||
continue
|
||||
}
|
||||
haveEntries = true
|
||||
}
|
||||
if haveEntries {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Can't populate non-empty directory",
|
||||
Detail: fmt.Sprintf("The target directory %s is not empty, so it cannot be initialized with the -from-module=... option.", rootDir),
|
||||
})
|
||||
return diags
|
||||
}
|
||||
}
|
||||
|
||||
// We use a hidden sub-loader to manage our inner installation directory,
|
||||
// but it shares dependencies with the receiver to allow it to access the
|
||||
// same remote resources and ensure it populates the same source code
|
||||
// cache in case .
|
||||
subLoader := &Loader{
|
||||
parser: l.parser,
|
||||
modules: l.modules, // this is a shallow copy, so we can safely mutate below
|
||||
}
|
||||
|
||||
// Our sub-loader will have its own independent manifest and install
|
||||
// directory, so we can install with it and know we won't interfere
|
||||
// with the receiver.
|
||||
subLoader.modules.manifest = make(moduleManifest)
|
||||
subLoader.modules.Dir = filepath.Join(rootDir, ".terraform/init-from-module")
|
||||
|
||||
log.Printf("[DEBUG] using a child module loader in %s to initialize working directory from %q", subLoader.modules.Dir, sourceAddr)
|
||||
|
||||
subLoader.modules.FS.RemoveAll(subLoader.modules.Dir) // if this fails then we'll fail on MkdirAll below too
|
||||
|
||||
err := subLoader.modules.FS.MkdirAll(subLoader.modules.Dir, os.ModePerm)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to create temporary directory",
|
||||
Detail: fmt.Sprintf("Failed to create temporary directory %s: %s.", subLoader.modules.Dir, err),
|
||||
})
|
||||
return diags
|
||||
}
|
||||
|
||||
fakeFilename := fmt.Sprintf("-from-module=%q", sourceAddr)
|
||||
fakeRange := hcl.Range{
|
||||
Filename: fakeFilename,
|
||||
Start: hcl.Pos{
|
||||
Line: 1,
|
||||
Column: 1,
|
||||
Byte: 0,
|
||||
},
|
||||
End: hcl.Pos{
|
||||
Line: 1,
|
||||
Column: len(fakeFilename) + 1, // not accurate if the address contains unicode, but irrelevant since we have no source cache for this anyway
|
||||
Byte: len(fakeFilename),
|
||||
},
|
||||
}
|
||||
|
||||
// -from-module allows relative paths but it's different than a normal
|
||||
// module address where it'd be resolved relative to the module call
|
||||
// (which is synthetic, here.) To address this, we'll just patch up any
|
||||
// relative paths to be absolute paths before we run, ensuring we'll
|
||||
// get the right result. This also, as an important side-effect, ensures
|
||||
// that the result will be "downloaded" with go-getter (copied from the
|
||||
// source location), rather than just recorded as a relative path.
|
||||
{
|
||||
maybePath := filepath.ToSlash(sourceAddr)
|
||||
if maybePath == "." || strings.HasPrefix(maybePath, "./") || strings.HasPrefix(maybePath, "../") {
|
||||
if wd, err := os.Getwd(); err == nil {
|
||||
sourceAddr = filepath.Join(wd, sourceAddr)
|
||||
log.Printf("[TRACE] -from-module relative path rewritten to absolute path %s", sourceAddr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Now we need to create an artificial root module that will seed our
|
||||
// installation process.
|
||||
fakeRootModule := &configs.Module{
|
||||
ModuleCalls: map[string]*configs.ModuleCall{
|
||||
initFromModuleRootCallName: &configs.ModuleCall{
|
||||
Name: initFromModuleRootCallName,
|
||||
|
||||
SourceAddr: sourceAddr,
|
||||
SourceAddrRange: fakeRange,
|
||||
SourceSet: true,
|
||||
|
||||
DeclRange: fakeRange,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// wrapHooks filters hook notifications to only include Download calls
|
||||
// and to trim off the initFromModuleRootCallName prefix. We'll produce
|
||||
// our own Install notifications directly below.
|
||||
wrapHooks := installHooksInitDir{
|
||||
Wrapped: hooks,
|
||||
}
|
||||
getter := reusingGetter{}
|
||||
instDiags := subLoader.installDescendentModules(fakeRootModule, rootDir, true, wrapHooks, getter)
|
||||
diags = append(diags, instDiags...)
|
||||
if instDiags.HasErrors() {
|
||||
return diags
|
||||
}
|
||||
|
||||
// If all of that succeeded then we'll now migrate what was installed
|
||||
// into the final directory structure.
|
||||
modulesDir := l.modules.Dir
|
||||
err = subLoader.modules.FS.MkdirAll(modulesDir, os.ModePerm)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to create local modules directory",
|
||||
Detail: fmt.Sprintf("Failed to create modules directory %s: %s.", modulesDir, err),
|
||||
})
|
||||
return diags
|
||||
}
|
||||
|
||||
manifest := subLoader.modules.manifest
|
||||
recordKeys := make([]string, 0, len(manifest))
|
||||
for k := range manifest {
|
||||
recordKeys = append(recordKeys, k)
|
||||
}
|
||||
sort.Strings(recordKeys)
|
||||
|
||||
for _, recordKey := range recordKeys {
|
||||
record := manifest[recordKey]
|
||||
|
||||
if record.Key == initFromModuleRootCallName {
|
||||
// We've found the module the user requested, which we must
|
||||
// now copy into rootDir so it can be used directly.
|
||||
log.Printf("[TRACE] copying new root module from %s to %s", record.Dir, rootDir)
|
||||
err := copyDir(rootDir, record.Dir)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to copy root module",
|
||||
Detail: fmt.Sprintf("Error copying root module %q from %s to %s: %s.", sourceAddr, record.Dir, rootDir, err),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
// We'll try to load the newly-copied module here just so we can
|
||||
// sniff for any module calls that ../ out of the root directory
|
||||
// and must thus be rewritten to be absolute addresses again.
|
||||
// For now we can't do this rewriting automatically, but we'll
|
||||
// generate an error to help the user do it manually.
|
||||
mod, _ := l.parser.LoadConfigDir(rootDir) // ignore diagnostics since we're just doing value-add here anyway
|
||||
for _, mc := range mod.ModuleCalls {
|
||||
if pathTraversesUp(sourceAddr) {
|
||||
packageAddr, givenSubdir := splitAddrSubdir(sourceAddr)
|
||||
newSubdir := filepath.Join(givenSubdir, mc.SourceAddr)
|
||||
if pathTraversesUp(newSubdir) {
|
||||
// This should never happen in any reasonable
|
||||
// configuration since this suggests a path that
|
||||
// traverses up out of the package root. We'll just
|
||||
// ignore this, since we'll fail soon enough anyway
|
||||
// trying to resolve this path when this module is
|
||||
// loaded.
|
||||
continue
|
||||
}
|
||||
|
||||
var newAddr = packageAddr
|
||||
if newSubdir != "" {
|
||||
newAddr = fmt.Sprintf("%s//%s", newAddr, filepath.ToSlash(newSubdir))
|
||||
}
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Root module references parent directory",
|
||||
Detail: fmt.Sprintf("The requested module %q refers to a module via its parent directory. To use this as a new root module this source string must be rewritten as a remote source address, such as %q.", sourceAddr, newAddr),
|
||||
Subject: &mc.SourceAddrRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
l.modules.manifest[""] = moduleRecord{
|
||||
Key: "",
|
||||
Dir: rootDir,
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if !strings.HasPrefix(record.Key, initFromModuleRootKeyPrefix) {
|
||||
// Ignore the *real* root module, whose key is empty, since
|
||||
// we're only interested in the module named "root" and its
|
||||
// descendents.
|
||||
continue
|
||||
}
|
||||
|
||||
newKey := record.Key[len(initFromModuleRootKeyPrefix):]
|
||||
instPath := filepath.Join(l.modules.Dir, newKey)
|
||||
tempPath := filepath.Join(subLoader.modules.Dir, record.Key)
|
||||
|
||||
// tempPath won't be present for a module that was installed from
|
||||
// a relative path, so in that case we just record the installation
|
||||
// directory and assume it was already copied into place as part
|
||||
// of its parent.
|
||||
if _, err := os.Stat(tempPath); err != nil {
|
||||
if !os.IsNotExist(err) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to stat temporary module install directory",
|
||||
Detail: fmt.Sprintf("Error from stat %s for module %s: %s.", instPath, newKey, err),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
var parentKey string
|
||||
if lastDot := strings.LastIndexByte(newKey, '.'); lastDot != -1 {
|
||||
parentKey = newKey[:lastDot]
|
||||
} else {
|
||||
parentKey = "" // parent is the root module
|
||||
}
|
||||
|
||||
parentOld := manifest[initFromModuleRootKeyPrefix+parentKey]
|
||||
parentNew := l.modules.manifest[parentKey]
|
||||
|
||||
// We need to figure out which portion of our directory is the
|
||||
// parent package path and which portion is the subdirectory
|
||||
// under that.
|
||||
baseDirRel, err := filepath.Rel(parentOld.Dir, record.Dir)
|
||||
if err != nil {
|
||||
// Should never happen, because we constructed both directories
|
||||
// from the same base and so they must have a common prefix.
|
||||
panic(err)
|
||||
}
|
||||
|
||||
newDir := filepath.Join(parentNew.Dir, baseDirRel)
|
||||
log.Printf("[TRACE] relative reference for %s rewritten from %s to %s", newKey, record.Dir, newDir)
|
||||
newRecord := record // shallow copy
|
||||
newRecord.Dir = newDir
|
||||
newRecord.Key = newKey
|
||||
l.modules.manifest[newKey] = newRecord
|
||||
hooks.Install(newRecord.Key, newRecord.Version, newRecord.Dir)
|
||||
continue
|
||||
}
|
||||
|
||||
err = subLoader.modules.FS.MkdirAll(instPath, os.ModePerm)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to create module install directory",
|
||||
Detail: fmt.Sprintf("Error creating directory %s for module %s: %s.", instPath, newKey, err),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
// We copy rather than "rename" here because renaming between directories
|
||||
// can be tricky in edge-cases like network filesystems, etc.
|
||||
log.Printf("[TRACE] copying new module %s from %s to %s", newKey, record.Dir, instPath)
|
||||
err := copyDir(instPath, tempPath)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to copy descendent module",
|
||||
Detail: fmt.Sprintf("Error copying module %q from %s to %s: %s.", newKey, tempPath, rootDir, err),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
subDir, err := filepath.Rel(tempPath, record.Dir)
|
||||
if err != nil {
|
||||
// Should never happen, because we constructed both directories
|
||||
// from the same base and so they must have a common prefix.
|
||||
panic(err)
|
||||
}
|
||||
|
||||
newRecord := record // shallow copy
|
||||
newRecord.Dir = filepath.Join(instPath, subDir)
|
||||
newRecord.Key = newKey
|
||||
l.modules.manifest[newKey] = newRecord
|
||||
hooks.Install(newRecord.Key, newRecord.Version, newRecord.Dir)
|
||||
}
|
||||
|
||||
err = l.modules.writeModuleManifestSnapshot()
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to write module manifest",
|
||||
Detail: fmt.Sprintf("Error writing module manifest: %s.", err),
|
||||
})
|
||||
}
|
||||
|
||||
if !diags.HasErrors() {
|
||||
// Try to clean up our temporary directory, but don't worry if we don't
|
||||
// succeed since it shouldn't hurt anything.
|
||||
subLoader.modules.FS.RemoveAll(subLoader.modules.Dir)
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func pathTraversesUp(path string) bool {
|
||||
return strings.HasPrefix(filepath.ToSlash(path), "../")
|
||||
}
|
||||
|
||||
// installHooksInitDir is an adapter wrapper for an InstallHooks that
|
||||
// does some fakery to make downloads look like they are happening in their
|
||||
// final locations, rather than in the temporary loader we use.
|
||||
//
|
||||
// It also suppresses "Install" calls entirely, since InitDirFromModule
|
||||
// does its own installation steps after the initial installation pass
|
||||
// has completed.
|
||||
type installHooksInitDir struct {
|
||||
Wrapped InstallHooks
|
||||
InstallHooksImpl
|
||||
}
|
||||
|
||||
func (h installHooksInitDir) Download(moduleAddr, packageAddr string, version *version.Version) {
|
||||
if !strings.HasPrefix(moduleAddr, initFromModuleRootKeyPrefix) {
|
||||
// We won't announce the root module, since hook implementations
|
||||
// don't expect to see that and the caller will usually have produced
|
||||
// its own user-facing notification about what it's doing anyway.
|
||||
return
|
||||
}
|
||||
|
||||
trimAddr := moduleAddr[len(initFromModuleRootKeyPrefix):]
|
||||
h.Wrapped.Download(trimAddr, packageAddr, version)
|
||||
}
|
||||
523
vendor/github.com/hashicorp/terraform/configs/configload/loader_install.go
generated
vendored
Normal file
523
vendor/github.com/hashicorp/terraform/configs/configload/loader_install.go
generated
vendored
Normal file
|
|
@ -0,0 +1,523 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
"github.com/hashicorp/terraform/registry"
|
||||
"github.com/hashicorp/terraform/registry/regsrc"
|
||||
)
|
||||
|
||||
// InstallModules analyses the root module in the given directory and installs
|
||||
// all of its direct and transitive dependencies into the loader's modules
|
||||
// directory, which must already exist.
|
||||
//
|
||||
// Since InstallModules makes possibly-time-consuming calls to remote services,
|
||||
// a hook interface is supported to allow the caller to be notified when
|
||||
// each module is installed and, for remote modules, when downloading begins.
|
||||
// LoadConfig guarantees that two hook calls will not happen concurrently but
|
||||
// it does not guarantee any particular ordering of hook calls. This mechanism
|
||||
// is for UI feedback only and does not give the caller any control over the
|
||||
// process.
|
||||
//
|
||||
// If modules are already installed in the target directory, they will be
|
||||
// skipped unless their source address or version have changed or unless
|
||||
// the upgrade flag is set.
|
||||
//
|
||||
// InstallModules never deletes any directory, except in the case where it
|
||||
// needs to replace a directory that is already present with a newly-extracted
|
||||
// package.
|
||||
//
|
||||
// If the returned diagnostics contains errors then the module installation
|
||||
// may have wholly or partially completed. Modules must be loaded in order
|
||||
// to find their dependencies, so this function does many of the same checks
|
||||
// as LoadConfig as a side-effect.
|
||||
//
|
||||
// This function will panic if called on a loader that cannot install modules.
|
||||
// Use CanInstallModules to determine if a loader can install modules, or
|
||||
// refer to the documentation for that method for situations where module
|
||||
// installation capability is guaranteed.
|
||||
func (l *Loader) InstallModules(rootDir string, upgrade bool, hooks InstallHooks) hcl.Diagnostics {
|
||||
if !l.CanInstallModules() {
|
||||
panic(fmt.Errorf("InstallModules called on loader that cannot install modules"))
|
||||
}
|
||||
|
||||
rootMod, diags := l.parser.LoadConfigDir(rootDir)
|
||||
if rootMod == nil {
|
||||
return diags
|
||||
}
|
||||
|
||||
getter := reusingGetter{}
|
||||
instDiags := l.installDescendentModules(rootMod, rootDir, upgrade, hooks, getter)
|
||||
diags = append(diags, instDiags...)
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (l *Loader) installDescendentModules(rootMod *configs.Module, rootDir string, upgrade bool, hooks InstallHooks, getter reusingGetter) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if hooks == nil {
|
||||
// Use our no-op implementation as a placeholder
|
||||
hooks = InstallHooksImpl{}
|
||||
}
|
||||
|
||||
// Create a manifest record for the root module. This will be used if
|
||||
// there are any relative-pathed modules in the root.
|
||||
l.modules.manifest[""] = moduleRecord{
|
||||
Key: "",
|
||||
Dir: rootDir,
|
||||
}
|
||||
|
||||
_, cDiags := configs.BuildConfig(rootMod, configs.ModuleWalkerFunc(
|
||||
func(req *configs.ModuleRequest) (*configs.Module, *version.Version, hcl.Diagnostics) {
|
||||
|
||||
key := manifestKey(req.Path)
|
||||
instPath := l.packageInstallPath(req.Path)
|
||||
|
||||
log.Printf("[DEBUG] Module installer: begin %s", key)
|
||||
|
||||
// First we'll check if we need to upgrade/replace an existing
|
||||
// installed module, and delete it out of the way if so.
|
||||
replace := upgrade
|
||||
if !replace {
|
||||
record, recorded := l.modules.manifest[key]
|
||||
switch {
|
||||
case !recorded:
|
||||
log.Printf("[TRACE] %s is not yet installed", key)
|
||||
replace = true
|
||||
case record.SourceAddr != req.SourceAddr:
|
||||
log.Printf("[TRACE] %s source address has changed from %q to %q", key, record.SourceAddr, req.SourceAddr)
|
||||
replace = true
|
||||
case record.Version != nil && !req.VersionConstraint.Required.Check(record.Version):
|
||||
log.Printf("[TRACE] %s version %s no longer compatible with constraints %s", key, record.Version, req.VersionConstraint.Required)
|
||||
replace = true
|
||||
}
|
||||
}
|
||||
|
||||
// If we _are_ planning to replace this module, then we'll remove
|
||||
// it now so our installation code below won't conflict with any
|
||||
// existing remnants.
|
||||
if replace {
|
||||
if _, recorded := l.modules.manifest[key]; recorded {
|
||||
log.Printf("[TRACE] discarding previous record of %s prior to reinstall", key)
|
||||
}
|
||||
delete(l.modules.manifest, key)
|
||||
// Deleting a module invalidates all of its descendent modules too.
|
||||
keyPrefix := key + "."
|
||||
for subKey := range l.modules.manifest {
|
||||
if strings.HasPrefix(subKey, keyPrefix) {
|
||||
if _, recorded := l.modules.manifest[subKey]; recorded {
|
||||
log.Printf("[TRACE] also discarding downstream %s", subKey)
|
||||
}
|
||||
delete(l.modules.manifest, subKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
record, recorded := l.modules.manifest[key]
|
||||
if !recorded {
|
||||
// Clean up any stale cache directory that might be present.
|
||||
// If this is a local (relative) source then the dir will
|
||||
// not exist, but we'll ignore that.
|
||||
log.Printf("[TRACE] cleaning directory %s prior to install of %s", instPath, key)
|
||||
err := l.modules.FS.RemoveAll(instPath)
|
||||
if err != nil && !os.IsNotExist(err) {
|
||||
log.Printf("[TRACE] failed to remove %s: %s", key, err)
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to remove local module cache",
|
||||
Detail: fmt.Sprintf(
|
||||
"Terraform tried to remove %s in order to reinstall this module, but encountered an error: %s",
|
||||
instPath, err,
|
||||
),
|
||||
Subject: &req.CallRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
} else {
|
||||
// If this module is already recorded and its root directory
|
||||
// exists then we will just load what's already there and
|
||||
// keep our existing record.
|
||||
info, err := l.modules.FS.Stat(record.Dir)
|
||||
if err == nil && info.IsDir() {
|
||||
mod, mDiags := l.parser.LoadConfigDir(record.Dir)
|
||||
diags = append(diags, mDiags...)
|
||||
|
||||
log.Printf("[TRACE] Module installer: %s %s already installed in %s", key, record.Version, record.Dir)
|
||||
return mod, record.Version, diags
|
||||
}
|
||||
}
|
||||
|
||||
// If we get down here then it's finally time to actually install
|
||||
// the module. There are some variants to this process depending
|
||||
// on what type of module source address we have.
|
||||
switch {
|
||||
|
||||
case isLocalSourceAddr(req.SourceAddr):
|
||||
log.Printf("[TRACE] %s has local path %q", key, req.SourceAddr)
|
||||
mod, mDiags := l.installLocalModule(req, key, hooks)
|
||||
diags = append(diags, mDiags...)
|
||||
return mod, nil, diags
|
||||
|
||||
case isRegistrySourceAddr(req.SourceAddr):
|
||||
addr, err := regsrc.ParseModuleSource(req.SourceAddr)
|
||||
if err != nil {
|
||||
// Should never happen because isRegistrySourceAddr already validated
|
||||
panic(err)
|
||||
}
|
||||
log.Printf("[TRACE] %s is a registry module at %s", key, addr)
|
||||
|
||||
mod, v, mDiags := l.installRegistryModule(req, key, instPath, addr, hooks, getter)
|
||||
diags = append(diags, mDiags...)
|
||||
return mod, v, diags
|
||||
|
||||
default:
|
||||
log.Printf("[TRACE] %s address %q will be handled by go-getter", key, req.SourceAddr)
|
||||
|
||||
mod, mDiags := l.installGoGetterModule(req, key, instPath, hooks, getter)
|
||||
diags = append(diags, mDiags...)
|
||||
return mod, nil, diags
|
||||
}
|
||||
|
||||
},
|
||||
))
|
||||
diags = append(diags, cDiags...)
|
||||
|
||||
err := l.modules.writeModuleManifestSnapshot()
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to update module manifest",
|
||||
Detail: fmt.Sprintf("Unable to write the module manifest file: %s", err),
|
||||
})
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
// CanInstallModules returns true if InstallModules can be used with this
|
||||
// loader.
|
||||
//
|
||||
// Loaders created with NewLoader can always install modules. Loaders created
|
||||
// from plan files (where the configuration is embedded in the plan file itself)
|
||||
// cannot install modules, because the plan file is read-only.
|
||||
func (l *Loader) CanInstallModules() bool {
|
||||
return l.modules.CanInstall
|
||||
}
|
||||
|
||||
func (l *Loader) installLocalModule(req *configs.ModuleRequest, key string, hooks InstallHooks) (*configs.Module, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
parentKey := manifestKey(req.Parent.Path)
|
||||
parentRecord, recorded := l.modules.manifest[parentKey]
|
||||
if !recorded {
|
||||
// This is indicative of a bug rather than a user-actionable error
|
||||
panic(fmt.Errorf("missing manifest record for parent module %s", parentKey))
|
||||
}
|
||||
|
||||
if len(req.VersionConstraint.Required) != 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid version constraint",
|
||||
Detail: "A version constraint cannot be applied to a module at a relative local path.",
|
||||
Subject: &req.VersionConstraint.DeclRange,
|
||||
})
|
||||
}
|
||||
|
||||
// For local sources we don't actually need to modify the
|
||||
// filesystem at all because the parent already wrote
|
||||
// the files we need, and so we just load up what's already here.
|
||||
newDir := filepath.Join(parentRecord.Dir, req.SourceAddr)
|
||||
log.Printf("[TRACE] %s uses directory from parent: %s", key, newDir)
|
||||
mod, mDiags := l.parser.LoadConfigDir(newDir)
|
||||
if mod == nil {
|
||||
// nil indicates missing or unreadable directory, so we'll
|
||||
// discard the returned diags and return a more specific
|
||||
// error message here.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unreadable module directory",
|
||||
Detail: fmt.Sprintf("The directory %s could not be read.", newDir),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, mDiags...)
|
||||
}
|
||||
|
||||
// Note the local location in our manifest.
|
||||
l.modules.manifest[key] = moduleRecord{
|
||||
Key: key,
|
||||
Dir: newDir,
|
||||
SourceAddr: req.SourceAddr,
|
||||
}
|
||||
log.Printf("[DEBUG] Module installer: %s installed at %s", key, newDir)
|
||||
hooks.Install(key, nil, newDir)
|
||||
|
||||
return mod, diags
|
||||
}
|
||||
|
||||
func (l *Loader) installRegistryModule(req *configs.ModuleRequest, key string, instPath string, addr *regsrc.Module, hooks InstallHooks, getter reusingGetter) (*configs.Module, *version.Version, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
hostname, err := addr.SvcHost()
|
||||
if err != nil {
|
||||
// If it looks like the user was trying to use punycode then we'll generate
|
||||
// a specialized error for that case. We require the unicode form of
|
||||
// hostname so that hostnames are always human-readable in configuration
|
||||
// and punycode can't be used to hide a malicious module hostname.
|
||||
if strings.HasPrefix(addr.RawHost.Raw, "xn--") {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid module registry hostname",
|
||||
Detail: "The hostname portion of this source address is not an acceptable hostname. Internationalized domain names must be given in unicode form rather than ASCII (\"punycode\") form.",
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid module registry hostname",
|
||||
Detail: "The hostname portion of this source address is not a valid hostname.",
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
}
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
reg := l.modules.Registry
|
||||
|
||||
log.Printf("[DEBUG] %s listing available versions of %s at %s", key, addr, hostname)
|
||||
resp, err := reg.ModuleVersions(addr)
|
||||
if err != nil {
|
||||
if registry.IsModuleNotFound(err) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module not found",
|
||||
Detail: fmt.Sprintf("The specified module could not be found in the module registry at %s.", hostname),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Error accessing remote module registry",
|
||||
Detail: fmt.Sprintf("Failed to retrieve available versions for this module from %s: %s.", hostname, err),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
}
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
// The response might contain information about dependencies to allow us
|
||||
// to potentially optimize future requests, but we don't currently do that
|
||||
// and so for now we'll just take the first item which is guaranteed to
|
||||
// be the address we requested.
|
||||
if len(resp.Modules) < 1 {
|
||||
// Should never happen, but since this is a remote service that may
|
||||
// be implemented by third-parties we will handle it gracefully.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid response from remote module registry",
|
||||
Detail: fmt.Sprintf("The registry at %s returned an invalid response when Terraform requested available versions for this module.", hostname),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
modMeta := resp.Modules[0]
|
||||
|
||||
var latestMatch *version.Version
|
||||
var latestVersion *version.Version
|
||||
for _, mv := range modMeta.Versions {
|
||||
v, err := version.NewVersion(mv.Version)
|
||||
if err != nil {
|
||||
// Should never happen if the registry server is compliant with
|
||||
// the protocol, but we'll warn if not to assist someone who
|
||||
// might be developing a module registry server.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagWarning,
|
||||
Summary: "Invalid response from remote module registry",
|
||||
Detail: fmt.Sprintf("The registry at %s returned an invalid version string %q for this module, which Terraform ignored.", hostname, mv.Version),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
// If we've found a pre-release version then we'll ignore it unless
|
||||
// it was exactly requested.
|
||||
if v.Prerelease() != "" && req.VersionConstraint.Required.String() != v.String() {
|
||||
log.Printf("[TRACE] %s ignoring %s because it is a pre-release and was not requested exactly", key, v)
|
||||
continue
|
||||
}
|
||||
|
||||
if latestVersion == nil || v.GreaterThan(latestVersion) {
|
||||
latestVersion = v
|
||||
}
|
||||
|
||||
if req.VersionConstraint.Required.Check(v) {
|
||||
if latestMatch == nil || v.GreaterThan(latestMatch) {
|
||||
latestMatch = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if latestVersion == nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module has no versions",
|
||||
Detail: fmt.Sprintf("The specified module does not have any available versions."),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
if latestMatch == nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unresolvable module version constraint",
|
||||
Detail: fmt.Sprintf("There is no available version of %q that matches the given version constraint. The newest available version is %s.", addr, latestVersion),
|
||||
Subject: &req.VersionConstraint.DeclRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
// Report up to the caller that we're about to start downloading.
|
||||
packageAddr, _ := splitAddrSubdir(req.SourceAddr)
|
||||
hooks.Download(key, packageAddr, latestMatch)
|
||||
|
||||
// If we manage to get down here then we've found a suitable version to
|
||||
// install, so we need to ask the registry where we should download it from.
|
||||
// The response to this is a go-getter-style address string.
|
||||
dlAddr, err := reg.ModuleLocation(addr, latestMatch.String())
|
||||
if err != nil {
|
||||
log.Printf("[ERROR] %s from %s %s: %s", key, addr, latestMatch, err)
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid response from remote module registry",
|
||||
Detail: fmt.Sprintf("The remote registry at %s failed to return a download URL for %s %s.", hostname, addr, latestMatch),
|
||||
Subject: &req.VersionConstraint.DeclRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
log.Printf("[TRACE] %s %s %s is available at %q", key, addr, latestMatch, dlAddr)
|
||||
|
||||
modDir, err := getter.getWithGoGetter(instPath, dlAddr)
|
||||
if err != nil {
|
||||
// Errors returned by go-getter have very inconsistent quality as
|
||||
// end-user error messages, but for now we're accepting that because
|
||||
// we have no way to recognize any specific errors to improve them
|
||||
// and masking the error entirely would hide valuable diagnostic
|
||||
// information from the user.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to download module",
|
||||
Detail: fmt.Sprintf("Error attempting to download module source code from %q: %s", dlAddr, err),
|
||||
Subject: &req.CallRange,
|
||||
})
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
log.Printf("[TRACE] %s %q was downloaded to %s", key, dlAddr, modDir)
|
||||
|
||||
if addr.RawSubmodule != "" {
|
||||
// Append the user's requested subdirectory to any subdirectory that
|
||||
// was implied by any of the nested layers we expanded within go-getter.
|
||||
modDir = filepath.Join(modDir, addr.RawSubmodule)
|
||||
}
|
||||
|
||||
log.Printf("[TRACE] %s should now be at %s", key, modDir)
|
||||
|
||||
// Finally we are ready to try actually loading the module.
|
||||
mod, mDiags := l.parser.LoadConfigDir(modDir)
|
||||
if mod == nil {
|
||||
// nil indicates missing or unreadable directory, so we'll
|
||||
// discard the returned diags and return a more specific
|
||||
// error message here. For registry modules this actually
|
||||
// indicates a bug in the code above, since it's not the
|
||||
// user's responsibility to create the directory in this case.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unreadable module directory",
|
||||
Detail: fmt.Sprintf("The directory %s could not be read. This is a bug in Terraform and should be reported.", modDir),
|
||||
Subject: &req.CallRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, mDiags...)
|
||||
}
|
||||
|
||||
// Note the local location in our manifest.
|
||||
l.modules.manifest[key] = moduleRecord{
|
||||
Key: key,
|
||||
Version: latestMatch,
|
||||
Dir: modDir,
|
||||
SourceAddr: req.SourceAddr,
|
||||
}
|
||||
log.Printf("[DEBUG] Module installer: %s installed at %s", key, modDir)
|
||||
hooks.Install(key, latestMatch, modDir)
|
||||
|
||||
return mod, latestMatch, diags
|
||||
}
|
||||
|
||||
func (l *Loader) installGoGetterModule(req *configs.ModuleRequest, key string, instPath string, hooks InstallHooks, getter reusingGetter) (*configs.Module, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
// Report up to the caller that we're about to start downloading.
|
||||
packageAddr, _ := splitAddrSubdir(req.SourceAddr)
|
||||
hooks.Download(key, packageAddr, nil)
|
||||
|
||||
modDir, err := getter.getWithGoGetter(instPath, req.SourceAddr)
|
||||
if err != nil {
|
||||
// Errors returned by go-getter have very inconsistent quality as
|
||||
// end-user error messages, but for now we're accepting that because
|
||||
// we have no way to recognize any specific errors to improve them
|
||||
// and masking the error entirely would hide valuable diagnostic
|
||||
// information from the user.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to download module",
|
||||
Detail: fmt.Sprintf("Error attempting to download module source code from %q: %s", packageAddr, err),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
log.Printf("[TRACE] %s %q was downloaded to %s", key, req.SourceAddr, modDir)
|
||||
|
||||
mod, mDiags := l.parser.LoadConfigDir(modDir)
|
||||
if mod == nil {
|
||||
// nil indicates missing or unreadable directory, so we'll
|
||||
// discard the returned diags and return a more specific
|
||||
// error message here. For registry modules this actually
|
||||
// indicates a bug in the code above, since it's not the
|
||||
// user's responsibility to create the directory in this case.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unreadable module directory",
|
||||
Detail: fmt.Sprintf("The directory %s could not be read. This is a bug in Terraform and should be reported.", modDir),
|
||||
Subject: &req.CallRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, mDiags...)
|
||||
}
|
||||
|
||||
// Note the local location in our manifest.
|
||||
l.modules.manifest[key] = moduleRecord{
|
||||
Key: key,
|
||||
Dir: modDir,
|
||||
SourceAddr: req.SourceAddr,
|
||||
}
|
||||
log.Printf("[DEBUG] Module installer: %s installed at %s", key, modDir)
|
||||
hooks.Install(key, nil, modDir)
|
||||
|
||||
return mod, diags
|
||||
}
|
||||
|
||||
func (l *Loader) packageInstallPath(modulePath []string) string {
|
||||
return filepath.Join(l.modules.Dir, strings.Join(modulePath, "."))
|
||||
}
|
||||
34
vendor/github.com/hashicorp/terraform/configs/configload/loader_install_hooks.go
generated
vendored
Normal file
34
vendor/github.com/hashicorp/terraform/configs/configload/loader_install_hooks.go
generated
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
package configload
|
||||
|
||||
import version "github.com/hashicorp/go-version"
|
||||
|
||||
// InstallHooks is an interface used to provide notifications about the
|
||||
// installation process being orchestrated by InstallModules.
|
||||
//
|
||||
// This interface may have new methods added in future, so implementers should
|
||||
// embed InstallHooksImpl to get no-op implementations of any unimplemented
|
||||
// methods.
|
||||
type InstallHooks interface {
|
||||
// Download is called for modules that are retrieved from a remote source
|
||||
// before that download begins, to allow a caller to give feedback
|
||||
// on progress through a possibly-long sequence of downloads.
|
||||
Download(moduleAddr, packageAddr string, version *version.Version)
|
||||
|
||||
// Install is called for each module that is installed, even if it did
|
||||
// not need to be downloaded from a remote source.
|
||||
Install(moduleAddr string, version *version.Version, localPath string)
|
||||
}
|
||||
|
||||
// InstallHooksImpl is a do-nothing implementation of InstallHooks that
|
||||
// can be embedded in another implementation struct to allow only partial
|
||||
// implementation of the interface.
|
||||
type InstallHooksImpl struct {
|
||||
}
|
||||
|
||||
func (h InstallHooksImpl) Download(moduleAddr, packageAddr string, version *version.Version) {
|
||||
}
|
||||
|
||||
func (h InstallHooksImpl) Install(moduleAddr string, version *version.Version, localPath string) {
|
||||
}
|
||||
|
||||
var _ InstallHooks = InstallHooksImpl{}
|
||||
97
vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
generated
vendored
Normal file
97
vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
generated
vendored
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
)
|
||||
|
||||
// LoadConfig reads the Terraform module in the given directory and uses it as the
|
||||
// root module to build the static module tree that represents a configuration,
|
||||
// assuming that all required descendent modules have already been installed.
|
||||
//
|
||||
// If error diagnostics are returned, the returned configuration may be either
|
||||
// nil or incomplete. In the latter case, cautious static analysis is possible
|
||||
// in spite of the errors.
|
||||
//
|
||||
// LoadConfig performs the basic syntax and uniqueness validations that are
|
||||
// required to process the individual modules, and also detects
|
||||
func (l *Loader) LoadConfig(rootDir string) (*configs.Config, hcl.Diagnostics) {
|
||||
rootMod, diags := l.parser.LoadConfigDir(rootDir)
|
||||
if rootMod == nil {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
cfg, cDiags := configs.BuildConfig(rootMod, configs.ModuleWalkerFunc(l.moduleWalkerLoad))
|
||||
diags = append(diags, cDiags...)
|
||||
|
||||
return cfg, diags
|
||||
}
|
||||
|
||||
// moduleWalkerLoad is a configs.ModuleWalkerFunc for loading modules that
|
||||
// are presumed to have already been installed. A different function
|
||||
// (moduleWalkerInstall) is used for installation.
|
||||
func (l *Loader) moduleWalkerLoad(req *configs.ModuleRequest) (*configs.Module, *version.Version, hcl.Diagnostics) {
|
||||
// Since we're just loading here, we expect that all referenced modules
|
||||
// will be already installed and described in our manifest. However, we
|
||||
// do verify that the manifest and the configuration are in agreement
|
||||
// so that we can prompt the user to run "terraform init" if not.
|
||||
|
||||
key := manifestKey(req.Path)
|
||||
record, exists := l.modules.manifest[key]
|
||||
|
||||
if !exists {
|
||||
return nil, nil, hcl.Diagnostics{
|
||||
{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module not installed",
|
||||
Detail: "This module is not yet installed. Run \"terraform init\" to install all modules required by this configuration.",
|
||||
Subject: &req.CallRange,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
// Check for inconsistencies between manifest and config
|
||||
if req.SourceAddr != record.SourceAddr {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module source has changed",
|
||||
Detail: "The source address was changed since this module was installed. Run \"terraform init\" to install all modules required by this configuration.",
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
}
|
||||
if !req.VersionConstraint.Required.Check(record.Version) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module version requirements have changed",
|
||||
Detail: fmt.Sprintf(
|
||||
"The version requirements have changed since this module was installed and the installed version (%s) is no longer acceptable. Run \"terraform init\" to install all modules required by this configuration.",
|
||||
record.Version,
|
||||
),
|
||||
Subject: &req.SourceAddrRange,
|
||||
})
|
||||
}
|
||||
|
||||
mod, mDiags := l.parser.LoadConfigDir(record.Dir)
|
||||
diags = append(diags, mDiags...)
|
||||
if mod == nil {
|
||||
// nil specifically indicates that the directory does not exist or
|
||||
// cannot be read, so in this case we'll discard any generic diagnostics
|
||||
// returned from LoadConfigDir and produce our own context-sensitive
|
||||
// error message.
|
||||
return nil, nil, hcl.Diagnostics{
|
||||
{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Module not installed",
|
||||
Detail: fmt.Sprintf("This module's local cache directory %s could not be read. Run \"terraform init\" to install all modules required by this configuration.", record.Dir),
|
||||
Subject: &req.CallRange,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
return mod, record.Version, diags
|
||||
}
|
||||
505
vendor/github.com/hashicorp/terraform/configs/configload/loader_snapshot.go
generated
vendored
Normal file
505
vendor/github.com/hashicorp/terraform/configs/configload/loader_snapshot.go
generated
vendored
Normal file
|
|
@ -0,0 +1,505 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"time"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/spf13/afero"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
)
|
||||
|
||||
// LoadConfigWithSnapshot is a variant of LoadConfig that also simultaneously
|
||||
// creates an in-memory snapshot of the configuration files used, which can
|
||||
// be later used to create a loader that may read only from this snapshot.
|
||||
func (l *Loader) LoadConfigWithSnapshot(rootDir string) (*configs.Config, *Snapshot, hcl.Diagnostics) {
|
||||
rootMod, diags := l.parser.LoadConfigDir(rootDir)
|
||||
if rootMod == nil {
|
||||
return nil, nil, diags
|
||||
}
|
||||
|
||||
snap := &Snapshot{
|
||||
Modules: map[string]*SnapshotModule{},
|
||||
}
|
||||
walker := l.makeModuleWalkerSnapshot(snap)
|
||||
cfg, cDiags := configs.BuildConfig(rootMod, walker)
|
||||
diags = append(diags, cDiags...)
|
||||
|
||||
addDiags := l.addModuleToSnapshot(snap, "", rootDir, "", nil)
|
||||
diags = append(diags, addDiags...)
|
||||
|
||||
return cfg, snap, diags
|
||||
}
|
||||
|
||||
// NewLoaderFromSnapshot creates a Loader that reads files only from the
|
||||
// given snapshot.
|
||||
//
|
||||
// A snapshot-based loader cannot install modules, so calling InstallModules
|
||||
// on the return value will cause a panic.
|
||||
//
|
||||
// A snapshot-based loader also has access only to configuration files. Its
|
||||
// underlying parser does not have access to other files in the native
|
||||
// filesystem, such as values files. For those, either use a normal loader
|
||||
// (created by NewLoader) or use the configs.Parser API directly.
|
||||
func NewLoaderFromSnapshot(snap *Snapshot) *Loader {
|
||||
fs := snapshotFS{snap}
|
||||
parser := configs.NewParser(fs)
|
||||
|
||||
ret := &Loader{
|
||||
parser: parser,
|
||||
modules: moduleMgr{
|
||||
FS: afero.Afero{Fs: fs},
|
||||
CanInstall: false,
|
||||
manifest: snap.moduleManifest(),
|
||||
},
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
// Snapshot is an in-memory representation of the source files from a
|
||||
// configuration, which can be used as an alternative configurations source
|
||||
// for a loader with NewLoaderFromSnapshot.
|
||||
//
|
||||
// The primary purpose of a Snapshot is to build the configuration portion
|
||||
// of a plan file (see ../../plans/planfile) so that it can later be reloaded
|
||||
// and used to recover the exact configuration that the plan was built from.
|
||||
type Snapshot struct {
|
||||
// Modules is a map from opaque module keys (suitable for use as directory
|
||||
// names on all supported operating systems) to the snapshot information
|
||||
// about each module.
|
||||
Modules map[string]*SnapshotModule
|
||||
}
|
||||
|
||||
// NewEmptySnapshot constructs and returns a snapshot containing only an empty
|
||||
// root module. This is not useful for anything except placeholders in tests.
|
||||
func NewEmptySnapshot() *Snapshot {
|
||||
return &Snapshot{
|
||||
Modules: map[string]*SnapshotModule{
|
||||
manifestKey(addrs.RootModule): &SnapshotModule{
|
||||
Files: map[string][]byte{},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// SnapshotModule represents a single module within a Snapshot.
|
||||
type SnapshotModule struct {
|
||||
// Dir is the path, relative to the root directory given when the
|
||||
// snapshot was created, where the module appears in the snapshot's
|
||||
// virtual filesystem.
|
||||
Dir string
|
||||
|
||||
// Files is a map from each configuration file filename for the
|
||||
// module to a raw byte representation of the source file contents.
|
||||
Files map[string][]byte
|
||||
|
||||
// SourceAddr is the source address given for this module in configuration.
|
||||
SourceAddr string `json:"Source"`
|
||||
|
||||
// Version is the version of the module that is installed, or nil if
|
||||
// the module is installed from a source that does not support versions.
|
||||
Version *version.Version `json:"-"`
|
||||
}
|
||||
|
||||
// moduleManifest constructs a module manifest based on the contents of
|
||||
// the receiving snapshot.
|
||||
func (s *Snapshot) moduleManifest() moduleManifest {
|
||||
ret := make(moduleManifest)
|
||||
|
||||
for k, modSnap := range s.Modules {
|
||||
ret[k] = moduleRecord{
|
||||
Key: k,
|
||||
Dir: modSnap.Dir,
|
||||
SourceAddr: modSnap.SourceAddr,
|
||||
Version: modSnap.Version,
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
// makeModuleWalkerSnapshot creates a configs.ModuleWalker that will exhibit
|
||||
// the same lookup behaviors as l.moduleWalkerLoad but will additionally write
|
||||
// source files from the referenced modules into the given snapshot.
|
||||
func (l *Loader) makeModuleWalkerSnapshot(snap *Snapshot) configs.ModuleWalker {
|
||||
return configs.ModuleWalkerFunc(
|
||||
func(req *configs.ModuleRequest) (*configs.Module, *version.Version, hcl.Diagnostics) {
|
||||
mod, v, diags := l.moduleWalkerLoad(req)
|
||||
if diags.HasErrors() {
|
||||
return mod, v, diags
|
||||
}
|
||||
|
||||
key := manifestKey(req.Path)
|
||||
record, exists := l.modules.manifest[key]
|
||||
|
||||
if !exists {
|
||||
// Should never happen, since otherwise moduleWalkerLoader would've
|
||||
// returned an error and we would've returned already.
|
||||
panic(fmt.Sprintf("module %s is not present in manifest", key))
|
||||
}
|
||||
|
||||
addDiags := l.addModuleToSnapshot(snap, key, record.Dir, record.SourceAddr, record.Version)
|
||||
diags = append(diags, addDiags...)
|
||||
|
||||
return mod, v, diags
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
func (l *Loader) addModuleToSnapshot(snap *Snapshot, key string, dir string, sourceAddr string, v *version.Version) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
primaryFiles, overrideFiles, moreDiags := l.parser.ConfigDirFiles(dir)
|
||||
if moreDiags.HasErrors() {
|
||||
// Any diagnostics we get here should be already present
|
||||
// in diags, so it's weird if we get here but we'll allow it
|
||||
// and return a general error message in that case.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to read directory for module",
|
||||
Detail: fmt.Sprintf("The source directory %s could not be read", dir),
|
||||
})
|
||||
return diags
|
||||
}
|
||||
|
||||
snapMod := &SnapshotModule{
|
||||
Dir: dir,
|
||||
Files: map[string][]byte{},
|
||||
SourceAddr: sourceAddr,
|
||||
Version: v,
|
||||
}
|
||||
|
||||
files := make([]string, 0, len(primaryFiles)+len(overrideFiles))
|
||||
files = append(files, primaryFiles...)
|
||||
files = append(files, overrideFiles...)
|
||||
sources := l.Sources() // should be populated with all the files we need by now
|
||||
for _, filePath := range files {
|
||||
filename := filepath.Base(filePath)
|
||||
src, exists := sources[filePath]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing source file for snapshot",
|
||||
Detail: fmt.Sprintf("The source code for file %s could not be found to produce a configuration snapshot.", filePath),
|
||||
})
|
||||
continue
|
||||
}
|
||||
snapMod.Files[filepath.Clean(filename)] = src
|
||||
}
|
||||
|
||||
snap.Modules[key] = snapMod
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
// snapshotFS is an implementation of afero.Fs that reads from a snapshot.
|
||||
//
|
||||
// This is not intended as a general-purpose filesystem implementation. Instead,
|
||||
// it just supports the minimal functionality required to support the
|
||||
// configuration loader and parser as an implementation detail of creating
|
||||
// a loader from a snapshot.
|
||||
type snapshotFS struct {
|
||||
snap *Snapshot
|
||||
}
|
||||
|
||||
var _ afero.Fs = snapshotFS{}
|
||||
|
||||
func (fs snapshotFS) Create(name string) (afero.File, error) {
|
||||
return nil, fmt.Errorf("cannot create file inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Mkdir(name string, perm os.FileMode) error {
|
||||
return fmt.Errorf("cannot create directory inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) MkdirAll(name string, perm os.FileMode) error {
|
||||
return fmt.Errorf("cannot create directories inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Open(name string) (afero.File, error) {
|
||||
|
||||
// Our "filesystem" is sparsely populated only with the directories
|
||||
// mentioned by modules in our snapshot, so the high-level process
|
||||
// for opening a file is:
|
||||
// - Find the module snapshot corresponding to the containing directory
|
||||
// - Find the file within that snapshot
|
||||
// - Wrap the resulting byte slice in a snapshotFile to return
|
||||
//
|
||||
// The other possibility handled here is if the given name is for the
|
||||
// module directory itself, in which case we'll return a snapshotDir
|
||||
// instead.
|
||||
//
|
||||
// This function doesn't try to be incredibly robust in supporting
|
||||
// different permutations of paths, etc because in practice we only
|
||||
// need to support the path forms that our own loader and parser will
|
||||
// generate.
|
||||
|
||||
dir := filepath.Dir(name)
|
||||
fn := filepath.Base(name)
|
||||
directDir := filepath.Clean(name)
|
||||
|
||||
// First we'll check to see if this is an exact path for a module directory.
|
||||
// We need to do this first (rather than as part of the next loop below)
|
||||
// because a module in a child directory of another module can otherwise
|
||||
// appear to be a file in that parent directory.
|
||||
for _, candidate := range fs.snap.Modules {
|
||||
modDir := filepath.Clean(candidate.Dir)
|
||||
if modDir == directDir {
|
||||
// We've matched the module directory itself
|
||||
filenames := make([]string, 0, len(candidate.Files))
|
||||
for n := range candidate.Files {
|
||||
filenames = append(filenames, n)
|
||||
}
|
||||
sort.Strings(filenames)
|
||||
return snapshotDir{
|
||||
filenames: filenames,
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
// If we get here then the given path isn't a module directory exactly, so
|
||||
// we'll treat it as a file path and try to find a module directory it
|
||||
// could be located in.
|
||||
var modSnap *SnapshotModule
|
||||
for _, candidate := range fs.snap.Modules {
|
||||
modDir := filepath.Clean(candidate.Dir)
|
||||
if modDir == dir {
|
||||
modSnap = candidate
|
||||
break
|
||||
}
|
||||
}
|
||||
if modSnap == nil {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
|
||||
src, exists := modSnap.Files[fn]
|
||||
if !exists {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
|
||||
return &snapshotFile{
|
||||
src: src,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (fs snapshotFS) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
|
||||
return fs.Open(name)
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Remove(name string) error {
|
||||
return fmt.Errorf("cannot remove file inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) RemoveAll(path string) error {
|
||||
return fmt.Errorf("cannot remove files inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Rename(old, new string) error {
|
||||
return fmt.Errorf("cannot rename file inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Stat(name string) (os.FileInfo, error) {
|
||||
f, err := fs.Open(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_, isDir := f.(snapshotDir)
|
||||
return snapshotFileInfo{
|
||||
name: filepath.Base(name),
|
||||
isDir: isDir,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Name() string {
|
||||
return "ConfigSnapshotFS"
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Chmod(name string, mode os.FileMode) error {
|
||||
return fmt.Errorf("cannot set file mode inside configuration snapshot")
|
||||
}
|
||||
|
||||
func (fs snapshotFS) Chtimes(name string, atime, mtime time.Time) error {
|
||||
return fmt.Errorf("cannot set file times inside configuration snapshot")
|
||||
}
|
||||
|
||||
type snapshotFile struct {
|
||||
snapshotFileStub
|
||||
src []byte
|
||||
at int64
|
||||
}
|
||||
|
||||
var _ afero.File = (*snapshotFile)(nil)
|
||||
|
||||
func (f *snapshotFile) Read(p []byte) (n int, err error) {
|
||||
if len(p) > 0 && f.at == int64(len(f.src)) {
|
||||
return 0, io.EOF
|
||||
}
|
||||
if f.at > int64(len(f.src)) {
|
||||
return 0, io.ErrUnexpectedEOF
|
||||
}
|
||||
if int64(len(f.src))-f.at >= int64(len(p)) {
|
||||
n = len(p)
|
||||
} else {
|
||||
n = int(int64(len(f.src)) - f.at)
|
||||
}
|
||||
copy(p, f.src[f.at:f.at+int64(n)])
|
||||
f.at += int64(n)
|
||||
return
|
||||
}
|
||||
|
||||
func (f *snapshotFile) ReadAt(p []byte, off int64) (n int, err error) {
|
||||
f.at = off
|
||||
return f.Read(p)
|
||||
}
|
||||
|
||||
func (f *snapshotFile) Seek(offset int64, whence int) (int64, error) {
|
||||
switch whence {
|
||||
case 0:
|
||||
f.at = offset
|
||||
case 1:
|
||||
f.at += offset
|
||||
case 2:
|
||||
f.at = int64(len(f.src)) + offset
|
||||
}
|
||||
return f.at, nil
|
||||
}
|
||||
|
||||
type snapshotDir struct {
|
||||
snapshotFileStub
|
||||
filenames []string
|
||||
at int
|
||||
}
|
||||
|
||||
var _ afero.File = snapshotDir{}
|
||||
|
||||
func (f snapshotDir) Readdir(count int) ([]os.FileInfo, error) {
|
||||
names, err := f.Readdirnames(count)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ret := make([]os.FileInfo, len(names))
|
||||
for i, name := range names {
|
||||
ret[i] = snapshotFileInfo{
|
||||
name: name,
|
||||
isDir: false,
|
||||
}
|
||||
}
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (f snapshotDir) Readdirnames(count int) ([]string, error) {
|
||||
var outLen int
|
||||
names := f.filenames[f.at:]
|
||||
if count > 0 {
|
||||
if len(names) < count {
|
||||
outLen = len(names)
|
||||
} else {
|
||||
outLen = count
|
||||
}
|
||||
if len(names) == 0 {
|
||||
return nil, io.EOF
|
||||
}
|
||||
} else {
|
||||
outLen = len(names)
|
||||
}
|
||||
f.at += outLen
|
||||
|
||||
return names[:outLen], nil
|
||||
}
|
||||
|
||||
// snapshotFileInfo is a minimal implementation of os.FileInfo to support our
|
||||
// virtual filesystem from snapshots.
|
||||
type snapshotFileInfo struct {
|
||||
name string
|
||||
isDir bool
|
||||
}
|
||||
|
||||
var _ os.FileInfo = snapshotFileInfo{}
|
||||
|
||||
func (fi snapshotFileInfo) Name() string {
|
||||
return fi.name
|
||||
}
|
||||
|
||||
func (fi snapshotFileInfo) Size() int64 {
|
||||
// In practice, our parser and loader never call Size
|
||||
return -1
|
||||
}
|
||||
|
||||
func (fi snapshotFileInfo) Mode() os.FileMode {
|
||||
return os.ModePerm
|
||||
}
|
||||
|
||||
func (fi snapshotFileInfo) ModTime() time.Time {
|
||||
return time.Now()
|
||||
}
|
||||
|
||||
func (fi snapshotFileInfo) IsDir() bool {
|
||||
return fi.isDir
|
||||
}
|
||||
|
||||
func (fi snapshotFileInfo) Sys() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
type snapshotFileStub struct{}
|
||||
|
||||
func (f snapshotFileStub) Close() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Read(p []byte) (n int, err error) {
|
||||
return 0, fmt.Errorf("cannot read")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) ReadAt(p []byte, off int64) (n int, err error) {
|
||||
return 0, fmt.Errorf("cannot read")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Seek(offset int64, whence int) (int64, error) {
|
||||
return 0, fmt.Errorf("cannot seek")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Write(p []byte) (n int, err error) {
|
||||
return f.WriteAt(p, 0)
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) WriteAt(p []byte, off int64) (n int, err error) {
|
||||
return 0, fmt.Errorf("cannot write to file in snapshot")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) WriteString(s string) (n int, err error) {
|
||||
return 0, fmt.Errorf("cannot write to file in snapshot")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Name() string {
|
||||
// in practice, the loader and parser never use this
|
||||
return "<unimplemented>"
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Readdir(count int) ([]os.FileInfo, error) {
|
||||
return nil, fmt.Errorf("cannot use Readdir on a file")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Readdirnames(count int) ([]string, error) {
|
||||
return nil, fmt.Errorf("cannot use Readdir on a file")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Stat() (os.FileInfo, error) {
|
||||
return nil, fmt.Errorf("cannot stat")
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Sync() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f snapshotFileStub) Truncate(size int64) error {
|
||||
return fmt.Errorf("cannot write to file in snapshot")
|
||||
}
|
||||
133
vendor/github.com/hashicorp/terraform/configs/configload/module_manifest.go
generated
vendored
Normal file
133
vendor/github.com/hashicorp/terraform/configs/configload/module_manifest.go
generated
vendored
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// moduleRecord represents some metadata about an installed module, as part
|
||||
// of a moduleManifest.
|
||||
type moduleRecord struct {
|
||||
// Key is a unique identifier for this particular module, based on its
|
||||
// position within the static module tree.
|
||||
Key string `json:"Key"`
|
||||
|
||||
// SourceAddr is the source address given for this module in configuration.
|
||||
// This is used only to detect if the source was changed in configuration
|
||||
// since the module was last installed, which means that the installer
|
||||
// must re-install it.
|
||||
SourceAddr string `json:"Source"`
|
||||
|
||||
// Version is the exact version of the module, which results from parsing
|
||||
// VersionStr. nil for un-versioned modules.
|
||||
Version *version.Version `json:"-"`
|
||||
|
||||
// VersionStr is the version specifier string. This is used only for
|
||||
// serialization in snapshots and should not be accessed or updated
|
||||
// by any other codepaths; use "Version" instead.
|
||||
VersionStr string `json:"Version,omitempty"`
|
||||
|
||||
// Dir is the path to the local directory where the module is installed.
|
||||
Dir string `json:"Dir"`
|
||||
}
|
||||
|
||||
// moduleManifest is a map used to keep track of the filesystem locations
|
||||
// and other metadata about installed modules.
|
||||
//
|
||||
// The configuration loader refers to this, while the module installer updates
|
||||
// it to reflect any changes to the installed modules.
|
||||
type moduleManifest map[string]moduleRecord
|
||||
|
||||
func manifestKey(path addrs.Module) string {
|
||||
return path.String()
|
||||
}
|
||||
|
||||
// manifestSnapshotFile is an internal struct used only to assist in our JSON
|
||||
// serializtion of manifest snapshots. It should not be used for any other
|
||||
// purposes.
|
||||
type manifestSnapshotFile struct {
|
||||
Records []moduleRecord `json:"Modules"`
|
||||
}
|
||||
|
||||
const manifestFilename = "modules.json"
|
||||
|
||||
func (m *moduleMgr) manifestSnapshotPath() string {
|
||||
return filepath.Join(m.Dir, manifestFilename)
|
||||
}
|
||||
|
||||
// readModuleManifestSnapshot loads a manifest snapshot from the filesystem.
|
||||
func (m *moduleMgr) readModuleManifestSnapshot() error {
|
||||
src, err := m.FS.ReadFile(m.manifestSnapshotPath())
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
// We'll treat a missing file as an empty manifest
|
||||
m.manifest = make(moduleManifest)
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
if len(src) == 0 {
|
||||
// This should never happen, but we'll tolerate it as if it were
|
||||
// a valid empty JSON object.
|
||||
m.manifest = make(moduleManifest)
|
||||
return nil
|
||||
}
|
||||
|
||||
var read manifestSnapshotFile
|
||||
err = json.Unmarshal(src, &read)
|
||||
|
||||
new := make(moduleManifest)
|
||||
for _, record := range read.Records {
|
||||
if record.VersionStr != "" {
|
||||
record.Version, err = version.NewVersion(record.VersionStr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("invalid version %q for %s: %s", record.VersionStr, record.Key, err)
|
||||
}
|
||||
}
|
||||
if _, exists := new[record.Key]; exists {
|
||||
// This should never happen in any valid file, so we'll catch it
|
||||
// and report it to avoid confusing/undefined behavior if the
|
||||
// snapshot file was edited incorrectly outside of Terraform.
|
||||
return fmt.Errorf("snapshot file contains two records for path %s", record.Key)
|
||||
}
|
||||
new[record.Key] = record
|
||||
}
|
||||
|
||||
m.manifest = new
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeModuleManifestSnapshot writes a snapshot of the current manifest
|
||||
// to the filesystem.
|
||||
//
|
||||
// The caller must guarantee no concurrent modifications of the manifest for
|
||||
// the duration of a call to this function, or the behavior is undefined.
|
||||
func (m *moduleMgr) writeModuleManifestSnapshot() error {
|
||||
var write manifestSnapshotFile
|
||||
|
||||
for _, record := range m.manifest {
|
||||
// Make sure VersionStr is in sync with Version, since we encourage
|
||||
// callers to manipulate Version and ignore VersionStr.
|
||||
if record.Version != nil {
|
||||
record.VersionStr = record.Version.String()
|
||||
} else {
|
||||
record.VersionStr = ""
|
||||
}
|
||||
write.Records = append(write.Records, record)
|
||||
}
|
||||
|
||||
src, err := json.Marshal(write)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return m.FS.WriteFile(m.manifestSnapshotPath(), src, os.ModePerm)
|
||||
}
|
||||
38
vendor/github.com/hashicorp/terraform/configs/configload/module_mgr.go
generated
vendored
Normal file
38
vendor/github.com/hashicorp/terraform/configs/configload/module_mgr.go
generated
vendored
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/terraform/registry"
|
||||
"github.com/hashicorp/terraform/svchost/disco"
|
||||
"github.com/spf13/afero"
|
||||
)
|
||||
|
||||
type moduleMgr struct {
|
||||
FS afero.Afero
|
||||
|
||||
// CanInstall is true for a module manager that can support installation.
|
||||
//
|
||||
// This must be set only if FS is an afero.OsFs, because the installer
|
||||
// (which uses go-getter) is not aware of the virtual filesystem
|
||||
// abstraction and will always write into the "real" filesystem.
|
||||
CanInstall bool
|
||||
|
||||
// Dir is the path where descendent modules are (or will be) installed.
|
||||
Dir string
|
||||
|
||||
// Services is a service discovery client that will be used to find
|
||||
// remote module registry endpoints. This object may be pre-loaded with
|
||||
// cached discovery information.
|
||||
Services *disco.Disco
|
||||
|
||||
// Registry is a client for the module registry protocol, which is used
|
||||
// when a module is requested from a registry source.
|
||||
Registry *registry.Client
|
||||
|
||||
// manifest tracks the currently-installed modules for this manager.
|
||||
//
|
||||
// The loader may read this. Only the installer may write to it, and
|
||||
// after a set of updates are completed the installer must call
|
||||
// writeModuleManifestSnapshot to persist a snapshot of the manifest
|
||||
// to disk for use on subsequent runs.
|
||||
manifest moduleManifest
|
||||
}
|
||||
45
vendor/github.com/hashicorp/terraform/configs/configload/source_addr.go
generated
vendored
Normal file
45
vendor/github.com/hashicorp/terraform/configs/configload/source_addr.go
generated
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/hashicorp/go-getter"
|
||||
|
||||
"github.com/hashicorp/terraform/registry/regsrc"
|
||||
)
|
||||
|
||||
var localSourcePrefixes = []string{
|
||||
"./",
|
||||
"../",
|
||||
".\\",
|
||||
"..\\",
|
||||
}
|
||||
|
||||
func isLocalSourceAddr(addr string) bool {
|
||||
for _, prefix := range localSourcePrefixes {
|
||||
if strings.HasPrefix(addr, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func isRegistrySourceAddr(addr string) bool {
|
||||
_, err := regsrc.ParseModuleSource(addr)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// splitAddrSubdir splits the given address (which is assumed to be a
|
||||
// registry address or go-getter-style address) into a package portion
|
||||
// and a sub-directory portion.
|
||||
//
|
||||
// The package portion defines what should be downloaded and then the
|
||||
// sub-directory portion, if present, specifies a sub-directory within
|
||||
// the downloaded object (an archive, VCS repository, etc) that contains
|
||||
// the module's configuration files.
|
||||
//
|
||||
// The subDir portion will be returned as empty if no subdir separator
|
||||
// ("//") is present in the address.
|
||||
func splitAddrSubdir(addr string) (packageAddr, subDir string) {
|
||||
return getter.SourceDirSubdir(addr)
|
||||
}
|
||||
101
vendor/github.com/hashicorp/terraform/configs/configload/testing.go
generated
vendored
Normal file
101
vendor/github.com/hashicorp/terraform/configs/configload/testing.go
generated
vendored
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
package configload
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// NewLoaderForTests is a variant of NewLoader that is intended to be more
|
||||
// convenient for unit tests.
|
||||
//
|
||||
// The loader's modules directory is a separate temporary directory created
|
||||
// for each call. Along with the created loader, this function returns a
|
||||
// cleanup function that should be called before the test completes in order
|
||||
// to remove that temporary directory.
|
||||
//
|
||||
// In the case of any errors, t.Fatal (or similar) will be called to halt
|
||||
// execution of the test, so the calling test does not need to handle errors
|
||||
// itself.
|
||||
func NewLoaderForTests(t *testing.T) (*Loader, func()) {
|
||||
t.Helper()
|
||||
|
||||
modulesDir, err := ioutil.TempDir("", "tf-configs")
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create temporary modules dir: %s", err)
|
||||
return nil, func() {}
|
||||
}
|
||||
|
||||
cleanup := func() {
|
||||
os.RemoveAll(modulesDir)
|
||||
}
|
||||
|
||||
loader, err := NewLoader(&Config{
|
||||
ModulesDir: modulesDir,
|
||||
})
|
||||
if err != nil {
|
||||
cleanup()
|
||||
t.Fatalf("failed to create config loader: %s", err)
|
||||
return nil, func() {}
|
||||
}
|
||||
|
||||
return loader, cleanup
|
||||
}
|
||||
|
||||
// LoadConfigForTests is a convenience wrapper around NewLoaderForTests,
|
||||
// Loader.InstallModules and Loader.LoadConfig that allows a test configuration
|
||||
// to be loaded in a single step.
|
||||
//
|
||||
// If module installation fails, t.Fatal (or similar) is called to halt
|
||||
// execution of the test, under the assumption that installation failures are
|
||||
// not expected. If installation failures _are_ expected then use
|
||||
// NewLoaderForTests and work with the loader object directly. If module
|
||||
// installation succeeds but generates warnings, these warnings are discarded.
|
||||
//
|
||||
// If installation succeeds but errors are detected during loading then a
|
||||
// possibly-incomplete config is returned along with error diagnostics. The
|
||||
// test run is not aborted in this case, so that the caller can make assertions
|
||||
// against the returned diagnostics.
|
||||
//
|
||||
// As with NewLoaderForTests, a cleanup function is returned which must be
|
||||
// called before the test completes in order to remove the temporary
|
||||
// modules directory.
|
||||
func LoadConfigForTests(t *testing.T, rootDir string) (*configs.Config, *Loader, func(), tfdiags.Diagnostics) {
|
||||
t.Helper()
|
||||
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
loader, cleanup := NewLoaderForTests(t)
|
||||
hclDiags := loader.InstallModules(rootDir, true, InstallHooksImpl{})
|
||||
if diags.HasErrors() {
|
||||
cleanup()
|
||||
diags = diags.Append(hclDiags)
|
||||
t.Fatal(diags.Err())
|
||||
return nil, nil, cleanup, diags
|
||||
}
|
||||
|
||||
config, hclDiags := loader.LoadConfig(rootDir)
|
||||
diags = diags.Append(hclDiags)
|
||||
return config, loader, cleanup, diags
|
||||
}
|
||||
|
||||
// MustLoadConfigForTests is a variant of LoadConfigForTests which calls
|
||||
// t.Fatal (or similar) if there are any errors during loading, and thus
|
||||
// does not return diagnostics at all.
|
||||
//
|
||||
// This is useful for concisely writing tests that don't expect errors at
|
||||
// all. For tests that expect errors and need to assert against them, use
|
||||
// LoadConfigForTests instead.
|
||||
func MustLoadConfigForTests(t *testing.T, rootDir string) (*configs.Config, *Loader, func()) {
|
||||
t.Helper()
|
||||
|
||||
config, loader, cleanup, diags := LoadConfigForTests(t, rootDir)
|
||||
if diags.HasErrors() {
|
||||
cleanup()
|
||||
t.Fatal(diags.Err())
|
||||
}
|
||||
return config, loader, cleanup
|
||||
}
|
||||
248
vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
generated
vendored
Normal file
248
vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
generated
vendored
Normal file
|
|
@ -0,0 +1,248 @@
|
|||
package configschema
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
)
|
||||
|
||||
// CoerceValue attempts to force the given value to conform to the type
|
||||
// implied by the receiever, while also applying the same validation and
|
||||
// transformation rules that would be applied by the decoder specification
|
||||
// returned by method DecoderSpec.
|
||||
//
|
||||
// This is useful in situations where a configuration must be derived from
|
||||
// an already-decoded value. It is always better to decode directly from
|
||||
// configuration where possible since then source location information is
|
||||
// still available to produce diagnostics, but in special situations this
|
||||
// function allows a compatible result to be obtained even if the
|
||||
// configuration objects are not available.
|
||||
//
|
||||
// If the given value cannot be converted to conform to the receiving schema
|
||||
// then an error is returned describing one of possibly many problems. This
|
||||
// error may be a cty.PathError indicating a position within the nested
|
||||
// data structure where the problem applies.
|
||||
func (b *Block) CoerceValue(in cty.Value) (cty.Value, error) {
|
||||
var path cty.Path
|
||||
return b.coerceValue(in, path)
|
||||
}
|
||||
|
||||
func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
|
||||
switch {
|
||||
case in.IsNull():
|
||||
return cty.NullVal(b.ImpliedType()), nil
|
||||
case !in.IsKnown():
|
||||
return cty.UnknownVal(b.ImpliedType()), nil
|
||||
}
|
||||
|
||||
ty := in.Type()
|
||||
if !ty.IsObjectType() {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("an object is required")
|
||||
}
|
||||
|
||||
for name := range ty.AttributeTypes() {
|
||||
if _, defined := b.Attributes[name]; defined {
|
||||
continue
|
||||
}
|
||||
if _, defined := b.BlockTypes[name]; defined {
|
||||
continue
|
||||
}
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("unexpected attribute %q", name)
|
||||
}
|
||||
|
||||
attrs := make(map[string]cty.Value)
|
||||
|
||||
for name, attrS := range b.Attributes {
|
||||
var val cty.Value
|
||||
switch {
|
||||
case ty.HasAttribute(name):
|
||||
val = in.GetAttr(name)
|
||||
case attrS.Computed || attrS.Optional:
|
||||
val = cty.NullVal(attrS.Type)
|
||||
default:
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", name)
|
||||
}
|
||||
|
||||
val, err := attrS.coerceValue(val, append(path, cty.GetAttrStep{Name: name}))
|
||||
if err != nil {
|
||||
return cty.UnknownVal(b.ImpliedType()), err
|
||||
}
|
||||
|
||||
attrs[name] = val
|
||||
}
|
||||
for typeName, blockS := range b.BlockTypes {
|
||||
switch blockS.Nesting {
|
||||
|
||||
case NestingSingle:
|
||||
switch {
|
||||
case ty.HasAttribute(typeName):
|
||||
var err error
|
||||
val := in.GetAttr(typeName)
|
||||
attrs[typeName], err = blockS.coerceValue(val, append(path, cty.GetAttrStep{Name: typeName}))
|
||||
if err != nil {
|
||||
return cty.UnknownVal(b.ImpliedType()), err
|
||||
}
|
||||
case blockS.MinItems != 1 && blockS.MaxItems != 1:
|
||||
attrs[typeName] = cty.NullVal(blockS.ImpliedType())
|
||||
default:
|
||||
// We use the word "attribute" here because we're talking about
|
||||
// the cty sense of that word rather than the HCL sense.
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
|
||||
}
|
||||
|
||||
case NestingList:
|
||||
switch {
|
||||
case ty.HasAttribute(typeName):
|
||||
coll := in.GetAttr(typeName)
|
||||
|
||||
switch {
|
||||
case coll.IsNull():
|
||||
attrs[typeName] = cty.NullVal(cty.List(blockS.ImpliedType()))
|
||||
continue
|
||||
case !coll.IsKnown():
|
||||
attrs[typeName] = cty.UnknownVal(cty.List(blockS.ImpliedType()))
|
||||
continue
|
||||
}
|
||||
|
||||
if !coll.CanIterateElements() {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a list")
|
||||
}
|
||||
l := coll.LengthInt()
|
||||
if l < blockS.MinItems {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
|
||||
}
|
||||
if l > blockS.MaxItems && blockS.MaxItems > 0 {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("too many items for attribute %q; cannot have more than %d", typeName, blockS.MaxItems)
|
||||
}
|
||||
if l == 0 {
|
||||
attrs[typeName] = cty.ListValEmpty(blockS.ImpliedType())
|
||||
continue
|
||||
}
|
||||
elems := make([]cty.Value, 0, l)
|
||||
{
|
||||
path = append(path, cty.GetAttrStep{Name: typeName})
|
||||
for it := coll.ElementIterator(); it.Next(); {
|
||||
var err error
|
||||
idx, val := it.Element()
|
||||
val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
|
||||
if err != nil {
|
||||
return cty.UnknownVal(b.ImpliedType()), err
|
||||
}
|
||||
elems = append(elems, val)
|
||||
}
|
||||
}
|
||||
attrs[typeName] = cty.ListVal(elems)
|
||||
case blockS.MinItems == 0:
|
||||
attrs[typeName] = cty.ListValEmpty(blockS.ImpliedType())
|
||||
default:
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
|
||||
}
|
||||
|
||||
case NestingSet:
|
||||
switch {
|
||||
case ty.HasAttribute(typeName):
|
||||
coll := in.GetAttr(typeName)
|
||||
|
||||
switch {
|
||||
case coll.IsNull():
|
||||
attrs[typeName] = cty.NullVal(cty.Set(blockS.ImpliedType()))
|
||||
continue
|
||||
case !coll.IsKnown():
|
||||
attrs[typeName] = cty.UnknownVal(cty.Set(blockS.ImpliedType()))
|
||||
continue
|
||||
}
|
||||
|
||||
if !coll.CanIterateElements() {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a set")
|
||||
}
|
||||
l := coll.LengthInt()
|
||||
if l < blockS.MinItems {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
|
||||
}
|
||||
if l > blockS.MaxItems && blockS.MaxItems > 0 {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("too many items for attribute %q; cannot have more than %d", typeName, blockS.MaxItems)
|
||||
}
|
||||
if l == 0 {
|
||||
attrs[typeName] = cty.SetValEmpty(blockS.ImpliedType())
|
||||
continue
|
||||
}
|
||||
elems := make([]cty.Value, 0, l)
|
||||
{
|
||||
path = append(path, cty.GetAttrStep{Name: typeName})
|
||||
for it := coll.ElementIterator(); it.Next(); {
|
||||
var err error
|
||||
idx, val := it.Element()
|
||||
val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
|
||||
if err != nil {
|
||||
return cty.UnknownVal(b.ImpliedType()), err
|
||||
}
|
||||
elems = append(elems, val)
|
||||
}
|
||||
}
|
||||
attrs[typeName] = cty.SetVal(elems)
|
||||
case blockS.MinItems == 0:
|
||||
attrs[typeName] = cty.SetValEmpty(blockS.ImpliedType())
|
||||
default:
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
|
||||
}
|
||||
|
||||
case NestingMap:
|
||||
switch {
|
||||
case ty.HasAttribute(typeName):
|
||||
coll := in.GetAttr(typeName)
|
||||
|
||||
switch {
|
||||
case coll.IsNull():
|
||||
attrs[typeName] = cty.NullVal(cty.Map(blockS.ImpliedType()))
|
||||
continue
|
||||
case !coll.IsKnown():
|
||||
attrs[typeName] = cty.UnknownVal(cty.Map(blockS.ImpliedType()))
|
||||
continue
|
||||
}
|
||||
|
||||
if !coll.CanIterateElements() {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
|
||||
}
|
||||
l := coll.LengthInt()
|
||||
if l == 0 {
|
||||
attrs[typeName] = cty.MapValEmpty(blockS.ImpliedType())
|
||||
continue
|
||||
}
|
||||
elems := make(map[string]cty.Value)
|
||||
{
|
||||
path = append(path, cty.GetAttrStep{Name: typeName})
|
||||
for it := coll.ElementIterator(); it.Next(); {
|
||||
var err error
|
||||
key, val := it.Element()
|
||||
if key.Type() != cty.String || key.IsNull() || !key.IsKnown() {
|
||||
return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
|
||||
}
|
||||
val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: key}))
|
||||
if err != nil {
|
||||
return cty.UnknownVal(b.ImpliedType()), err
|
||||
}
|
||||
elems[key.AsString()] = val
|
||||
}
|
||||
}
|
||||
attrs[typeName] = cty.MapVal(elems)
|
||||
default:
|
||||
attrs[typeName] = cty.MapValEmpty(blockS.ImpliedType())
|
||||
}
|
||||
|
||||
default:
|
||||
// should never happen because above is exhaustive
|
||||
panic(fmt.Errorf("unsupported nesting mode %#v", blockS.Nesting))
|
||||
}
|
||||
}
|
||||
|
||||
return cty.ObjectVal(attrs), nil
|
||||
}
|
||||
|
||||
func (a *Attribute) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
|
||||
val, err := convert.Convert(in, a.Type)
|
||||
if err != nil {
|
||||
return cty.UnknownVal(a.Type), path.NewError(err)
|
||||
}
|
||||
return val, nil
|
||||
}
|
||||
105
vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
generated
vendored
Normal file
105
vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
generated
vendored
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
package configschema
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcldec"
|
||||
)
|
||||
|
||||
var mapLabelNames = []string{"key"}
|
||||
|
||||
// DecoderSpec returns a hcldec.Spec that can be used to decode a HCL Body
|
||||
// using the facilities in the hcldec package.
|
||||
//
|
||||
// The returned specification is guaranteed to return a value of the same type
|
||||
// returned by method ImpliedType, but it may contain null values if any of the
|
||||
// block attributes are defined as optional and/or computed respectively.
|
||||
func (b *Block) DecoderSpec() hcldec.Spec {
|
||||
ret := hcldec.ObjectSpec{}
|
||||
if b == nil {
|
||||
return ret
|
||||
}
|
||||
|
||||
for name, attrS := range b.Attributes {
|
||||
ret[name] = &hcldec.AttrSpec{
|
||||
Name: name,
|
||||
Type: attrS.Type,
|
||||
Required: attrS.Required,
|
||||
}
|
||||
}
|
||||
|
||||
for name, blockS := range b.BlockTypes {
|
||||
if _, exists := ret[name]; exists {
|
||||
// This indicates an invalid schema, since it's not valid to
|
||||
// define both an attribute and a block type of the same name.
|
||||
// However, we don't raise this here since it's checked by
|
||||
// InternalValidate.
|
||||
continue
|
||||
}
|
||||
|
||||
childSpec := blockS.Block.DecoderSpec()
|
||||
|
||||
switch blockS.Nesting {
|
||||
case NestingSingle:
|
||||
ret[name] = &hcldec.BlockSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
Required: blockS.MinItems == 1 && blockS.MaxItems >= 1,
|
||||
}
|
||||
case NestingList:
|
||||
// We prefer to use a list where possible, since it makes our
|
||||
// implied type more complete, but if there are any
|
||||
// dynamically-typed attributes inside we must use a tuple
|
||||
// instead, at the expense of our type then not being predictable.
|
||||
if blockS.Block.ImpliedType().HasDynamicTypes() {
|
||||
ret[name] = &hcldec.BlockTupleSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
MinItems: blockS.MinItems,
|
||||
MaxItems: blockS.MaxItems,
|
||||
}
|
||||
} else {
|
||||
ret[name] = &hcldec.BlockListSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
MinItems: blockS.MinItems,
|
||||
MaxItems: blockS.MaxItems,
|
||||
}
|
||||
}
|
||||
case NestingSet:
|
||||
// We forbid dynamically-typed attributes inside NestingSet in
|
||||
// InternalValidate, so we don't do anything special to handle
|
||||
// that here. (There is no set analog to tuple and object types,
|
||||
// because cty's set implementation depends on knowing the static
|
||||
// type in order to properly compute its internal hashes.)
|
||||
ret[name] = &hcldec.BlockSetSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
MinItems: blockS.MinItems,
|
||||
MaxItems: blockS.MaxItems,
|
||||
}
|
||||
case NestingMap:
|
||||
// We prefer to use a list where possible, since it makes our
|
||||
// implied type more complete, but if there are any
|
||||
// dynamically-typed attributes inside we must use a tuple
|
||||
// instead, at the expense of our type then not being predictable.
|
||||
if blockS.Block.ImpliedType().HasDynamicTypes() {
|
||||
ret[name] = &hcldec.BlockObjectSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
LabelNames: mapLabelNames,
|
||||
}
|
||||
} else {
|
||||
ret[name] = &hcldec.BlockMapSpec{
|
||||
TypeName: name,
|
||||
Nested: childSpec,
|
||||
LabelNames: mapLabelNames,
|
||||
}
|
||||
}
|
||||
default:
|
||||
// Invalid nesting type is just ignored. It's checked by
|
||||
// InternalValidate.
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
|
@ -76,6 +76,15 @@ func (b *Block) internalValidate(prefix string, err error) error {
|
|||
if blockS.MinItems > blockS.MaxItems && blockS.MaxItems != 0 {
|
||||
err = multierror.Append(err, fmt.Errorf("%s%s: MinItems must be less than or equal to MaxItems in %s mode", prefix, name, blockS.Nesting))
|
||||
}
|
||||
if blockS.Nesting == NestingSet {
|
||||
ety := blockS.Block.ImpliedType()
|
||||
if ety.HasDynamicTypes() {
|
||||
// This is not permitted because the HCL (cty) set implementation
|
||||
// needs to know the exact type of set elements in order to
|
||||
// properly hash them, and so can't support mixed types.
|
||||
err = multierror.Append(err, fmt.Errorf("%s%s: NestingSet blocks may not contain attributes of cty.DynamicPseudoType", prefix, name))
|
||||
}
|
||||
}
|
||||
case NestingMap:
|
||||
if blockS.MinItems != 0 || blockS.MaxItems != 0 {
|
||||
err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be 0 in NestingMap mode", prefix, name))
|
||||
38
vendor/github.com/hashicorp/terraform/configs/configschema/none_required.go
generated
vendored
Normal file
38
vendor/github.com/hashicorp/terraform/configs/configschema/none_required.go
generated
vendored
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
package configschema
|
||||
|
||||
// NoneRequired returns a deep copy of the receiver with any required
|
||||
// attributes translated to optional.
|
||||
func (b *Block) NoneRequired() *Block {
|
||||
ret := &Block{}
|
||||
|
||||
if b.Attributes != nil {
|
||||
ret.Attributes = make(map[string]*Attribute, len(b.Attributes))
|
||||
}
|
||||
for name, attrS := range b.Attributes {
|
||||
ret.Attributes[name] = attrS.forceOptional()
|
||||
}
|
||||
|
||||
if b.BlockTypes != nil {
|
||||
ret.BlockTypes = make(map[string]*NestedBlock, len(b.BlockTypes))
|
||||
}
|
||||
for name, blockS := range b.BlockTypes {
|
||||
ret.BlockTypes[name] = blockS.noneRequired()
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
func (b *NestedBlock) noneRequired() *NestedBlock {
|
||||
ret := *b
|
||||
ret.Block = *(ret.Block.NoneRequired())
|
||||
ret.MinItems = 0
|
||||
ret.MaxItems = 0
|
||||
return &ret
|
||||
}
|
||||
|
||||
func (a *Attribute) forceOptional() *Attribute {
|
||||
ret := *a
|
||||
ret.Optional = true
|
||||
ret.Required = false
|
||||
return &ret
|
||||
}
|
||||
|
|
@ -28,6 +28,12 @@ type Attribute struct {
|
|||
// Type is a type specification that the attribute's value must conform to.
|
||||
Type cty.Type
|
||||
|
||||
// Description is an English-language description of the purpose and
|
||||
// usage of the attribute. A description should be concise and use only
|
||||
// one or two sentences, leaving full definition to longer-form
|
||||
// documentation defined elsewhere.
|
||||
Description string
|
||||
|
||||
// Required, if set to true, specifies that an omitted or null value is
|
||||
// not permitted.
|
||||
Required bool
|
||||
173
vendor/github.com/hashicorp/terraform/configs/configschema/validate_traversal.go
generated
vendored
Normal file
173
vendor/github.com/hashicorp/terraform/configs/configschema/validate_traversal.go
generated
vendored
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
package configschema
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
|
||||
"github.com/hashicorp/terraform/helper/didyoumean"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// StaticValidateTraversal checks whether the given traversal (which must be
|
||||
// relative) refers to a construct in the receiving schema, returning error
|
||||
// diagnostics if any problems are found.
|
||||
//
|
||||
// This method is "optimistic" in that it will not return errors for possible
|
||||
// problems that cannot be detected statically. It is possible that an
|
||||
// traversal which passed static validation will still fail when evaluated.
|
||||
func (b *Block) StaticValidateTraversal(traversal hcl.Traversal) tfdiags.Diagnostics {
|
||||
if !traversal.IsRelative() {
|
||||
panic("StaticValidateTraversal on absolute traversal")
|
||||
}
|
||||
if len(traversal) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
var diags tfdiags.Diagnostics
|
||||
|
||||
next := traversal[0]
|
||||
after := traversal[1:]
|
||||
|
||||
var name string
|
||||
switch step := next.(type) {
|
||||
case hcl.TraverseAttr:
|
||||
name = step.Name
|
||||
case hcl.TraverseIndex:
|
||||
// No other traversal step types are allowed directly at a block.
|
||||
// If it looks like the user was trying to use index syntax to
|
||||
// access an attribute then we'll produce a specialized message.
|
||||
key := step.Key
|
||||
if key.Type() == cty.String && key.IsKnown() && !key.IsNull() {
|
||||
maybeName := key.AsString()
|
||||
if hclsyntax.ValidIdentifier(maybeName) {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Invalid index operation`,
|
||||
Detail: fmt.Sprintf(`Only attribute access is allowed here. Did you mean to access attribute %q using the dot operator?`, maybeName),
|
||||
Subject: &step.SrcRange,
|
||||
})
|
||||
return diags
|
||||
}
|
||||
}
|
||||
// If it looks like some other kind of index then we'll use a generic error.
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Invalid index operation`,
|
||||
Detail: `Only attribute access is allowed here, using the dot operator.`,
|
||||
Subject: &step.SrcRange,
|
||||
})
|
||||
return diags
|
||||
default:
|
||||
// No other traversal types should appear in a normal valid traversal,
|
||||
// but we'll handle this with a generic error anyway to be robust.
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Invalid operation`,
|
||||
Detail: `Only attribute access is allowed here, using the dot operator.`,
|
||||
Subject: next.SourceRange().Ptr(),
|
||||
})
|
||||
return diags
|
||||
}
|
||||
|
||||
if attrS, exists := b.Attributes[name]; exists {
|
||||
// For attribute validation we will just apply the rest of the
|
||||
// traversal to an unknown value of the attribute type and pass
|
||||
// through HCL's own errors, since we don't want to replicate all of
|
||||
// HCL's type checking rules here.
|
||||
val := cty.UnknownVal(attrS.Type)
|
||||
_, hclDiags := after.TraverseRel(val)
|
||||
diags = diags.Append(hclDiags)
|
||||
return diags
|
||||
}
|
||||
|
||||
if blockS, exists := b.BlockTypes[name]; exists {
|
||||
moreDiags := blockS.staticValidateTraversal(name, after)
|
||||
diags = diags.Append(moreDiags)
|
||||
return diags
|
||||
}
|
||||
|
||||
// If we get here then the name isn't valid at all. We'll collect up
|
||||
// all of the names that _are_ valid to use as suggestions.
|
||||
var suggestions []string
|
||||
for name := range b.Attributes {
|
||||
suggestions = append(suggestions, name)
|
||||
}
|
||||
for name := range b.BlockTypes {
|
||||
suggestions = append(suggestions, name)
|
||||
}
|
||||
sort.Strings(suggestions)
|
||||
suggestion := didyoumean.NameSuggestion(name, suggestions)
|
||||
if suggestion != "" {
|
||||
suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
|
||||
}
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Unsupported attribute`,
|
||||
Detail: fmt.Sprintf(`This object has no argument, nested block, or exported attribute named %q.%s`, name, suggestion),
|
||||
Subject: next.SourceRange().Ptr(),
|
||||
})
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (b *NestedBlock) staticValidateTraversal(typeName string, traversal hcl.Traversal) tfdiags.Diagnostics {
|
||||
if b.Nesting == NestingSingle {
|
||||
// Single blocks are easy: just pass right through.
|
||||
return b.Block.StaticValidateTraversal(traversal)
|
||||
}
|
||||
|
||||
if len(traversal) == 0 {
|
||||
// It's always valid to access a nested block's attribute directly.
|
||||
return nil
|
||||
}
|
||||
|
||||
var diags tfdiags.Diagnostics
|
||||
next := traversal[0]
|
||||
after := traversal[1:]
|
||||
|
||||
switch b.Nesting {
|
||||
|
||||
case NestingSet:
|
||||
// Can't traverse into a set at all, since it does not have any keys
|
||||
// to index with.
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Cannot index a set value`,
|
||||
Detail: fmt.Sprintf(`Block type %q is represented by a set of objects, and set elements do not have addressable keys. To find elements matching specific criteria, use a "for" expression with an "if" clause.`, typeName),
|
||||
Subject: next.SourceRange().Ptr(),
|
||||
})
|
||||
return diags
|
||||
|
||||
case NestingList:
|
||||
if _, ok := next.(hcl.TraverseIndex); ok {
|
||||
moreDiags := b.Block.StaticValidateTraversal(after)
|
||||
diags = diags.Append(moreDiags)
|
||||
} else {
|
||||
diags = diags.Append(&hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: `Invalid operation`,
|
||||
Detail: fmt.Sprintf(`Block type %q is represented by a list of objects, so it must be indexed using a numeric key, like .%s[0].`, typeName, typeName),
|
||||
Subject: next.SourceRange().Ptr(),
|
||||
})
|
||||
}
|
||||
return diags
|
||||
|
||||
case NestingMap:
|
||||
// Both attribute and index steps are valid for maps, so we'll just
|
||||
// pass through here and let normal evaluation catch an
|
||||
// incorrectly-typed index key later, if present.
|
||||
moreDiags := b.Block.StaticValidateTraversal(after)
|
||||
diags = diags.Append(moreDiags)
|
||||
return diags
|
||||
|
||||
default:
|
||||
// Invalid nesting type is just ignored. It's checked by
|
||||
// InternalValidate. (Note that we handled NestingSingle separately
|
||||
// back at the start of this function.)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
23
vendor/github.com/hashicorp/terraform/configs/depends_on.go
generated
vendored
Normal file
23
vendor/github.com/hashicorp/terraform/configs/depends_on.go
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
func decodeDependsOn(attr *hcl.Attribute) ([]hcl.Traversal, hcl.Diagnostics) {
|
||||
var ret []hcl.Traversal
|
||||
exprs, diags := hcl.ExprList(attr.Expr)
|
||||
|
||||
for _, expr := range exprs {
|
||||
expr, shimDiags := shimTraversalInString(expr, false)
|
||||
diags = append(diags, shimDiags...)
|
||||
|
||||
traversal, travDiags := hcl.AbsTraversalForExpr(expr)
|
||||
diags = append(diags, travDiags...)
|
||||
if len(traversal) != 0 {
|
||||
ret = append(ret, traversal)
|
||||
}
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
19
vendor/github.com/hashicorp/terraform/configs/doc.go
generated
vendored
Normal file
19
vendor/github.com/hashicorp/terraform/configs/doc.go
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
// Package configs contains types that represent Terraform configurations and
|
||||
// the different elements thereof.
|
||||
//
|
||||
// The functionality in this package can be used for some static analyses of
|
||||
// Terraform configurations, but this package generally exposes representations
|
||||
// of the configuration source code rather than the result of evaluating these
|
||||
// objects. The sibling package "lang" deals with evaluation of structures
|
||||
// and expressions in the configuration.
|
||||
//
|
||||
// Due to its close relationship with HCL, this package makes frequent use
|
||||
// of types from the HCL API, including raw HCL diagnostic messages. Such
|
||||
// diagnostics can be converted into Terraform-flavored diagnostics, if needed,
|
||||
// using functions in the sibling package tfdiags.
|
||||
//
|
||||
// The Parser type is the main entry-point into this package. The LoadConfigDir
|
||||
// method can be used to load a single module directory, and then a full
|
||||
// configuration (including any descendent modules) can be produced using
|
||||
// the top-level BuildConfig method.
|
||||
package configs
|
||||
404
vendor/github.com/hashicorp/terraform/configs/module.go
generated
vendored
Normal file
404
vendor/github.com/hashicorp/terraform/configs/module.go
generated
vendored
Normal file
|
|
@ -0,0 +1,404 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// Module is a container for a set of configuration constructs that are
|
||||
// evaluated within a common namespace.
|
||||
type Module struct {
|
||||
// SourceDir is the filesystem directory that the module was loaded from.
|
||||
//
|
||||
// This is populated automatically only for configurations loaded with
|
||||
// LoadConfigDir. If the parser is using a virtual filesystem then the
|
||||
// path here will be in terms of that virtual filesystem.
|
||||
|
||||
// Any other caller that constructs a module directly with NewModule may
|
||||
// assign a suitable value to this attribute before using it for other
|
||||
// purposes. It should be treated as immutable by all consumers of Module
|
||||
// values.
|
||||
SourceDir string
|
||||
|
||||
CoreVersionConstraints []VersionConstraint
|
||||
|
||||
Backend *Backend
|
||||
ProviderConfigs map[string]*Provider
|
||||
ProviderRequirements map[string][]VersionConstraint
|
||||
|
||||
Variables map[string]*Variable
|
||||
Locals map[string]*Local
|
||||
Outputs map[string]*Output
|
||||
|
||||
ModuleCalls map[string]*ModuleCall
|
||||
|
||||
ManagedResources map[string]*Resource
|
||||
DataResources map[string]*Resource
|
||||
}
|
||||
|
||||
// File describes the contents of a single configuration file.
|
||||
//
|
||||
// Individual files are not usually used alone, but rather combined together
|
||||
// with other files (conventionally, those in the same directory) to produce
|
||||
// a *Module, using NewModule.
|
||||
//
|
||||
// At the level of an individual file we represent directly the structural
|
||||
// elements present in the file, without any attempt to detect conflicting
|
||||
// declarations. A File object can therefore be used for some basic static
|
||||
// analysis of individual elements, but must be built into a Module to detect
|
||||
// duplicate declarations.
|
||||
type File struct {
|
||||
CoreVersionConstraints []VersionConstraint
|
||||
|
||||
Backends []*Backend
|
||||
ProviderConfigs []*Provider
|
||||
ProviderRequirements []*ProviderRequirement
|
||||
|
||||
Variables []*Variable
|
||||
Locals []*Local
|
||||
Outputs []*Output
|
||||
|
||||
ModuleCalls []*ModuleCall
|
||||
|
||||
ManagedResources []*Resource
|
||||
DataResources []*Resource
|
||||
}
|
||||
|
||||
// NewModule takes a list of primary files and a list of override files and
|
||||
// produces a *Module by combining the files together.
|
||||
//
|
||||
// If there are any conflicting declarations in the given files -- for example,
|
||||
// if the same variable name is defined twice -- then the resulting module
|
||||
// will be incomplete and error diagnostics will be returned. Careful static
|
||||
// analysis of the returned Module is still possible in this case, but the
|
||||
// module will probably not be semantically valid.
|
||||
func NewModule(primaryFiles, overrideFiles []*File) (*Module, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
mod := &Module{
|
||||
ProviderConfigs: map[string]*Provider{},
|
||||
ProviderRequirements: map[string][]VersionConstraint{},
|
||||
Variables: map[string]*Variable{},
|
||||
Locals: map[string]*Local{},
|
||||
Outputs: map[string]*Output{},
|
||||
ModuleCalls: map[string]*ModuleCall{},
|
||||
ManagedResources: map[string]*Resource{},
|
||||
DataResources: map[string]*Resource{},
|
||||
}
|
||||
|
||||
for _, file := range primaryFiles {
|
||||
fileDiags := mod.appendFile(file)
|
||||
diags = append(diags, fileDiags...)
|
||||
}
|
||||
|
||||
for _, file := range overrideFiles {
|
||||
fileDiags := mod.mergeFile(file)
|
||||
diags = append(diags, fileDiags...)
|
||||
}
|
||||
|
||||
return mod, diags
|
||||
}
|
||||
|
||||
// ResourceByAddr returns the configuration for the resource with the given
|
||||
// address, or nil if there is no such resource.
|
||||
func (m *Module) ResourceByAddr(addr addrs.Resource) *Resource {
|
||||
key := addr.String()
|
||||
switch addr.Mode {
|
||||
case addrs.ManagedResourceMode:
|
||||
return m.ManagedResources[key]
|
||||
case addrs.DataResourceMode:
|
||||
return m.DataResources[key]
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Module) appendFile(file *File) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
for _, constraint := range file.CoreVersionConstraints {
|
||||
// If there are any conflicting requirements then we'll catch them
|
||||
// when we actually check these constraints.
|
||||
m.CoreVersionConstraints = append(m.CoreVersionConstraints, constraint)
|
||||
}
|
||||
|
||||
for _, b := range file.Backends {
|
||||
if m.Backend != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate backend configuration",
|
||||
Detail: fmt.Sprintf("A module may have only one backend configuration. The backend was previously configured at %s.", m.Backend.DeclRange),
|
||||
Subject: &b.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
m.Backend = b
|
||||
}
|
||||
|
||||
for _, pc := range file.ProviderConfigs {
|
||||
key := pc.moduleUniqueKey()
|
||||
if existing, exists := m.ProviderConfigs[key]; exists {
|
||||
if existing.Alias == "" {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate provider configuration",
|
||||
Detail: fmt.Sprintf("A default (non-aliased) provider configuration for %q was already given at %s. If multiple configurations are required, set the \"alias\" argument for alternative configurations.", existing.Name, existing.DeclRange),
|
||||
Subject: &pc.DeclRange,
|
||||
})
|
||||
} else {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate provider configuration",
|
||||
Detail: fmt.Sprintf("A provider configuration for %q with alias %q was already given at %s. Each configuration for the same provider must have a distinct alias.", existing.Name, existing.Alias, existing.DeclRange),
|
||||
Subject: &pc.DeclRange,
|
||||
})
|
||||
}
|
||||
continue
|
||||
}
|
||||
m.ProviderConfigs[key] = pc
|
||||
}
|
||||
|
||||
for _, reqd := range file.ProviderRequirements {
|
||||
m.ProviderRequirements[reqd.Name] = append(m.ProviderRequirements[reqd.Name], reqd.Requirement)
|
||||
}
|
||||
|
||||
for _, v := range file.Variables {
|
||||
if existing, exists := m.Variables[v.Name]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate variable declaration",
|
||||
Detail: fmt.Sprintf("A variable named %q was already declared at %s. Variable names must be unique within a module.", existing.Name, existing.DeclRange),
|
||||
Subject: &v.DeclRange,
|
||||
})
|
||||
}
|
||||
m.Variables[v.Name] = v
|
||||
}
|
||||
|
||||
for _, l := range file.Locals {
|
||||
if existing, exists := m.Locals[l.Name]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate local value definition",
|
||||
Detail: fmt.Sprintf("A local value named %q was already defined at %s. Local value names must be unique within a module.", existing.Name, existing.DeclRange),
|
||||
Subject: &l.DeclRange,
|
||||
})
|
||||
}
|
||||
m.Locals[l.Name] = l
|
||||
}
|
||||
|
||||
for _, o := range file.Outputs {
|
||||
if existing, exists := m.Outputs[o.Name]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate output definition",
|
||||
Detail: fmt.Sprintf("An output named %q was already defined at %s. Output names must be unique within a module.", existing.Name, existing.DeclRange),
|
||||
Subject: &o.DeclRange,
|
||||
})
|
||||
}
|
||||
m.Outputs[o.Name] = o
|
||||
}
|
||||
|
||||
for _, mc := range file.ModuleCalls {
|
||||
if existing, exists := m.ModuleCalls[mc.Name]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate module call",
|
||||
Detail: fmt.Sprintf("An module call named %q was already defined at %s. Module calls must have unique names within a module.", existing.Name, existing.DeclRange),
|
||||
Subject: &mc.DeclRange,
|
||||
})
|
||||
}
|
||||
m.ModuleCalls[mc.Name] = mc
|
||||
}
|
||||
|
||||
for _, r := range file.ManagedResources {
|
||||
key := r.moduleUniqueKey()
|
||||
if existing, exists := m.ManagedResources[key]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: fmt.Sprintf("Duplicate resource %q configuration", existing.Type),
|
||||
Detail: fmt.Sprintf("A %s resource named %q was already declared at %s. Resource names must be unique per type in each module.", existing.Type, existing.Name, existing.DeclRange),
|
||||
Subject: &r.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
m.ManagedResources[key] = r
|
||||
}
|
||||
|
||||
for _, r := range file.DataResources {
|
||||
key := r.moduleUniqueKey()
|
||||
if existing, exists := m.DataResources[key]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: fmt.Sprintf("Duplicate data %q configuration", existing.Type),
|
||||
Detail: fmt.Sprintf("A %s data resource named %q was already declared at %s. Resource names must be unique per type in each module.", existing.Type, existing.Name, existing.DeclRange),
|
||||
Subject: &r.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
m.DataResources[key] = r
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (m *Module) mergeFile(file *File) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if len(file.CoreVersionConstraints) != 0 {
|
||||
// This is a bit of a strange case for overriding since we normally
|
||||
// would union together across multiple files anyway, but we'll
|
||||
// allow it and have each override file clobber any existing list.
|
||||
m.CoreVersionConstraints = nil
|
||||
for _, constraint := range file.CoreVersionConstraints {
|
||||
m.CoreVersionConstraints = append(m.CoreVersionConstraints, constraint)
|
||||
}
|
||||
}
|
||||
|
||||
if len(file.Backends) != 0 {
|
||||
switch len(file.Backends) {
|
||||
case 1:
|
||||
m.Backend = file.Backends[0]
|
||||
default:
|
||||
// An override file with multiple backends is still invalid, even
|
||||
// though it can override backends from _other_ files.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate backend configuration",
|
||||
Detail: fmt.Sprintf("Each override file may have only one backend configuration. A backend was previously configured at %s.", file.Backends[0].DeclRange),
|
||||
Subject: &file.Backends[1].DeclRange,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
for _, pc := range file.ProviderConfigs {
|
||||
key := pc.moduleUniqueKey()
|
||||
existing, exists := m.ProviderConfigs[key]
|
||||
if pc.Alias == "" {
|
||||
// We allow overriding a non-existing _default_ provider configuration
|
||||
// because the user model is that an absent provider configuration
|
||||
// implies an empty provider configuration, which is what the user
|
||||
// is therefore overriding here.
|
||||
if exists {
|
||||
mergeDiags := existing.merge(pc)
|
||||
diags = append(diags, mergeDiags...)
|
||||
} else {
|
||||
m.ProviderConfigs[key] = pc
|
||||
}
|
||||
} else {
|
||||
// For aliased providers, there must be a base configuration to
|
||||
// override. This allows us to detect and report alias typos
|
||||
// that might otherwise cause the override to not apply.
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing base provider configuration for override",
|
||||
Detail: fmt.Sprintf("There is no %s provider configuration with the alias %q. An override file can only override an aliased provider configuration that was already defined in a primary configuration file.", pc.Name, pc.Alias),
|
||||
Subject: &pc.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(pc)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
}
|
||||
|
||||
if len(file.ProviderRequirements) != 0 {
|
||||
mergeProviderVersionConstraints(m.ProviderRequirements, file.ProviderRequirements)
|
||||
}
|
||||
|
||||
for _, v := range file.Variables {
|
||||
existing, exists := m.Variables[v.Name]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing base variable declaration to override",
|
||||
Detail: fmt.Sprintf("There is no variable named %q. An override file can only override a variable that was already declared in a primary configuration file.", v.Name),
|
||||
Subject: &v.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(v)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
for _, l := range file.Locals {
|
||||
existing, exists := m.Locals[l.Name]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing base local value definition to override",
|
||||
Detail: fmt.Sprintf("There is no local value named %q. An override file can only override a local value that was already defined in a primary configuration file.", l.Name),
|
||||
Subject: &l.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(l)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
for _, o := range file.Outputs {
|
||||
existing, exists := m.Outputs[o.Name]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing base output definition to override",
|
||||
Detail: fmt.Sprintf("There is no output named %q. An override file can only override an output that was already defined in a primary configuration file.", o.Name),
|
||||
Subject: &o.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(o)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
for _, mc := range file.ModuleCalls {
|
||||
existing, exists := m.ModuleCalls[mc.Name]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing module call to override",
|
||||
Detail: fmt.Sprintf("There is no module call named %q. An override file can only override a module call that was defined in a primary configuration file.", mc.Name),
|
||||
Subject: &mc.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(mc)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
for _, r := range file.ManagedResources {
|
||||
key := r.moduleUniqueKey()
|
||||
existing, exists := m.ManagedResources[key]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing resource to override",
|
||||
Detail: fmt.Sprintf("There is no %s resource named %q. An override file can only override a resource block defined in a primary configuration file.", r.Type, r.Name),
|
||||
Subject: &r.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(r)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
for _, r := range file.DataResources {
|
||||
key := r.moduleUniqueKey()
|
||||
existing, exists := m.DataResources[key]
|
||||
if !exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing data resource to override",
|
||||
Detail: fmt.Sprintf("There is no %s data resource named %q. An override file can only override a data block defined in a primary configuration file.", r.Type, r.Name),
|
||||
Subject: &r.DeclRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
mergeDiags := existing.merge(r)
|
||||
diags = append(diags, mergeDiags...)
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
188
vendor/github.com/hashicorp/terraform/configs/module_call.go
generated
vendored
Normal file
188
vendor/github.com/hashicorp/terraform/configs/module_call.go
generated
vendored
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/gohcl"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
)
|
||||
|
||||
// ModuleCall represents a "module" block in a module or file.
|
||||
type ModuleCall struct {
|
||||
Name string
|
||||
|
||||
SourceAddr string
|
||||
SourceAddrRange hcl.Range
|
||||
SourceSet bool
|
||||
|
||||
Config hcl.Body
|
||||
|
||||
Version VersionConstraint
|
||||
|
||||
Count hcl.Expression
|
||||
ForEach hcl.Expression
|
||||
|
||||
Providers []PassedProviderConfig
|
||||
|
||||
DependsOn []hcl.Traversal
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeModuleBlock(block *hcl.Block, override bool) (*ModuleCall, hcl.Diagnostics) {
|
||||
mc := &ModuleCall{
|
||||
Name: block.Labels[0],
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
schema := moduleBlockSchema
|
||||
if override {
|
||||
schema = schemaForOverrides(schema)
|
||||
}
|
||||
|
||||
content, remain, diags := block.Body.PartialContent(schema)
|
||||
mc.Config = remain
|
||||
|
||||
if !hclsyntax.ValidIdentifier(mc.Name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid module instance name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["source"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &mc.SourceAddr)
|
||||
diags = append(diags, valDiags...)
|
||||
mc.SourceAddrRange = attr.Expr.Range()
|
||||
mc.SourceSet = true
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["version"]; exists {
|
||||
var versionDiags hcl.Diagnostics
|
||||
mc.Version, versionDiags = decodeVersionConstraint(attr)
|
||||
diags = append(diags, versionDiags...)
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["count"]; exists {
|
||||
mc.Count = attr.Expr
|
||||
|
||||
// We currently parse this, but don't yet do anything with it.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in module block",
|
||||
Detail: fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["for_each"]; exists {
|
||||
mc.ForEach = attr.Expr
|
||||
|
||||
// We currently parse this, but don't yet do anything with it.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in module block",
|
||||
Detail: fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["depends_on"]; exists {
|
||||
deps, depsDiags := decodeDependsOn(attr)
|
||||
diags = append(diags, depsDiags...)
|
||||
mc.DependsOn = append(mc.DependsOn, deps...)
|
||||
|
||||
// We currently parse this, but don't yet do anything with it.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in module block",
|
||||
Detail: fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["providers"]; exists {
|
||||
seen := make(map[string]hcl.Range)
|
||||
pairs, pDiags := hcl.ExprMap(attr.Expr)
|
||||
diags = append(diags, pDiags...)
|
||||
for _, pair := range pairs {
|
||||
key, keyDiags := decodeProviderConfigRef(pair.Key, "providers")
|
||||
diags = append(diags, keyDiags...)
|
||||
value, valueDiags := decodeProviderConfigRef(pair.Value, "providers")
|
||||
diags = append(diags, valueDiags...)
|
||||
if keyDiags.HasErrors() || valueDiags.HasErrors() {
|
||||
continue
|
||||
}
|
||||
|
||||
matchKey := key.String()
|
||||
if prev, exists := seen[matchKey]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate provider address",
|
||||
Detail: fmt.Sprintf("A provider configuration was already passed to %s at %s. Each child provider configuration can be assigned only once.", matchKey, prev),
|
||||
Subject: pair.Value.Range().Ptr(),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
rng := hcl.RangeBetween(pair.Key.Range(), pair.Value.Range())
|
||||
seen[matchKey] = rng
|
||||
mc.Providers = append(mc.Providers, PassedProviderConfig{
|
||||
InChild: key,
|
||||
InParent: value,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Reserved block types (all of them)
|
||||
for _, block := range content.Blocks {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved block type name in module block",
|
||||
Detail: fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
|
||||
Subject: &block.TypeRange,
|
||||
})
|
||||
}
|
||||
|
||||
return mc, diags
|
||||
}
|
||||
|
||||
// PassedProviderConfig represents a provider config explicitly passed down to
|
||||
// a child module, possibly giving it a new local address in the process.
|
||||
type PassedProviderConfig struct {
|
||||
InChild *ProviderConfigRef
|
||||
InParent *ProviderConfigRef
|
||||
}
|
||||
|
||||
var moduleBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "source",
|
||||
Required: true,
|
||||
},
|
||||
{
|
||||
Name: "version",
|
||||
},
|
||||
{
|
||||
Name: "count",
|
||||
},
|
||||
{
|
||||
Name: "for_each",
|
||||
},
|
||||
{
|
||||
Name: "depends_on",
|
||||
},
|
||||
{
|
||||
Name: "providers",
|
||||
},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
// These are all reserved for future use.
|
||||
{Type: "lifecycle"},
|
||||
{Type: "locals"},
|
||||
{Type: "provider", LabelNames: []string{"type"}},
|
||||
},
|
||||
}
|
||||
247
vendor/github.com/hashicorp/terraform/configs/module_merge.go
generated
vendored
Normal file
247
vendor/github.com/hashicorp/terraform/configs/module_merge.go
generated
vendored
Normal file
|
|
@ -0,0 +1,247 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
)
|
||||
|
||||
// The methods in this file are used by Module.mergeFile to apply overrides
|
||||
// to our different configuration elements. These methods all follow the
|
||||
// pattern of mutating the receiver to incorporate settings from the parameter,
|
||||
// returning error diagnostics if any aspect of the parameter cannot be merged
|
||||
// into the receiver for some reason.
|
||||
//
|
||||
// User expectation is that anything _explicitly_ set in the given object
|
||||
// should take precedence over the corresponding settings in the receiver,
|
||||
// but that anything omitted in the given object should be left unchanged.
|
||||
// In some cases it may be reasonable to do a "deep merge" of certain nested
|
||||
// features, if it is possible to unambiguously correlate the nested elements
|
||||
// and their behaviors are orthogonal to each other.
|
||||
|
||||
func (p *Provider) merge(op *Provider) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if op.Version.Required != nil {
|
||||
p.Version = op.Version
|
||||
}
|
||||
|
||||
p.Config = MergeBodies(p.Config, op.Config)
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func mergeProviderVersionConstraints(recv map[string][]VersionConstraint, ovrd []*ProviderRequirement) {
|
||||
// Any provider name that's mentioned in the override gets nilled out in
|
||||
// our map so that we'll rebuild it below. Any provider not mentioned is
|
||||
// left unchanged.
|
||||
for _, reqd := range ovrd {
|
||||
delete(recv, reqd.Name)
|
||||
}
|
||||
for _, reqd := range ovrd {
|
||||
recv[reqd.Name] = append(recv[reqd.Name], reqd.Requirement)
|
||||
}
|
||||
}
|
||||
|
||||
func (v *Variable) merge(ov *Variable) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if ov.DescriptionSet {
|
||||
v.Description = ov.Description
|
||||
v.DescriptionSet = ov.DescriptionSet
|
||||
}
|
||||
if ov.Default != cty.NilVal {
|
||||
v.Default = ov.Default
|
||||
}
|
||||
if ov.Type != cty.NilType {
|
||||
v.Type = ov.Type
|
||||
}
|
||||
if ov.ParsingMode != 0 {
|
||||
v.ParsingMode = ov.ParsingMode
|
||||
}
|
||||
|
||||
// If the override file overrode type without default or vice-versa then
|
||||
// it may have created an invalid situation, which we'll catch now by
|
||||
// attempting to re-convert the value.
|
||||
//
|
||||
// Note that here we may be re-converting an already-converted base value
|
||||
// from the base config. This will be a no-op if the type was not changed,
|
||||
// but in particular might be user-observable in the edge case where the
|
||||
// literal value in config could've been converted to the overridden type
|
||||
// constraint but the converted value cannot. In practice, this situation
|
||||
// should be rare since most of our conversions are interchangable.
|
||||
if v.Default != cty.NilVal {
|
||||
val, err := convert.Convert(v.Default, v.Type)
|
||||
if err != nil {
|
||||
// What exactly we'll say in the error message here depends on whether
|
||||
// it was Default or Type that was overridden here.
|
||||
switch {
|
||||
case ov.Type != cty.NilType && ov.Default == cty.NilVal:
|
||||
// If only the type was overridden
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid default value for variable",
|
||||
Detail: fmt.Sprintf("Overriding this variable's type constraint has made its default value invalid: %s.", err),
|
||||
Subject: &ov.DeclRange,
|
||||
})
|
||||
case ov.Type == cty.NilType && ov.Default != cty.NilVal:
|
||||
// Only the default was overridden
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid default value for variable",
|
||||
Detail: fmt.Sprintf("The overridden default value for this variable is not compatible with the variable's type constraint: %s.", err),
|
||||
Subject: &ov.DeclRange,
|
||||
})
|
||||
default:
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid default value for variable",
|
||||
Detail: fmt.Sprintf("This variable's default value is not compatible with its type constraint: %s.", err),
|
||||
Subject: &ov.DeclRange,
|
||||
})
|
||||
}
|
||||
} else {
|
||||
v.Default = val
|
||||
}
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (l *Local) merge(ol *Local) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
// Since a local is just a single expression in configuration, the
|
||||
// override definition entirely replaces the base definition, including
|
||||
// the source range so that we'll send the user to the right place if
|
||||
// there is an error.
|
||||
l.Expr = ol.Expr
|
||||
l.DeclRange = ol.DeclRange
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (o *Output) merge(oo *Output) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if oo.Description != "" {
|
||||
o.Description = oo.Description
|
||||
}
|
||||
if oo.Expr != nil {
|
||||
o.Expr = oo.Expr
|
||||
}
|
||||
if oo.SensitiveSet {
|
||||
o.Sensitive = oo.Sensitive
|
||||
o.SensitiveSet = oo.SensitiveSet
|
||||
}
|
||||
|
||||
// We don't allow depends_on to be overridden because that is likely to
|
||||
// cause confusing misbehavior.
|
||||
if len(oo.DependsOn) != 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported override",
|
||||
Detail: "The depends_on argument may not be overridden.",
|
||||
Subject: oo.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
|
||||
})
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (mc *ModuleCall) merge(omc *ModuleCall) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if omc.SourceSet {
|
||||
mc.SourceAddr = omc.SourceAddr
|
||||
mc.SourceAddrRange = omc.SourceAddrRange
|
||||
mc.SourceSet = omc.SourceSet
|
||||
}
|
||||
|
||||
if omc.Count != nil {
|
||||
mc.Count = omc.Count
|
||||
}
|
||||
|
||||
if omc.ForEach != nil {
|
||||
mc.ForEach = omc.ForEach
|
||||
}
|
||||
|
||||
if len(omc.Version.Required) != 0 {
|
||||
mc.Version = omc.Version
|
||||
}
|
||||
|
||||
mc.Config = MergeBodies(mc.Config, omc.Config)
|
||||
|
||||
// We don't allow depends_on to be overridden because that is likely to
|
||||
// cause confusing misbehavior.
|
||||
if len(mc.DependsOn) != 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported override",
|
||||
Detail: "The depends_on argument may not be overridden.",
|
||||
Subject: mc.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
|
||||
})
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
|
||||
func (r *Resource) merge(or *Resource) hcl.Diagnostics {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
if r.Mode != or.Mode {
|
||||
// This is always a programming error, since managed and data resources
|
||||
// are kept in separate maps in the configuration structures.
|
||||
panic(fmt.Errorf("can't merge %s into %s", or.Mode, r.Mode))
|
||||
}
|
||||
|
||||
if or.Count != nil {
|
||||
r.Count = or.Count
|
||||
}
|
||||
if or.ForEach != nil {
|
||||
r.ForEach = or.ForEach
|
||||
}
|
||||
if or.ProviderConfigRef != nil {
|
||||
r.ProviderConfigRef = or.ProviderConfigRef
|
||||
}
|
||||
if r.Mode == addrs.ManagedResourceMode {
|
||||
// or.Managed is always non-nil for managed resource mode
|
||||
|
||||
if or.Managed.Connection != nil {
|
||||
r.Managed.Connection = or.Managed.Connection
|
||||
}
|
||||
if or.Managed.CreateBeforeDestroySet {
|
||||
r.Managed.CreateBeforeDestroy = or.Managed.CreateBeforeDestroy
|
||||
r.Managed.CreateBeforeDestroySet = or.Managed.CreateBeforeDestroySet
|
||||
}
|
||||
if len(or.Managed.IgnoreChanges) != 0 {
|
||||
r.Managed.IgnoreChanges = or.Managed.IgnoreChanges
|
||||
}
|
||||
if or.Managed.PreventDestroySet {
|
||||
r.Managed.PreventDestroy = or.Managed.PreventDestroy
|
||||
r.Managed.PreventDestroySet = or.Managed.PreventDestroySet
|
||||
}
|
||||
if len(or.Managed.Provisioners) != 0 {
|
||||
r.Managed.Provisioners = or.Managed.Provisioners
|
||||
}
|
||||
}
|
||||
|
||||
r.Config = MergeBodies(r.Config, or.Config)
|
||||
|
||||
// We don't allow depends_on to be overridden because that is likely to
|
||||
// cause confusing misbehavior.
|
||||
if len(or.DependsOn) != 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported override",
|
||||
Detail: "The depends_on argument may not be overridden.",
|
||||
Subject: or.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
|
||||
})
|
||||
}
|
||||
|
||||
return diags
|
||||
}
|
||||
129
vendor/github.com/hashicorp/terraform/configs/module_merge_body.go
generated
vendored
Normal file
129
vendor/github.com/hashicorp/terraform/configs/module_merge_body.go
generated
vendored
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
// MergeBodies creates a new HCL body that contains a combination of the
|
||||
// given base and override bodies. Attributes and blocks defined in the
|
||||
// override body take precedence over those of the same name defined in
|
||||
// the base body.
|
||||
//
|
||||
// If any block of a particular type appears in "override" then it will
|
||||
// replace _all_ of the blocks of the same type in "base" in the new
|
||||
// body.
|
||||
func MergeBodies(base, override hcl.Body) hcl.Body {
|
||||
return mergeBody{
|
||||
Base: base,
|
||||
Override: override,
|
||||
}
|
||||
}
|
||||
|
||||
// mergeBody is a hcl.Body implementation that wraps a pair of other bodies
|
||||
// and allows attributes and blocks within the override to take precedence
|
||||
// over those defined in the base body.
|
||||
//
|
||||
// This is used to deal with dynamically-processed bodies in Module.mergeFile.
|
||||
// It uses a shallow-only merging strategy where direct attributes defined
|
||||
// in Override will override attributes of the same name in Base, while any
|
||||
// blocks defined in Override will hide all blocks of the same type in Base.
|
||||
//
|
||||
// This cannot possibly "do the right thing" in all cases, because we don't
|
||||
// have enough information about user intent. However, this behavior is intended
|
||||
// to be reasonable for simple overriding use-cases.
|
||||
type mergeBody struct {
|
||||
Base hcl.Body
|
||||
Override hcl.Body
|
||||
}
|
||||
|
||||
var _ hcl.Body = mergeBody{}
|
||||
|
||||
func (b mergeBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
oSchema := schemaForOverrides(schema)
|
||||
|
||||
baseContent, cDiags := b.Base.Content(schema)
|
||||
diags = append(diags, cDiags...)
|
||||
overrideContent, cDiags := b.Override.Content(oSchema)
|
||||
diags = append(diags, cDiags...)
|
||||
|
||||
content := b.prepareContent(baseContent, overrideContent)
|
||||
|
||||
return content, diags
|
||||
}
|
||||
|
||||
func (b mergeBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
oSchema := schemaForOverrides(schema)
|
||||
|
||||
baseContent, baseRemain, cDiags := b.Base.PartialContent(schema)
|
||||
diags = append(diags, cDiags...)
|
||||
overrideContent, overrideRemain, cDiags := b.Override.PartialContent(oSchema)
|
||||
diags = append(diags, cDiags...)
|
||||
|
||||
content := b.prepareContent(baseContent, overrideContent)
|
||||
|
||||
remain := MergeBodies(baseRemain, overrideRemain)
|
||||
|
||||
return content, remain, diags
|
||||
}
|
||||
|
||||
func (b mergeBody) prepareContent(base *hcl.BodyContent, override *hcl.BodyContent) *hcl.BodyContent {
|
||||
content := &hcl.BodyContent{
|
||||
Attributes: make(hcl.Attributes),
|
||||
}
|
||||
|
||||
// For attributes we just assign from each map in turn and let the override
|
||||
// map clobber any matching entries from base.
|
||||
for k, a := range base.Attributes {
|
||||
content.Attributes[k] = a
|
||||
}
|
||||
for k, a := range override.Attributes {
|
||||
content.Attributes[k] = a
|
||||
}
|
||||
|
||||
// Things are a little more interesting for blocks because they arrive
|
||||
// as a flat list. Our merging semantics call for us to suppress blocks
|
||||
// from base if at least one block of the same type appears in override.
|
||||
// We explicitly do not try to correlate and deeply merge nested blocks,
|
||||
// since we don't have enough context here to infer user intent.
|
||||
|
||||
overriddenBlockTypes := make(map[string]bool)
|
||||
for _, block := range override.Blocks {
|
||||
overriddenBlockTypes[block.Type] = true
|
||||
}
|
||||
for _, block := range base.Blocks {
|
||||
if overriddenBlockTypes[block.Type] {
|
||||
continue
|
||||
}
|
||||
content.Blocks = append(content.Blocks, block)
|
||||
}
|
||||
for _, block := range override.Blocks {
|
||||
content.Blocks = append(content.Blocks, block)
|
||||
}
|
||||
|
||||
return content
|
||||
}
|
||||
|
||||
func (b mergeBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
ret := make(hcl.Attributes)
|
||||
|
||||
baseAttrs, aDiags := b.Base.JustAttributes()
|
||||
diags = append(diags, aDiags...)
|
||||
overrideAttrs, aDiags := b.Override.JustAttributes()
|
||||
diags = append(diags, aDiags...)
|
||||
|
||||
for k, a := range baseAttrs {
|
||||
ret[k] = a
|
||||
}
|
||||
for k, a := range overrideAttrs {
|
||||
ret[k] = a
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
func (b mergeBody) MissingItemRange() hcl.Range {
|
||||
return b.Base.MissingItemRange()
|
||||
}
|
||||
364
vendor/github.com/hashicorp/terraform/configs/named_values.go
generated
vendored
Normal file
364
vendor/github.com/hashicorp/terraform/configs/named_values.go
generated
vendored
Normal file
|
|
@ -0,0 +1,364 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/ext/typeexpr"
|
||||
"github.com/hashicorp/hcl2/gohcl"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// A consistent detail message for all "not a valid identifier" diagnostics.
|
||||
const badIdentifierDetail = "A name must start with a letter and may contain only letters, digits, underscores, and dashes."
|
||||
|
||||
// Variable represents a "variable" block in a module or file.
|
||||
type Variable struct {
|
||||
Name string
|
||||
Description string
|
||||
Default cty.Value
|
||||
Type cty.Type
|
||||
ParsingMode VariableParsingMode
|
||||
|
||||
DescriptionSet bool
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeVariableBlock(block *hcl.Block, override bool) (*Variable, hcl.Diagnostics) {
|
||||
v := &Variable{
|
||||
Name: block.Labels[0],
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
// Unless we're building an override, we'll set some defaults
|
||||
// which we might override with attributes below. We leave these
|
||||
// as zero-value in the override case so we can recognize whether
|
||||
// or not they are set when we merge.
|
||||
if !override {
|
||||
v.Type = cty.DynamicPseudoType
|
||||
v.ParsingMode = VariableParseLiteral
|
||||
}
|
||||
|
||||
content, diags := block.Body.Content(variableBlockSchema)
|
||||
|
||||
if !hclsyntax.ValidIdentifier(v.Name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid variable name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
|
||||
// Don't allow declaration of variables that would conflict with the
|
||||
// reserved attribute and block type names in a "module" block, since
|
||||
// these won't be usable for child modules.
|
||||
for _, attr := range moduleBlockSchema.Attributes {
|
||||
if attr.Name == v.Name {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid variable name",
|
||||
Detail: fmt.Sprintf("The variable name %q is reserved due to its special meaning inside module blocks.", attr.Name),
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
}
|
||||
for _, blockS := range moduleBlockSchema.Blocks {
|
||||
if blockS.Type == v.Name {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid variable name",
|
||||
Detail: fmt.Sprintf("The variable name %q is reserved due to its special meaning inside module blocks.", blockS.Type),
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["description"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &v.Description)
|
||||
diags = append(diags, valDiags...)
|
||||
v.DescriptionSet = true
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["type"]; exists {
|
||||
ty, parseMode, tyDiags := decodeVariableType(attr.Expr)
|
||||
diags = append(diags, tyDiags...)
|
||||
v.Type = ty
|
||||
v.ParsingMode = parseMode
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["default"]; exists {
|
||||
val, valDiags := attr.Expr.Value(nil)
|
||||
diags = append(diags, valDiags...)
|
||||
|
||||
// Convert the default to the expected type so we can catch invalid
|
||||
// defaults early and allow later code to assume validity.
|
||||
// Note that this depends on us having already processed any "type"
|
||||
// attribute above.
|
||||
// However, we can't do this if we're in an override file where
|
||||
// the type might not be set; we'll catch that during merge.
|
||||
if v.Type != cty.NilType {
|
||||
var err error
|
||||
val, err = convert.Convert(val, v.Type)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid default value for variable",
|
||||
Detail: fmt.Sprintf("This default value is not compatible with the variable's type constraint: %s.", err),
|
||||
Subject: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
val = cty.DynamicVal
|
||||
}
|
||||
}
|
||||
|
||||
v.Default = val
|
||||
}
|
||||
|
||||
return v, diags
|
||||
}
|
||||
|
||||
func decodeVariableType(expr hcl.Expression) (cty.Type, VariableParsingMode, hcl.Diagnostics) {
|
||||
if exprIsNativeQuotedString(expr) {
|
||||
// Here we're accepting the pre-0.12 form of variable type argument where
|
||||
// the string values "string", "list" and "map" are accepted has a hint
|
||||
// about the type used primarily for deciding how to parse values
|
||||
// given on the command line and in environment variables.
|
||||
// Only the native syntax ends up in this codepath; we handle the
|
||||
// JSON syntax (which is, of course, quoted even in the new format)
|
||||
// in the normal codepath below.
|
||||
val, diags := expr.Value(nil)
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicPseudoType, VariableParseHCL, diags
|
||||
}
|
||||
str := val.AsString()
|
||||
switch str {
|
||||
case "string":
|
||||
return cty.String, VariableParseLiteral, diags
|
||||
case "list":
|
||||
return cty.List(cty.DynamicPseudoType), VariableParseHCL, diags
|
||||
case "map":
|
||||
return cty.Map(cty.DynamicPseudoType), VariableParseHCL, diags
|
||||
default:
|
||||
return cty.DynamicPseudoType, VariableParseHCL, hcl.Diagnostics{{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid legacy variable type hint",
|
||||
Detail: `The legacy variable type hint form, using a quoted string, allows only the values "string", "list", and "map". To provide a full type expression, remove the surrounding quotes and give the type expression directly.`,
|
||||
Subject: expr.Range().Ptr(),
|
||||
}}
|
||||
}
|
||||
}
|
||||
|
||||
// First we'll deal with some shorthand forms that the HCL-level type
|
||||
// expression parser doesn't include. These both emulate pre-0.12 behavior
|
||||
// of allowing a list or map of any element type as long as all of the
|
||||
// elements are consistent. This is the same as list(any) or map(any).
|
||||
switch hcl.ExprAsKeyword(expr) {
|
||||
case "list":
|
||||
return cty.List(cty.DynamicPseudoType), VariableParseHCL, nil
|
||||
case "map":
|
||||
return cty.Map(cty.DynamicPseudoType), VariableParseHCL, nil
|
||||
}
|
||||
|
||||
ty, diags := typeexpr.TypeConstraint(expr)
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicPseudoType, VariableParseHCL, diags
|
||||
}
|
||||
|
||||
switch {
|
||||
case ty.IsPrimitiveType():
|
||||
// Primitive types use literal parsing.
|
||||
return ty, VariableParseLiteral, diags
|
||||
default:
|
||||
// Everything else uses HCL parsing
|
||||
return ty, VariableParseHCL, diags
|
||||
}
|
||||
}
|
||||
|
||||
// VariableParsingMode defines how values of a particular variable given by
|
||||
// text-only mechanisms (command line arguments and environment variables)
|
||||
// should be parsed to produce the final value.
|
||||
type VariableParsingMode rune
|
||||
|
||||
// VariableParseLiteral is a variable parsing mode that just takes the given
|
||||
// string directly as a cty.String value.
|
||||
const VariableParseLiteral VariableParsingMode = 'L'
|
||||
|
||||
// VariableParseHCL is a variable parsing mode that attempts to parse the given
|
||||
// string as an HCL expression and returns the result.
|
||||
const VariableParseHCL VariableParsingMode = 'H'
|
||||
|
||||
// Parse uses the receiving parsing mode to process the given variable value
|
||||
// string, returning the result along with any diagnostics.
|
||||
//
|
||||
// A VariableParsingMode does not know the expected type of the corresponding
|
||||
// variable, so it's the caller's responsibility to attempt to convert the
|
||||
// result to the appropriate type and return to the user any diagnostics that
|
||||
// conversion may produce.
|
||||
//
|
||||
// The given name is used to create a synthetic filename in case any diagnostics
|
||||
// must be generated about the given string value. This should be the name
|
||||
// of the root module variable whose value will be populated from the given
|
||||
// string.
|
||||
//
|
||||
// If the returned diagnostics has errors, the returned value may not be
|
||||
// valid.
|
||||
func (m VariableParsingMode) Parse(name, value string) (cty.Value, hcl.Diagnostics) {
|
||||
switch m {
|
||||
case VariableParseLiteral:
|
||||
return cty.StringVal(value), nil
|
||||
case VariableParseHCL:
|
||||
fakeFilename := fmt.Sprintf("<value for var.%s>", name)
|
||||
expr, diags := hclsyntax.ParseExpression([]byte(value), fakeFilename, hcl.Pos{Line: 1, Column: 1})
|
||||
if diags.HasErrors() {
|
||||
return cty.DynamicVal, diags
|
||||
}
|
||||
val, valDiags := expr.Value(nil)
|
||||
diags = append(diags, valDiags...)
|
||||
return val, diags
|
||||
default:
|
||||
// Should never happen
|
||||
panic(fmt.Errorf("Parse called on invalid VariableParsingMode %#v", m))
|
||||
}
|
||||
}
|
||||
|
||||
// Output represents an "output" block in a module or file.
|
||||
type Output struct {
|
||||
Name string
|
||||
Description string
|
||||
Expr hcl.Expression
|
||||
DependsOn []hcl.Traversal
|
||||
Sensitive bool
|
||||
|
||||
DescriptionSet bool
|
||||
SensitiveSet bool
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeOutputBlock(block *hcl.Block, override bool) (*Output, hcl.Diagnostics) {
|
||||
o := &Output{
|
||||
Name: block.Labels[0],
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
schema := outputBlockSchema
|
||||
if override {
|
||||
schema = schemaForOverrides(schema)
|
||||
}
|
||||
|
||||
content, diags := block.Body.Content(schema)
|
||||
|
||||
if !hclsyntax.ValidIdentifier(o.Name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid output name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["description"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &o.Description)
|
||||
diags = append(diags, valDiags...)
|
||||
o.DescriptionSet = true
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["value"]; exists {
|
||||
o.Expr = attr.Expr
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["sensitive"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &o.Sensitive)
|
||||
diags = append(diags, valDiags...)
|
||||
o.SensitiveSet = true
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["depends_on"]; exists {
|
||||
deps, depsDiags := decodeDependsOn(attr)
|
||||
diags = append(diags, depsDiags...)
|
||||
o.DependsOn = append(o.DependsOn, deps...)
|
||||
}
|
||||
|
||||
return o, diags
|
||||
}
|
||||
|
||||
// Local represents a single entry from a "locals" block in a module or file.
|
||||
// The "locals" block itself is not represented, because it serves only to
|
||||
// provide context for us to interpret its contents.
|
||||
type Local struct {
|
||||
Name string
|
||||
Expr hcl.Expression
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeLocalsBlock(block *hcl.Block) ([]*Local, hcl.Diagnostics) {
|
||||
attrs, diags := block.Body.JustAttributes()
|
||||
if len(attrs) == 0 {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
locals := make([]*Local, 0, len(attrs))
|
||||
for name, attr := range attrs {
|
||||
if !hclsyntax.ValidIdentifier(name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid local value name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
locals = append(locals, &Local{
|
||||
Name: name,
|
||||
Expr: attr.Expr,
|
||||
DeclRange: attr.Range,
|
||||
})
|
||||
}
|
||||
return locals, diags
|
||||
}
|
||||
|
||||
// Addr returns the address of the local value declared by the receiver,
|
||||
// relative to its containing module.
|
||||
func (l *Local) Addr() addrs.LocalValue {
|
||||
return addrs.LocalValue{
|
||||
Name: l.Name,
|
||||
}
|
||||
}
|
||||
|
||||
var variableBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "description",
|
||||
},
|
||||
{
|
||||
Name: "default",
|
||||
},
|
||||
{
|
||||
Name: "type",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var outputBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "description",
|
||||
},
|
||||
{
|
||||
Name: "value",
|
||||
Required: true,
|
||||
},
|
||||
{
|
||||
Name: "depends_on",
|
||||
},
|
||||
{
|
||||
Name: "sensitive",
|
||||
},
|
||||
},
|
||||
}
|
||||
100
vendor/github.com/hashicorp/terraform/configs/parser.go
generated
vendored
Normal file
100
vendor/github.com/hashicorp/terraform/configs/parser.go
generated
vendored
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hclparse"
|
||||
"github.com/spf13/afero"
|
||||
)
|
||||
|
||||
// Parser is the main interface to read configuration files and other related
|
||||
// files from disk.
|
||||
//
|
||||
// It retains a cache of all files that are loaded so that they can be used
|
||||
// to create source code snippets in diagnostics, etc.
|
||||
type Parser struct {
|
||||
fs afero.Afero
|
||||
p *hclparse.Parser
|
||||
}
|
||||
|
||||
// NewParser creates and returns a new Parser that reads files from the given
|
||||
// filesystem. If a nil filesystem is passed then the system's "real" filesystem
|
||||
// will be used, via afero.OsFs.
|
||||
func NewParser(fs afero.Fs) *Parser {
|
||||
if fs == nil {
|
||||
fs = afero.OsFs{}
|
||||
}
|
||||
|
||||
return &Parser{
|
||||
fs: afero.Afero{Fs: fs},
|
||||
p: hclparse.NewParser(),
|
||||
}
|
||||
}
|
||||
|
||||
// LoadHCLFile is a low-level method that reads the file at the given path,
|
||||
// parses it, and returns the hcl.Body representing its root. In many cases
|
||||
// it is better to use one of the other Load*File methods on this type,
|
||||
// which additionally decode the root body in some way and return a higher-level
|
||||
// construct.
|
||||
//
|
||||
// If the file cannot be read at all -- e.g. because it does not exist -- then
|
||||
// this method will return a nil body and error diagnostics. In this case
|
||||
// callers may wish to ignore the provided error diagnostics and produce
|
||||
// a more context-sensitive error instead.
|
||||
//
|
||||
// The file will be parsed using the HCL native syntax unless the filename
|
||||
// ends with ".json", in which case the HCL JSON syntax will be used.
|
||||
func (p *Parser) LoadHCLFile(path string) (hcl.Body, hcl.Diagnostics) {
|
||||
src, err := p.fs.ReadFile(path)
|
||||
|
||||
if err != nil {
|
||||
return nil, hcl.Diagnostics{
|
||||
{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to read file",
|
||||
Detail: fmt.Sprintf("The file %q could not be read.", path),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
var file *hcl.File
|
||||
var diags hcl.Diagnostics
|
||||
switch {
|
||||
case strings.HasSuffix(path, ".json"):
|
||||
file, diags = p.p.ParseJSON(src, path)
|
||||
default:
|
||||
file, diags = p.p.ParseHCL(src, path)
|
||||
}
|
||||
|
||||
// If the returned file or body is nil, then we'll return a non-nil empty
|
||||
// body so we'll meet our contract that nil means an error reading the file.
|
||||
if file == nil || file.Body == nil {
|
||||
return hcl.EmptyBody(), diags
|
||||
}
|
||||
|
||||
return file.Body, diags
|
||||
}
|
||||
|
||||
// Sources returns a map of the cached source buffers for all files that
|
||||
// have been loaded through this parser, with source filenames (as requested
|
||||
// when each file was opened) as the keys.
|
||||
func (p *Parser) Sources() map[string][]byte {
|
||||
return p.p.Sources()
|
||||
}
|
||||
|
||||
// ForceFileSource artificially adds source code to the cache of file sources,
|
||||
// as if it had been loaded from the given filename.
|
||||
//
|
||||
// This should be used only in special situations where configuration is loaded
|
||||
// some other way. Most callers should load configuration via methods of
|
||||
// Parser, which will update the sources cache automatically.
|
||||
func (p *Parser) ForceFileSource(filename string, src []byte) {
|
||||
// We'll make a synthetic hcl.File here just so we can reuse the
|
||||
// existing cache.
|
||||
p.p.AddFile(filename, &hcl.File{
|
||||
Body: hcl.EmptyBody(),
|
||||
Bytes: src,
|
||||
})
|
||||
}
|
||||
247
vendor/github.com/hashicorp/terraform/configs/parser_config.go
generated
vendored
Normal file
247
vendor/github.com/hashicorp/terraform/configs/parser_config.go
generated
vendored
Normal file
|
|
@ -0,0 +1,247 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
// LoadConfigFile reads the file at the given path and parses it as a config
|
||||
// file.
|
||||
//
|
||||
// If the file cannot be read -- for example, if it does not exist -- then
|
||||
// a nil *File will be returned along with error diagnostics. Callers may wish
|
||||
// to disregard the returned diagnostics in this case and instead generate
|
||||
// their own error message(s) with additional context.
|
||||
//
|
||||
// If the returned diagnostics has errors when a non-nil map is returned
|
||||
// then the map may be incomplete but should be valid enough for careful
|
||||
// static analysis.
|
||||
//
|
||||
// This method wraps LoadHCLFile, and so it inherits the syntax selection
|
||||
// behaviors documented for that method.
|
||||
func (p *Parser) LoadConfigFile(path string) (*File, hcl.Diagnostics) {
|
||||
return p.loadConfigFile(path, false)
|
||||
}
|
||||
|
||||
// LoadConfigFileOverride is the same as LoadConfigFile except that it relaxes
|
||||
// certain required attribute constraints in order to interpret the given
|
||||
// file as an overrides file.
|
||||
func (p *Parser) LoadConfigFileOverride(path string) (*File, hcl.Diagnostics) {
|
||||
return p.loadConfigFile(path, true)
|
||||
}
|
||||
|
||||
func (p *Parser) loadConfigFile(path string, override bool) (*File, hcl.Diagnostics) {
|
||||
|
||||
body, diags := p.LoadHCLFile(path)
|
||||
if body == nil {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
file := &File{}
|
||||
|
||||
var reqDiags hcl.Diagnostics
|
||||
file.CoreVersionConstraints, reqDiags = sniffCoreVersionRequirements(body)
|
||||
diags = append(diags, reqDiags...)
|
||||
|
||||
content, contentDiags := body.Content(configFileSchema)
|
||||
diags = append(diags, contentDiags...)
|
||||
|
||||
for _, block := range content.Blocks {
|
||||
switch block.Type {
|
||||
|
||||
case "terraform":
|
||||
content, contentDiags := block.Body.Content(terraformBlockSchema)
|
||||
diags = append(diags, contentDiags...)
|
||||
|
||||
// We ignore the "terraform_version" attribute here because
|
||||
// sniffCoreVersionRequirements already dealt with that above.
|
||||
|
||||
for _, innerBlock := range content.Blocks {
|
||||
switch innerBlock.Type {
|
||||
|
||||
case "backend":
|
||||
backendCfg, cfgDiags := decodeBackendBlock(innerBlock)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if backendCfg != nil {
|
||||
file.Backends = append(file.Backends, backendCfg)
|
||||
}
|
||||
|
||||
case "required_providers":
|
||||
reqs, reqsDiags := decodeRequiredProvidersBlock(innerBlock)
|
||||
diags = append(diags, reqsDiags...)
|
||||
file.ProviderRequirements = append(file.ProviderRequirements, reqs...)
|
||||
|
||||
default:
|
||||
// Should never happen because the above cases should be exhaustive
|
||||
// for all block type names in our schema.
|
||||
continue
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
case "provider":
|
||||
cfg, cfgDiags := decodeProviderBlock(block)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.ProviderConfigs = append(file.ProviderConfigs, cfg)
|
||||
}
|
||||
|
||||
case "variable":
|
||||
cfg, cfgDiags := decodeVariableBlock(block, override)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.Variables = append(file.Variables, cfg)
|
||||
}
|
||||
|
||||
case "locals":
|
||||
defs, defsDiags := decodeLocalsBlock(block)
|
||||
diags = append(diags, defsDiags...)
|
||||
file.Locals = append(file.Locals, defs...)
|
||||
|
||||
case "output":
|
||||
cfg, cfgDiags := decodeOutputBlock(block, override)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.Outputs = append(file.Outputs, cfg)
|
||||
}
|
||||
|
||||
case "module":
|
||||
cfg, cfgDiags := decodeModuleBlock(block, override)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.ModuleCalls = append(file.ModuleCalls, cfg)
|
||||
}
|
||||
|
||||
case "resource":
|
||||
cfg, cfgDiags := decodeResourceBlock(block)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.ManagedResources = append(file.ManagedResources, cfg)
|
||||
}
|
||||
|
||||
case "data":
|
||||
cfg, cfgDiags := decodeDataBlock(block)
|
||||
diags = append(diags, cfgDiags...)
|
||||
if cfg != nil {
|
||||
file.DataResources = append(file.DataResources, cfg)
|
||||
}
|
||||
|
||||
default:
|
||||
// Should never happen because the above cases should be exhaustive
|
||||
// for all block type names in our schema.
|
||||
continue
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return file, diags
|
||||
}
|
||||
|
||||
// sniffCoreVersionRequirements does minimal parsing of the given body for
|
||||
// "terraform" blocks with "required_version" attributes, returning the
|
||||
// requirements found.
|
||||
//
|
||||
// This is intended to maximize the chance that we'll be able to read the
|
||||
// requirements (syntax errors notwithstanding) even if the config file contains
|
||||
// constructs that might've been added in future Terraform versions
|
||||
//
|
||||
// This is a "best effort" sort of method which will return constraints it is
|
||||
// able to find, but may return no constraints at all if the given body is
|
||||
// so invalid that it cannot be decoded at all.
|
||||
func sniffCoreVersionRequirements(body hcl.Body) ([]VersionConstraint, hcl.Diagnostics) {
|
||||
rootContent, _, diags := body.PartialContent(configFileVersionSniffRootSchema)
|
||||
|
||||
var constraints []VersionConstraint
|
||||
|
||||
for _, block := range rootContent.Blocks {
|
||||
content, _, blockDiags := block.Body.PartialContent(configFileVersionSniffBlockSchema)
|
||||
diags = append(diags, blockDiags...)
|
||||
|
||||
attr, exists := content.Attributes["required_version"]
|
||||
if !exists {
|
||||
continue
|
||||
}
|
||||
|
||||
constraint, constraintDiags := decodeVersionConstraint(attr)
|
||||
diags = append(diags, constraintDiags...)
|
||||
if !constraintDiags.HasErrors() {
|
||||
constraints = append(constraints, constraint)
|
||||
}
|
||||
}
|
||||
|
||||
return constraints, diags
|
||||
}
|
||||
|
||||
// configFileSchema is the schema for the top-level of a config file. We use
|
||||
// the low-level HCL API for this level so we can easily deal with each
|
||||
// block type separately with its own decoding logic.
|
||||
var configFileSchema = &hcl.BodySchema{
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "terraform",
|
||||
},
|
||||
{
|
||||
Type: "provider",
|
||||
LabelNames: []string{"name"},
|
||||
},
|
||||
{
|
||||
Type: "variable",
|
||||
LabelNames: []string{"name"},
|
||||
},
|
||||
{
|
||||
Type: "locals",
|
||||
},
|
||||
{
|
||||
Type: "output",
|
||||
LabelNames: []string{"name"},
|
||||
},
|
||||
{
|
||||
Type: "module",
|
||||
LabelNames: []string{"name"},
|
||||
},
|
||||
{
|
||||
Type: "resource",
|
||||
LabelNames: []string{"type", "name"},
|
||||
},
|
||||
{
|
||||
Type: "data",
|
||||
LabelNames: []string{"type", "name"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// terraformBlockSchema is the schema for a top-level "terraform" block in
|
||||
// a configuration file.
|
||||
var terraformBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "required_version",
|
||||
},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "backend",
|
||||
LabelNames: []string{"type"},
|
||||
},
|
||||
{
|
||||
Type: "required_providers",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// configFileVersionSniffRootSchema is a schema for sniffCoreVersionRequirements
|
||||
var configFileVersionSniffRootSchema = &hcl.BodySchema{
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{
|
||||
Type: "terraform",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// configFileVersionSniffBlockSchema is a schema for sniffCoreVersionRequirements
|
||||
var configFileVersionSniffBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "required_version",
|
||||
},
|
||||
},
|
||||
}
|
||||
142
vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
generated
vendored
Normal file
142
vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
generated
vendored
Normal file
|
|
@ -0,0 +1,142 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
// LoadConfigDir reads the .tf and .tf.json files in the given directory
|
||||
// as config files (using LoadConfigFile) and then combines these files into
|
||||
// a single Module.
|
||||
//
|
||||
// If this method returns nil, that indicates that the given directory does not
|
||||
// exist at all or could not be opened for some reason. Callers may wish to
|
||||
// detect this case and ignore the returned diagnostics so that they can
|
||||
// produce a more context-aware error message in that case.
|
||||
//
|
||||
// If this method returns a non-nil module while error diagnostics are returned
|
||||
// then the module may be incomplete but can be used carefully for static
|
||||
// analysis.
|
||||
//
|
||||
// This file does not consider a directory with no files to be an error, and
|
||||
// will simply return an empty module in that case. Callers should first call
|
||||
// Parser.IsConfigDir if they wish to recognize that situation.
|
||||
//
|
||||
// .tf files are parsed using the HCL native syntax while .tf.json files are
|
||||
// parsed using the HCL JSON syntax.
|
||||
func (p *Parser) LoadConfigDir(path string) (*Module, hcl.Diagnostics) {
|
||||
primaryPaths, overridePaths, diags := p.dirFiles(path)
|
||||
if diags.HasErrors() {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
primary, fDiags := p.loadFiles(primaryPaths, false)
|
||||
diags = append(diags, fDiags...)
|
||||
override, fDiags := p.loadFiles(overridePaths, true)
|
||||
diags = append(diags, fDiags...)
|
||||
|
||||
mod, modDiags := NewModule(primary, override)
|
||||
diags = append(diags, modDiags...)
|
||||
|
||||
mod.SourceDir = path
|
||||
|
||||
return mod, diags
|
||||
}
|
||||
|
||||
// ConfigDirFiles returns lists of the primary and override files configuration
|
||||
// files in the given directory.
|
||||
//
|
||||
// If the given directory does not exist or cannot be read, error diagnostics
|
||||
// are returned. If errors are returned, the resulting lists may be incomplete.
|
||||
func (p Parser) ConfigDirFiles(dir string) (primary, override []string, diags hcl.Diagnostics) {
|
||||
return p.dirFiles(dir)
|
||||
}
|
||||
|
||||
// IsConfigDir determines whether the given path refers to a directory that
|
||||
// exists and contains at least one Terraform config file (with a .tf or
|
||||
// .tf.json extension.)
|
||||
func (p *Parser) IsConfigDir(path string) bool {
|
||||
primaryPaths, overridePaths, _ := p.dirFiles(path)
|
||||
return (len(primaryPaths) + len(overridePaths)) > 0
|
||||
}
|
||||
|
||||
func (p *Parser) loadFiles(paths []string, override bool) ([]*File, hcl.Diagnostics) {
|
||||
var files []*File
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
for _, path := range paths {
|
||||
var f *File
|
||||
var fDiags hcl.Diagnostics
|
||||
if override {
|
||||
f, fDiags = p.LoadConfigFileOverride(path)
|
||||
} else {
|
||||
f, fDiags = p.LoadConfigFile(path)
|
||||
}
|
||||
diags = append(diags, fDiags...)
|
||||
if f != nil {
|
||||
files = append(files, f)
|
||||
}
|
||||
}
|
||||
|
||||
return files, diags
|
||||
}
|
||||
|
||||
func (p *Parser) dirFiles(dir string) (primary, override []string, diags hcl.Diagnostics) {
|
||||
infos, err := p.fs.ReadDir(dir)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Failed to read module directory",
|
||||
Detail: fmt.Sprintf("Module directory %s does not exist or cannot be read.", dir),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
for _, info := range infos {
|
||||
if info.IsDir() {
|
||||
// We only care about files
|
||||
continue
|
||||
}
|
||||
|
||||
name := info.Name()
|
||||
ext := fileExt(name)
|
||||
if ext == "" || IsIgnoredFile(name) {
|
||||
continue
|
||||
}
|
||||
|
||||
baseName := name[:len(name)-len(ext)] // strip extension
|
||||
isOverride := baseName == "override" || strings.HasSuffix(baseName, "_override")
|
||||
|
||||
fullPath := filepath.Join(dir, name)
|
||||
if isOverride {
|
||||
override = append(override, fullPath)
|
||||
} else {
|
||||
primary = append(primary, fullPath)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// fileExt returns the Terraform configuration extension of the given
|
||||
// path, or a blank string if it is not a recognized extension.
|
||||
func fileExt(path string) string {
|
||||
if strings.HasSuffix(path, ".tf") {
|
||||
return ".tf"
|
||||
} else if strings.HasSuffix(path, ".tf.json") {
|
||||
return ".tf.json"
|
||||
} else {
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
// IsIgnoredFile returns true if the given filename (which must not have a
|
||||
// directory path ahead of it) should be ignored as e.g. an editor swap file.
|
||||
func IsIgnoredFile(name string) bool {
|
||||
return strings.HasPrefix(name, ".") || // Unix-like hidden files
|
||||
strings.HasSuffix(name, "~") || // vim
|
||||
strings.HasPrefix(name, "#") && strings.HasSuffix(name, "#") // emacs
|
||||
}
|
||||
43
vendor/github.com/hashicorp/terraform/configs/parser_values.go
generated
vendored
Normal file
43
vendor/github.com/hashicorp/terraform/configs/parser_values.go
generated
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// LoadValuesFile reads the file at the given path and parses it as a "values
|
||||
// file", which is an HCL config file whose top-level attributes are treated
|
||||
// as arbitrary key.value pairs.
|
||||
//
|
||||
// If the file cannot be read -- for example, if it does not exist -- then
|
||||
// a nil map will be returned along with error diagnostics. Callers may wish
|
||||
// to disregard the returned diagnostics in this case and instead generate
|
||||
// their own error message(s) with additional context.
|
||||
//
|
||||
// If the returned diagnostics has errors when a non-nil map is returned
|
||||
// then the map may be incomplete but should be valid enough for careful
|
||||
// static analysis.
|
||||
//
|
||||
// This method wraps LoadHCLFile, and so it inherits the syntax selection
|
||||
// behaviors documented for that method.
|
||||
func (p *Parser) LoadValuesFile(path string) (map[string]cty.Value, hcl.Diagnostics) {
|
||||
body, diags := p.LoadHCLFile(path)
|
||||
if body == nil {
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
vals := make(map[string]cty.Value)
|
||||
attrs, attrDiags := body.JustAttributes()
|
||||
diags = append(diags, attrDiags...)
|
||||
if attrs == nil {
|
||||
return vals, diags
|
||||
}
|
||||
|
||||
for name, attr := range attrs {
|
||||
val, valDiags := attr.Expr.Value(nil)
|
||||
diags = append(diags, valDiags...)
|
||||
vals[name] = val
|
||||
}
|
||||
|
||||
return vals, diags
|
||||
}
|
||||
144
vendor/github.com/hashicorp/terraform/configs/provider.go
generated
vendored
Normal file
144
vendor/github.com/hashicorp/terraform/configs/provider.go
generated
vendored
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/gohcl"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// Provider represents a "provider" block in a module or file. A provider
|
||||
// block is a provider configuration, and there can be zero or more
|
||||
// configurations for each actual provider.
|
||||
type Provider struct {
|
||||
Name string
|
||||
NameRange hcl.Range
|
||||
Alias string
|
||||
AliasRange *hcl.Range // nil if no alias set
|
||||
|
||||
Version VersionConstraint
|
||||
|
||||
Config hcl.Body
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeProviderBlock(block *hcl.Block) (*Provider, hcl.Diagnostics) {
|
||||
content, config, diags := block.Body.PartialContent(providerBlockSchema)
|
||||
|
||||
provider := &Provider{
|
||||
Name: block.Labels[0],
|
||||
NameRange: block.LabelRanges[0],
|
||||
Config: config,
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["alias"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &provider.Alias)
|
||||
diags = append(diags, valDiags...)
|
||||
provider.AliasRange = attr.Expr.Range().Ptr()
|
||||
|
||||
if !hclsyntax.ValidIdentifier(provider.Alias) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration alias",
|
||||
Detail: fmt.Sprintf("An alias must be a valid name. %s", badIdentifierDetail),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["version"]; exists {
|
||||
var versionDiags hcl.Diagnostics
|
||||
provider.Version, versionDiags = decodeVersionConstraint(attr)
|
||||
diags = append(diags, versionDiags...)
|
||||
}
|
||||
|
||||
// Reserved attribute names
|
||||
for _, name := range []string{"count", "depends_on", "for_each", "source"} {
|
||||
if attr, exists := content.Attributes[name]; exists {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in provider block",
|
||||
Detail: fmt.Sprintf("The provider argument name %q is reserved for use by Terraform in a future version.", name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Reserved block types (all of them)
|
||||
for _, block := range content.Blocks {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved block type name in provider block",
|
||||
Detail: fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
|
||||
Subject: &block.TypeRange,
|
||||
})
|
||||
}
|
||||
|
||||
return provider, diags
|
||||
}
|
||||
|
||||
// Addr returns the address of the receiving provider configuration, relative
|
||||
// to its containing module.
|
||||
func (p *Provider) Addr() addrs.ProviderConfig {
|
||||
return addrs.ProviderConfig{
|
||||
Type: p.Name,
|
||||
Alias: p.Alias,
|
||||
}
|
||||
}
|
||||
|
||||
func (p *Provider) moduleUniqueKey() string {
|
||||
if p.Alias != "" {
|
||||
return fmt.Sprintf("%s.%s", p.Name, p.Alias)
|
||||
}
|
||||
return p.Name
|
||||
}
|
||||
|
||||
// ProviderRequirement represents a declaration of a dependency on a particular
|
||||
// provider version without actually configuring that provider. This is used in
|
||||
// child modules that expect a provider to be passed in from their parent.
|
||||
type ProviderRequirement struct {
|
||||
Name string
|
||||
Requirement VersionConstraint
|
||||
}
|
||||
|
||||
func decodeRequiredProvidersBlock(block *hcl.Block) ([]*ProviderRequirement, hcl.Diagnostics) {
|
||||
attrs, diags := block.Body.JustAttributes()
|
||||
var reqs []*ProviderRequirement
|
||||
for name, attr := range attrs {
|
||||
req, reqDiags := decodeVersionConstraint(attr)
|
||||
diags = append(diags, reqDiags...)
|
||||
if !diags.HasErrors() {
|
||||
reqs = append(reqs, &ProviderRequirement{
|
||||
Name: name,
|
||||
Requirement: req,
|
||||
})
|
||||
}
|
||||
}
|
||||
return reqs, diags
|
||||
}
|
||||
|
||||
var providerBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "alias",
|
||||
},
|
||||
{
|
||||
Name: "version",
|
||||
},
|
||||
|
||||
// Attribute names reserved for future expansion.
|
||||
{Name: "count"},
|
||||
{Name: "depends_on"},
|
||||
{Name: "for_each"},
|
||||
{Name: "source"},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
// _All_ of these are reserved for future expansion.
|
||||
{Type: "lifecycle"},
|
||||
{Type: "locals"},
|
||||
},
|
||||
}
|
||||
150
vendor/github.com/hashicorp/terraform/configs/provisioner.go
generated
vendored
Normal file
150
vendor/github.com/hashicorp/terraform/configs/provisioner.go
generated
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
)
|
||||
|
||||
// Provisioner represents a "provisioner" block when used within a
|
||||
// "resource" block in a module or file.
|
||||
type Provisioner struct {
|
||||
Type string
|
||||
Config hcl.Body
|
||||
Connection *Connection
|
||||
When ProvisionerWhen
|
||||
OnFailure ProvisionerOnFailure
|
||||
|
||||
DeclRange hcl.Range
|
||||
TypeRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeProvisionerBlock(block *hcl.Block) (*Provisioner, hcl.Diagnostics) {
|
||||
pv := &Provisioner{
|
||||
Type: block.Labels[0],
|
||||
TypeRange: block.LabelRanges[0],
|
||||
DeclRange: block.DefRange,
|
||||
When: ProvisionerWhenCreate,
|
||||
OnFailure: ProvisionerOnFailureFail,
|
||||
}
|
||||
|
||||
content, config, diags := block.Body.PartialContent(provisionerBlockSchema)
|
||||
pv.Config = config
|
||||
|
||||
if attr, exists := content.Attributes["when"]; exists {
|
||||
expr, shimDiags := shimTraversalInString(attr.Expr, true)
|
||||
diags = append(diags, shimDiags...)
|
||||
|
||||
switch hcl.ExprAsKeyword(expr) {
|
||||
case "create":
|
||||
pv.When = ProvisionerWhenCreate
|
||||
case "destroy":
|
||||
pv.When = ProvisionerWhenDestroy
|
||||
default:
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid \"when\" keyword",
|
||||
Detail: "The \"when\" argument requires one of the following keywords: create or destroy.",
|
||||
Subject: expr.Range().Ptr(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["on_failure"]; exists {
|
||||
expr, shimDiags := shimTraversalInString(attr.Expr, true)
|
||||
diags = append(diags, shimDiags...)
|
||||
|
||||
switch hcl.ExprAsKeyword(expr) {
|
||||
case "continue":
|
||||
pv.OnFailure = ProvisionerOnFailureContinue
|
||||
case "fail":
|
||||
pv.OnFailure = ProvisionerOnFailureFail
|
||||
default:
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid \"on_failure\" keyword",
|
||||
Detail: "The \"on_failure\" argument requires one of the following keywords: continue or fail.",
|
||||
Subject: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
var seenConnection *hcl.Block
|
||||
for _, block := range content.Blocks {
|
||||
switch block.Type {
|
||||
|
||||
case "connection":
|
||||
if seenConnection != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate connection block",
|
||||
Detail: fmt.Sprintf("This provisioner already has a connection block at %s.", seenConnection.DefRange),
|
||||
Subject: &block.DefRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
seenConnection = block
|
||||
|
||||
//conn, connDiags := decodeConnectionBlock(block)
|
||||
//diags = append(diags, connDiags...)
|
||||
pv.Connection = &Connection{
|
||||
Config: block.Body,
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
default:
|
||||
// Any other block types are ones we've reserved for future use,
|
||||
// so they get a generic message.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved block type name in provisioner block",
|
||||
Detail: fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
|
||||
Subject: &block.TypeRange,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return pv, diags
|
||||
}
|
||||
|
||||
// Connection represents a "connection" block when used within either a
|
||||
// "resource" or "provisioner" block in a module or file.
|
||||
type Connection struct {
|
||||
Config hcl.Body
|
||||
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
// ProvisionerWhen is an enum for valid values for when to run provisioners.
|
||||
type ProvisionerWhen int
|
||||
|
||||
//go:generate stringer -type ProvisionerWhen
|
||||
|
||||
const (
|
||||
ProvisionerWhenInvalid ProvisionerWhen = iota
|
||||
ProvisionerWhenCreate
|
||||
ProvisionerWhenDestroy
|
||||
)
|
||||
|
||||
// ProvisionerOnFailure is an enum for valid values for on_failure options
|
||||
// for provisioners.
|
||||
type ProvisionerOnFailure int
|
||||
|
||||
//go:generate stringer -type ProvisionerOnFailure
|
||||
|
||||
const (
|
||||
ProvisionerOnFailureInvalid ProvisionerOnFailure = iota
|
||||
ProvisionerOnFailureContinue
|
||||
ProvisionerOnFailureFail
|
||||
)
|
||||
|
||||
var provisionerBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{Name: "when"},
|
||||
{Name: "on_failure"},
|
||||
},
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{Type: "connection"},
|
||||
{Type: "lifecycle"}, // reserved for future use
|
||||
},
|
||||
}
|
||||
16
vendor/github.com/hashicorp/terraform/configs/provisioneronfailure_string.go
generated
vendored
Normal file
16
vendor/github.com/hashicorp/terraform/configs/provisioneronfailure_string.go
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
// Code generated by "stringer -type ProvisionerOnFailure"; DO NOT EDIT.
|
||||
|
||||
package configs
|
||||
|
||||
import "strconv"
|
||||
|
||||
const _ProvisionerOnFailure_name = "ProvisionerOnFailureInvalidProvisionerOnFailureContinueProvisionerOnFailureFail"
|
||||
|
||||
var _ProvisionerOnFailure_index = [...]uint8{0, 27, 55, 79}
|
||||
|
||||
func (i ProvisionerOnFailure) String() string {
|
||||
if i < 0 || i >= ProvisionerOnFailure(len(_ProvisionerOnFailure_index)-1) {
|
||||
return "ProvisionerOnFailure(" + strconv.FormatInt(int64(i), 10) + ")"
|
||||
}
|
||||
return _ProvisionerOnFailure_name[_ProvisionerOnFailure_index[i]:_ProvisionerOnFailure_index[i+1]]
|
||||
}
|
||||
16
vendor/github.com/hashicorp/terraform/configs/provisionerwhen_string.go
generated
vendored
Normal file
16
vendor/github.com/hashicorp/terraform/configs/provisionerwhen_string.go
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
// Code generated by "stringer -type ProvisionerWhen"; DO NOT EDIT.
|
||||
|
||||
package configs
|
||||
|
||||
import "strconv"
|
||||
|
||||
const _ProvisionerWhen_name = "ProvisionerWhenInvalidProvisionerWhenCreateProvisionerWhenDestroy"
|
||||
|
||||
var _ProvisionerWhen_index = [...]uint8{0, 22, 43, 65}
|
||||
|
||||
func (i ProvisionerWhen) String() string {
|
||||
if i < 0 || i >= ProvisionerWhen(len(_ProvisionerWhen_index)-1) {
|
||||
return "ProvisionerWhen(" + strconv.FormatInt(int64(i), 10) + ")"
|
||||
}
|
||||
return _ProvisionerWhen_name[_ProvisionerWhen_index[i]:_ProvisionerWhen_index[i+1]]
|
||||
}
|
||||
486
vendor/github.com/hashicorp/terraform/configs/resource.go
generated
vendored
Normal file
486
vendor/github.com/hashicorp/terraform/configs/resource.go
generated
vendored
Normal file
|
|
@ -0,0 +1,486 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/gohcl"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
)
|
||||
|
||||
// Resource represents a "resource" or "data" block in a module or file.
|
||||
type Resource struct {
|
||||
Mode addrs.ResourceMode
|
||||
Name string
|
||||
Type string
|
||||
Config hcl.Body
|
||||
Count hcl.Expression
|
||||
ForEach hcl.Expression
|
||||
|
||||
ProviderConfigRef *ProviderConfigRef
|
||||
|
||||
DependsOn []hcl.Traversal
|
||||
|
||||
// Managed is populated only for Mode = addrs.ManagedResourceMode,
|
||||
// containing the additional fields that apply to managed resources.
|
||||
// For all other resource modes, this field is nil.
|
||||
Managed *ManagedResource
|
||||
|
||||
DeclRange hcl.Range
|
||||
TypeRange hcl.Range
|
||||
}
|
||||
|
||||
// ManagedResource represents a "resource" block in a module or file.
|
||||
type ManagedResource struct {
|
||||
Connection *Connection
|
||||
Provisioners []*Provisioner
|
||||
|
||||
CreateBeforeDestroy bool
|
||||
PreventDestroy bool
|
||||
IgnoreChanges []hcl.Traversal
|
||||
IgnoreAllChanges bool
|
||||
|
||||
CreateBeforeDestroySet bool
|
||||
PreventDestroySet bool
|
||||
}
|
||||
|
||||
func (r *Resource) moduleUniqueKey() string {
|
||||
return r.Addr().String()
|
||||
}
|
||||
|
||||
// Addr returns a resource address for the receiver that is relative to the
|
||||
// resource's containing module.
|
||||
func (r *Resource) Addr() addrs.Resource {
|
||||
return addrs.Resource{
|
||||
Mode: r.Mode,
|
||||
Type: r.Type,
|
||||
Name: r.Name,
|
||||
}
|
||||
}
|
||||
|
||||
// ProviderConfigAddr returns the address for the provider configuration
|
||||
// that should be used for this resource. This function implements the
|
||||
// default behavior of extracting the type from the resource type name if
|
||||
// an explicit "provider" argument was not provided.
|
||||
func (r *Resource) ProviderConfigAddr() addrs.ProviderConfig {
|
||||
if r.ProviderConfigRef == nil {
|
||||
return r.Addr().DefaultProviderConfig()
|
||||
}
|
||||
|
||||
return addrs.ProviderConfig{
|
||||
Type: r.ProviderConfigRef.Name,
|
||||
Alias: r.ProviderConfigRef.Alias,
|
||||
}
|
||||
}
|
||||
|
||||
func decodeResourceBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
|
||||
r := &Resource{
|
||||
Mode: addrs.ManagedResourceMode,
|
||||
Type: block.Labels[0],
|
||||
Name: block.Labels[1],
|
||||
DeclRange: block.DefRange,
|
||||
TypeRange: block.LabelRanges[0],
|
||||
Managed: &ManagedResource{},
|
||||
}
|
||||
|
||||
content, remain, diags := block.Body.PartialContent(resourceBlockSchema)
|
||||
r.Config = remain
|
||||
|
||||
if !hclsyntax.ValidIdentifier(r.Type) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid resource type name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
if !hclsyntax.ValidIdentifier(r.Name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid resource name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[1],
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["count"]; exists {
|
||||
r.Count = attr.Expr
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["for_each"]; exists {
|
||||
r.ForEach = attr.Expr
|
||||
// We currently parse this, but don't yet do anything with it.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in resource block",
|
||||
Detail: fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["provider"]; exists {
|
||||
var providerDiags hcl.Diagnostics
|
||||
r.ProviderConfigRef, providerDiags = decodeProviderConfigRef(attr.Expr, "provider")
|
||||
diags = append(diags, providerDiags...)
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["depends_on"]; exists {
|
||||
deps, depsDiags := decodeDependsOn(attr)
|
||||
diags = append(diags, depsDiags...)
|
||||
r.DependsOn = append(r.DependsOn, deps...)
|
||||
}
|
||||
|
||||
var seenLifecycle *hcl.Block
|
||||
var seenConnection *hcl.Block
|
||||
for _, block := range content.Blocks {
|
||||
switch block.Type {
|
||||
case "lifecycle":
|
||||
if seenLifecycle != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate lifecycle block",
|
||||
Detail: fmt.Sprintf("This resource already has a lifecycle block at %s.", seenLifecycle.DefRange),
|
||||
Subject: &block.DefRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
seenLifecycle = block
|
||||
|
||||
lcContent, lcDiags := block.Body.Content(resourceLifecycleBlockSchema)
|
||||
diags = append(diags, lcDiags...)
|
||||
|
||||
if attr, exists := lcContent.Attributes["create_before_destroy"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &r.Managed.CreateBeforeDestroy)
|
||||
diags = append(diags, valDiags...)
|
||||
r.Managed.CreateBeforeDestroySet = true
|
||||
}
|
||||
|
||||
if attr, exists := lcContent.Attributes["prevent_destroy"]; exists {
|
||||
valDiags := gohcl.DecodeExpression(attr.Expr, nil, &r.Managed.PreventDestroy)
|
||||
diags = append(diags, valDiags...)
|
||||
r.Managed.PreventDestroySet = true
|
||||
}
|
||||
|
||||
if attr, exists := lcContent.Attributes["ignore_changes"]; exists {
|
||||
|
||||
// ignore_changes can either be a list of relative traversals
|
||||
// or it can be just the keyword "all" to ignore changes to this
|
||||
// resource entirely.
|
||||
// ignore_changes = [ami, instance_type]
|
||||
// ignore_changes = all
|
||||
// We also allow two legacy forms for compatibility with earlier
|
||||
// versions:
|
||||
// ignore_changes = ["ami", "instance_type"]
|
||||
// ignore_changes = ["*"]
|
||||
|
||||
kw := hcl.ExprAsKeyword(attr.Expr)
|
||||
|
||||
switch {
|
||||
case kw == "all":
|
||||
r.Managed.IgnoreAllChanges = true
|
||||
default:
|
||||
exprs, listDiags := hcl.ExprList(attr.Expr)
|
||||
diags = append(diags, listDiags...)
|
||||
|
||||
var ignoreAllRange hcl.Range
|
||||
|
||||
for _, expr := range exprs {
|
||||
|
||||
// our expr might be the literal string "*", which
|
||||
// we accept as a deprecated way of saying "all".
|
||||
if shimIsIgnoreChangesStar(expr) {
|
||||
r.Managed.IgnoreAllChanges = true
|
||||
ignoreAllRange = expr.Range()
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagWarning,
|
||||
Summary: "Deprecated ignore_changes wildcard",
|
||||
Detail: "The [\"*\"] form of ignore_changes wildcard is deprecated. Use \"ignore_changes = all\" to ignore changes to all attributes.",
|
||||
Subject: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
expr, shimDiags := shimTraversalInString(expr, false)
|
||||
diags = append(diags, shimDiags...)
|
||||
|
||||
traversal, travDiags := hcl.RelTraversalForExpr(expr)
|
||||
diags = append(diags, travDiags...)
|
||||
if len(traversal) != 0 {
|
||||
r.Managed.IgnoreChanges = append(r.Managed.IgnoreChanges, traversal)
|
||||
}
|
||||
}
|
||||
|
||||
if r.Managed.IgnoreAllChanges && len(r.Managed.IgnoreChanges) != 0 {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid ignore_changes ruleset",
|
||||
Detail: "Cannot mix wildcard string \"*\" with non-wildcard references.",
|
||||
Subject: &ignoreAllRange,
|
||||
Context: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
case "connection":
|
||||
if seenConnection != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Duplicate connection block",
|
||||
Detail: fmt.Sprintf("This resource already has a connection block at %s.", seenConnection.DefRange),
|
||||
Subject: &block.DefRange,
|
||||
})
|
||||
continue
|
||||
}
|
||||
seenConnection = block
|
||||
|
||||
r.Managed.Connection = &Connection{
|
||||
Config: block.Body,
|
||||
DeclRange: block.DefRange,
|
||||
}
|
||||
|
||||
case "provisioner":
|
||||
pv, pvDiags := decodeProvisionerBlock(block)
|
||||
diags = append(diags, pvDiags...)
|
||||
if pv != nil {
|
||||
r.Managed.Provisioners = append(r.Managed.Provisioners, pv)
|
||||
}
|
||||
|
||||
default:
|
||||
// Any other block types are ones we've reserved for future use,
|
||||
// so they get a generic message.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved block type name in resource block",
|
||||
Detail: fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
|
||||
Subject: &block.TypeRange,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return r, diags
|
||||
}
|
||||
|
||||
func decodeDataBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
|
||||
r := &Resource{
|
||||
Mode: addrs.DataResourceMode,
|
||||
Type: block.Labels[0],
|
||||
Name: block.Labels[1],
|
||||
DeclRange: block.DefRange,
|
||||
TypeRange: block.LabelRanges[0],
|
||||
}
|
||||
|
||||
content, remain, diags := block.Body.PartialContent(dataBlockSchema)
|
||||
r.Config = remain
|
||||
|
||||
if !hclsyntax.ValidIdentifier(r.Type) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid data source name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[0],
|
||||
})
|
||||
}
|
||||
if !hclsyntax.ValidIdentifier(r.Name) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid data resource name",
|
||||
Detail: badIdentifierDetail,
|
||||
Subject: &block.LabelRanges[1],
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["count"]; exists {
|
||||
r.Count = attr.Expr
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["for_each"]; exists {
|
||||
r.ForEach = attr.Expr
|
||||
// We currently parse this, but don't yet do anything with it.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved argument name in module block",
|
||||
Detail: fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
|
||||
Subject: &attr.NameRange,
|
||||
})
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["provider"]; exists {
|
||||
var providerDiags hcl.Diagnostics
|
||||
r.ProviderConfigRef, providerDiags = decodeProviderConfigRef(attr.Expr, "provider")
|
||||
diags = append(diags, providerDiags...)
|
||||
}
|
||||
|
||||
if attr, exists := content.Attributes["depends_on"]; exists {
|
||||
deps, depsDiags := decodeDependsOn(attr)
|
||||
diags = append(diags, depsDiags...)
|
||||
r.DependsOn = append(r.DependsOn, deps...)
|
||||
}
|
||||
|
||||
for _, block := range content.Blocks {
|
||||
// All of the block types we accept are just reserved for future use, but some get a specialized error message.
|
||||
switch block.Type {
|
||||
case "lifecycle":
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported lifecycle block",
|
||||
Detail: "Data resources do not have lifecycle settings, so a lifecycle block is not allowed.",
|
||||
Subject: &block.DefRange,
|
||||
})
|
||||
default:
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Reserved block type name in data block",
|
||||
Detail: fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
|
||||
Subject: &block.TypeRange,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return r, diags
|
||||
}
|
||||
|
||||
type ProviderConfigRef struct {
|
||||
Name string
|
||||
NameRange hcl.Range
|
||||
Alias string
|
||||
AliasRange *hcl.Range // nil if alias not set
|
||||
}
|
||||
|
||||
func decodeProviderConfigRef(expr hcl.Expression, argName string) (*ProviderConfigRef, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
|
||||
var shimDiags hcl.Diagnostics
|
||||
expr, shimDiags = shimTraversalInString(expr, false)
|
||||
diags = append(diags, shimDiags...)
|
||||
|
||||
traversal, travDiags := hcl.AbsTraversalForExpr(expr)
|
||||
|
||||
// AbsTraversalForExpr produces only generic errors, so we'll discard
|
||||
// the errors given and produce our own with extra context. If we didn't
|
||||
// get any errors then we might still have warnings, though.
|
||||
if !travDiags.HasErrors() {
|
||||
diags = append(diags, travDiags...)
|
||||
}
|
||||
|
||||
if len(traversal) < 1 || len(traversal) > 2 {
|
||||
// A provider reference was given as a string literal in the legacy
|
||||
// configuration language and there are lots of examples out there
|
||||
// showing that usage, so we'll sniff for that situation here and
|
||||
// produce a specialized error message for it to help users find
|
||||
// the new correct form.
|
||||
if exprIsNativeQuotedString(expr) {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration reference",
|
||||
Detail: "A provider configuration reference must not be given in quotes.",
|
||||
Subject: expr.Range().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration reference",
|
||||
Detail: fmt.Sprintf("The %s argument requires a provider type name, optionally followed by a period and then a configuration alias.", argName),
|
||||
Subject: expr.Range().Ptr(),
|
||||
})
|
||||
return nil, diags
|
||||
}
|
||||
|
||||
ret := &ProviderConfigRef{
|
||||
Name: traversal.RootName(),
|
||||
NameRange: traversal[0].SourceRange(),
|
||||
}
|
||||
|
||||
if len(traversal) > 1 {
|
||||
aliasStep, ok := traversal[1].(hcl.TraverseAttr)
|
||||
if !ok {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid provider configuration reference",
|
||||
Detail: "Provider name must either stand alone or be followed by a period and then a configuration alias.",
|
||||
Subject: traversal[1].SourceRange().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
ret.Alias = aliasStep.Name
|
||||
ret.AliasRange = aliasStep.SourceRange().Ptr()
|
||||
}
|
||||
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
// Addr returns the provider config address corresponding to the receiving
|
||||
// config reference.
|
||||
//
|
||||
// This is a trivial conversion, essentially just discarding the source
|
||||
// location information and keeping just the addressing information.
|
||||
func (r *ProviderConfigRef) Addr() addrs.ProviderConfig {
|
||||
return addrs.ProviderConfig{
|
||||
Type: r.Name,
|
||||
Alias: r.Alias,
|
||||
}
|
||||
}
|
||||
|
||||
func (r *ProviderConfigRef) String() string {
|
||||
if r == nil {
|
||||
return "<nil>"
|
||||
}
|
||||
if r.Alias != "" {
|
||||
return fmt.Sprintf("%s.%s", r.Name, r.Alias)
|
||||
}
|
||||
return r.Name
|
||||
}
|
||||
|
||||
var commonResourceAttributes = []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "count",
|
||||
},
|
||||
{
|
||||
Name: "for_each",
|
||||
},
|
||||
{
|
||||
Name: "provider",
|
||||
},
|
||||
{
|
||||
Name: "depends_on",
|
||||
},
|
||||
}
|
||||
|
||||
var resourceBlockSchema = &hcl.BodySchema{
|
||||
Attributes: commonResourceAttributes,
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{Type: "locals"}, // reserved for future use
|
||||
{Type: "lifecycle"},
|
||||
{Type: "connection"},
|
||||
{Type: "provisioner", LabelNames: []string{"type"}},
|
||||
},
|
||||
}
|
||||
|
||||
var dataBlockSchema = &hcl.BodySchema{
|
||||
Attributes: commonResourceAttributes,
|
||||
Blocks: []hcl.BlockHeaderSchema{
|
||||
{Type: "lifecycle"}, // reserved for future use
|
||||
{Type: "locals"}, // reserved for future use
|
||||
},
|
||||
}
|
||||
|
||||
var resourceLifecycleBlockSchema = &hcl.BodySchema{
|
||||
Attributes: []hcl.AttributeSchema{
|
||||
{
|
||||
Name: "create_before_destroy",
|
||||
},
|
||||
{
|
||||
Name: "prevent_destroy",
|
||||
},
|
||||
{
|
||||
Name: "ignore_changes",
|
||||
},
|
||||
},
|
||||
}
|
||||
118
vendor/github.com/hashicorp/terraform/configs/synth_body.go
generated
vendored
Normal file
118
vendor/github.com/hashicorp/terraform/configs/synth_body.go
generated
vendored
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// SynthBody produces a synthetic hcl.Body that behaves as if it had attributes
|
||||
// corresponding to the elements given in the values map.
|
||||
//
|
||||
// This is useful in situations where, for example, values provided on the
|
||||
// command line can override values given in configuration, using MergeBodies.
|
||||
//
|
||||
// The given filename is used in case any diagnostics are returned. Since
|
||||
// the created body is synthetic, it is likely that this will not be a "real"
|
||||
// filename. For example, if from a command line argument it could be
|
||||
// a representation of that argument's name, such as "-var=...".
|
||||
func SynthBody(filename string, values map[string]cty.Value) hcl.Body {
|
||||
return synthBody{
|
||||
Filename: filename,
|
||||
Values: values,
|
||||
}
|
||||
}
|
||||
|
||||
type synthBody struct {
|
||||
Filename string
|
||||
Values map[string]cty.Value
|
||||
}
|
||||
|
||||
func (b synthBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
|
||||
content, remain, diags := b.PartialContent(schema)
|
||||
remainS := remain.(synthBody)
|
||||
for name := range remainS.Values {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Unsupported attribute",
|
||||
Detail: fmt.Sprintf("An attribute named %q is not expected here.", name),
|
||||
Subject: b.synthRange().Ptr(),
|
||||
})
|
||||
}
|
||||
return content, diags
|
||||
}
|
||||
|
||||
func (b synthBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
|
||||
var diags hcl.Diagnostics
|
||||
content := &hcl.BodyContent{
|
||||
Attributes: make(hcl.Attributes),
|
||||
MissingItemRange: b.synthRange(),
|
||||
}
|
||||
|
||||
remainValues := make(map[string]cty.Value)
|
||||
for attrName, val := range b.Values {
|
||||
remainValues[attrName] = val
|
||||
}
|
||||
|
||||
for _, attrS := range schema.Attributes {
|
||||
delete(remainValues, attrS.Name)
|
||||
val, defined := b.Values[attrS.Name]
|
||||
if !defined {
|
||||
if attrS.Required {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Missing required attribute",
|
||||
Detail: fmt.Sprintf("The attribute %q is required, but no definition was found.", attrS.Name),
|
||||
Subject: b.synthRange().Ptr(),
|
||||
})
|
||||
}
|
||||
continue
|
||||
}
|
||||
content.Attributes[attrS.Name] = b.synthAttribute(attrS.Name, val)
|
||||
}
|
||||
|
||||
// We just ignore blocks altogether, because this body type never has
|
||||
// nested blocks.
|
||||
|
||||
remain := synthBody{
|
||||
Filename: b.Filename,
|
||||
Values: remainValues,
|
||||
}
|
||||
|
||||
return content, remain, diags
|
||||
}
|
||||
|
||||
func (b synthBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
|
||||
ret := make(hcl.Attributes)
|
||||
for name, val := range b.Values {
|
||||
ret[name] = b.synthAttribute(name, val)
|
||||
}
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (b synthBody) MissingItemRange() hcl.Range {
|
||||
return b.synthRange()
|
||||
}
|
||||
|
||||
func (b synthBody) synthAttribute(name string, val cty.Value) *hcl.Attribute {
|
||||
rng := b.synthRange()
|
||||
return &hcl.Attribute{
|
||||
Name: name,
|
||||
Expr: &hclsyntax.LiteralValueExpr{
|
||||
Val: val,
|
||||
SrcRange: rng,
|
||||
},
|
||||
NameRange: rng,
|
||||
Range: rng,
|
||||
}
|
||||
}
|
||||
|
||||
func (b synthBody) synthRange() hcl.Range {
|
||||
return hcl.Range{
|
||||
Filename: b.Filename,
|
||||
Start: hcl.Pos{Line: 1, Column: 1},
|
||||
End: hcl.Pos{Line: 1, Column: 1},
|
||||
}
|
||||
}
|
||||
45
vendor/github.com/hashicorp/terraform/configs/util.go
generated
vendored
Normal file
45
vendor/github.com/hashicorp/terraform/configs/util.go
generated
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/hashicorp/hcl2/hcl/hclsyntax"
|
||||
)
|
||||
|
||||
// exprIsNativeQuotedString determines whether the given expression looks like
|
||||
// it's a quoted string in the HCL native syntax.
|
||||
//
|
||||
// This should be used sparingly only for situations where our legacy HCL
|
||||
// decoding would've expected a keyword or reference in quotes but our new
|
||||
// decoding expects the keyword or reference to be provided directly as
|
||||
// an identifier-based expression.
|
||||
func exprIsNativeQuotedString(expr hcl.Expression) bool {
|
||||
_, ok := expr.(*hclsyntax.TemplateExpr)
|
||||
return ok
|
||||
}
|
||||
|
||||
// schemaForOverrides takes a *hcl.BodySchema and produces a new one that is
|
||||
// equivalent except that any required attributes are forced to not be required.
|
||||
//
|
||||
// This is useful for dealing with "override" config files, which are allowed
|
||||
// to omit things that they don't wish to override from the main configuration.
|
||||
//
|
||||
// The returned schema may have some pointers in common with the given schema,
|
||||
// so neither the given schema nor the returned schema should be modified after
|
||||
// using this function in order to avoid confusion.
|
||||
//
|
||||
// Overrides are rarely used, so it's recommended to just create the override
|
||||
// schema on the fly only when it's needed, rather than storing it in a global
|
||||
// variable as we tend to do for a primary schema.
|
||||
func schemaForOverrides(schema *hcl.BodySchema) *hcl.BodySchema {
|
||||
ret := &hcl.BodySchema{
|
||||
Attributes: make([]hcl.AttributeSchema, len(schema.Attributes)),
|
||||
Blocks: schema.Blocks,
|
||||
}
|
||||
|
||||
for i, attrS := range schema.Attributes {
|
||||
ret.Attributes[i] = attrS
|
||||
ret.Attributes[i].Required = false
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
45
vendor/github.com/hashicorp/terraform/configs/variable_type_hint.go
generated
vendored
Normal file
45
vendor/github.com/hashicorp/terraform/configs/variable_type_hint.go
generated
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
package configs
|
||||
|
||||
// VariableTypeHint is an enumeration used for the Variable.TypeHint field,
|
||||
// which is an incompletely-specified type for the variable which is used
|
||||
// as a hint for whether a value provided in an ambiguous context (on the
|
||||
// command line or in an environment variable) should be taken literally as a
|
||||
// string or parsed as an HCL expression to produce a data structure.
|
||||
//
|
||||
// The type hint is applied to runtime values as well, but since it does not
|
||||
// accurately describe a precise type it is not fully-sufficient to infer
|
||||
// the dynamic type of a value passed through a variable.
|
||||
//
|
||||
// These hints use inaccurate terminology for historical reasons. Full details
|
||||
// are in the documentation for each constant in this enumeration, but in
|
||||
// summary:
|
||||
//
|
||||
// TypeHintString requires a primitive type
|
||||
// TypeHintList requires a type that could be converted to a tuple
|
||||
// TypeHintMap requires a type that could be converted to an object
|
||||
type VariableTypeHint rune
|
||||
|
||||
//go:generate stringer -type VariableTypeHint
|
||||
|
||||
// TypeHintNone indicates the absense of a type hint. Values specified in
|
||||
// ambiguous contexts will be treated as literal strings, as if TypeHintString
|
||||
// were selected, but no runtime value checks will be applied. This is reasonable
|
||||
// type hint for a module that is never intended to be used at the top-level
|
||||
// of a configuration, since descendent modules never recieve values from
|
||||
// ambiguous contexts.
|
||||
const TypeHintNone VariableTypeHint = 0
|
||||
|
||||
// TypeHintString spec indicates that a value provided in an ambiguous context
|
||||
// should be treated as a literal string, and additionally requires that the
|
||||
// runtime value for the variable is of a primitive type (string, number, bool).
|
||||
const TypeHintString VariableTypeHint = 'S'
|
||||
|
||||
// TypeHintList indicates that a value provided in an ambiguous context should
|
||||
// be treated as an HCL expression, and additionally requires that the
|
||||
// runtime value for the variable is of an tuple, list, or set type.
|
||||
const TypeHintList VariableTypeHint = 'L'
|
||||
|
||||
// TypeHintMap indicates that a value provided in an ambiguous context should
|
||||
// be treated as an HCL expression, and additionally requires that the
|
||||
// runtime value for the variable is of an object or map type.
|
||||
const TypeHintMap VariableTypeHint = 'M'
|
||||
29
vendor/github.com/hashicorp/terraform/configs/variabletypehint_string.go
generated
vendored
Normal file
29
vendor/github.com/hashicorp/terraform/configs/variabletypehint_string.go
generated
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
// Code generated by "stringer -type VariableTypeHint"; DO NOT EDIT.
|
||||
|
||||
package configs
|
||||
|
||||
import "strconv"
|
||||
|
||||
const (
|
||||
_VariableTypeHint_name_0 = "TypeHintNone"
|
||||
_VariableTypeHint_name_1 = "TypeHintListTypeHintMap"
|
||||
_VariableTypeHint_name_2 = "TypeHintString"
|
||||
)
|
||||
|
||||
var (
|
||||
_VariableTypeHint_index_1 = [...]uint8{0, 12, 23}
|
||||
)
|
||||
|
||||
func (i VariableTypeHint) String() string {
|
||||
switch {
|
||||
case i == 0:
|
||||
return _VariableTypeHint_name_0
|
||||
case 76 <= i && i <= 77:
|
||||
i -= 76
|
||||
return _VariableTypeHint_name_1[_VariableTypeHint_index_1[i]:_VariableTypeHint_index_1[i+1]]
|
||||
case i == 83:
|
||||
return _VariableTypeHint_name_2
|
||||
default:
|
||||
return "VariableTypeHint(" + strconv.FormatInt(int64(i), 10) + ")"
|
||||
}
|
||||
}
|
||||
61
vendor/github.com/hashicorp/terraform/configs/version_constraint.go
generated
vendored
Normal file
61
vendor/github.com/hashicorp/terraform/configs/version_constraint.go
generated
vendored
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
package configs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
version "github.com/hashicorp/go-version"
|
||||
"github.com/hashicorp/hcl2/hcl"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
"github.com/zclconf/go-cty/cty/convert"
|
||||
)
|
||||
|
||||
// VersionConstraint represents a version constraint on some resource
|
||||
// (e.g. Terraform Core, a provider, a module, ...) that carries with it
|
||||
// a source range so that a helpful diagnostic can be printed in the event
|
||||
// that a particular constraint does not match.
|
||||
type VersionConstraint struct {
|
||||
Required version.Constraints
|
||||
DeclRange hcl.Range
|
||||
}
|
||||
|
||||
func decodeVersionConstraint(attr *hcl.Attribute) (VersionConstraint, hcl.Diagnostics) {
|
||||
ret := VersionConstraint{
|
||||
DeclRange: attr.Range,
|
||||
}
|
||||
|
||||
val, diags := attr.Expr.Value(nil)
|
||||
var err error
|
||||
val, err = convert.Convert(val, cty.String)
|
||||
if err != nil {
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid version constraint",
|
||||
Detail: fmt.Sprintf("A string value is required for %s.", attr.Name),
|
||||
Subject: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
if val.IsNull() {
|
||||
// A null version constraint is strange, but we'll just treat it
|
||||
// like an empty constraint set.
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
constraintStr := val.AsString()
|
||||
constraints, err := version.NewConstraint(constraintStr)
|
||||
if err != nil {
|
||||
// NewConstraint doesn't return user-friendly errors, so we'll just
|
||||
// ignore the provided error and produce our own generic one.
|
||||
diags = append(diags, &hcl.Diagnostic{
|
||||
Severity: hcl.DiagError,
|
||||
Summary: "Invalid version constraint",
|
||||
Detail: "This string does not use correct version constraint syntax.", // Not very actionable :(
|
||||
Subject: attr.Expr.Range().Ptr(),
|
||||
})
|
||||
return ret, diags
|
||||
}
|
||||
|
||||
ret.Required = constraints
|
||||
return ret, diags
|
||||
}
|
||||
10
vendor/github.com/hashicorp/terraform/dag/dag.go
generated
vendored
10
vendor/github.com/hashicorp/terraform/dag/dag.go
generated
vendored
|
|
@ -5,6 +5,8 @@ import (
|
|||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
|
||||
"github.com/hashicorp/go-multierror"
|
||||
)
|
||||
|
||||
|
|
@ -15,7 +17,7 @@ type AcyclicGraph struct {
|
|||
}
|
||||
|
||||
// WalkFunc is the callback used for walking the graph.
|
||||
type WalkFunc func(Vertex) error
|
||||
type WalkFunc func(Vertex) tfdiags.Diagnostics
|
||||
|
||||
// DepthWalkFunc is a walk function that also receives the current depth of the
|
||||
// walk as an argument
|
||||
|
|
@ -161,9 +163,9 @@ func (g *AcyclicGraph) Cycles() [][]Vertex {
|
|||
}
|
||||
|
||||
// Walk walks the graph, calling your callback as each node is visited.
|
||||
// This will walk nodes in parallel if it can. Because the walk is done
|
||||
// in parallel, the error returned will be a multierror.
|
||||
func (g *AcyclicGraph) Walk(cb WalkFunc) error {
|
||||
// This will walk nodes in parallel if it can. The resulting diagnostics
|
||||
// contains problems from all graphs visited, in no particular order.
|
||||
func (g *AcyclicGraph) Walk(cb WalkFunc) tfdiags.Diagnostics {
|
||||
defer g.debug.BeginOperation(typeWalk, "").End("")
|
||||
|
||||
w := &Walker{Callback: cb, Reverse: true}
|
||||
|
|
|
|||
94
vendor/github.com/hashicorp/terraform/dag/walk.go
generated
vendored
94
vendor/github.com/hashicorp/terraform/dag/walk.go
generated
vendored
|
|
@ -2,12 +2,11 @@ package dag
|
|||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/hashicorp/go-multierror"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// Walker is used to walk every vertex of a graph in parallel.
|
||||
|
|
@ -54,10 +53,15 @@ type Walker struct {
|
|||
// if new vertices are added.
|
||||
wait sync.WaitGroup
|
||||
|
||||
// errMap contains the errors recorded so far for execution. Reading
|
||||
// and writing should hold errLock.
|
||||
errMap map[Vertex]error
|
||||
errLock sync.Mutex
|
||||
// diagsMap contains the diagnostics recorded so far for execution,
|
||||
// and upstreamFailed contains all the vertices whose problems were
|
||||
// caused by upstream failures, and thus whose diagnostics should be
|
||||
// excluded from the final set.
|
||||
//
|
||||
// Readers and writers of either map must hold diagsLock.
|
||||
diagsMap map[Vertex]tfdiags.Diagnostics
|
||||
upstreamFailed map[Vertex]struct{}
|
||||
diagsLock sync.Mutex
|
||||
}
|
||||
|
||||
type walkerVertex struct {
|
||||
|
|
@ -98,31 +102,30 @@ type walkerVertex struct {
|
|||
// user-returned error.
|
||||
var errWalkUpstream = errors.New("upstream dependency failed")
|
||||
|
||||
// Wait waits for the completion of the walk and returns any errors (
|
||||
// in the form of a multierror) that occurred. Update should be called
|
||||
// to populate the walk with vertices and edges prior to calling this.
|
||||
// Wait waits for the completion of the walk and returns diagnostics describing
|
||||
// any problems that arose. Update should be called to populate the walk with
|
||||
// vertices and edges prior to calling this.
|
||||
//
|
||||
// Wait will return as soon as all currently known vertices are complete.
|
||||
// If you plan on calling Update with more vertices in the future, you
|
||||
// should not call Wait until after this is done.
|
||||
func (w *Walker) Wait() error {
|
||||
func (w *Walker) Wait() tfdiags.Diagnostics {
|
||||
// Wait for completion
|
||||
w.wait.Wait()
|
||||
|
||||
// Grab the error lock
|
||||
w.errLock.Lock()
|
||||
defer w.errLock.Unlock()
|
||||
|
||||
// Build the error
|
||||
var result error
|
||||
for v, err := range w.errMap {
|
||||
if err != nil && err != errWalkUpstream {
|
||||
result = multierror.Append(result, fmt.Errorf(
|
||||
"%s: %s", VertexName(v), err))
|
||||
var diags tfdiags.Diagnostics
|
||||
w.diagsLock.Lock()
|
||||
for v, vDiags := range w.diagsMap {
|
||||
if _, upstream := w.upstreamFailed[v]; upstream {
|
||||
// Ignore diagnostics for nodes that had failed upstreams, since
|
||||
// the downstream diagnostics are likely to be redundant.
|
||||
continue
|
||||
}
|
||||
diags = diags.Append(vDiags)
|
||||
}
|
||||
w.diagsLock.Unlock()
|
||||
|
||||
return result
|
||||
return diags
|
||||
}
|
||||
|
||||
// Update updates the currently executing walk with the given graph.
|
||||
|
|
@ -136,6 +139,7 @@ func (w *Walker) Wait() error {
|
|||
// Multiple Updates can be called in parallel. Update can be called at any
|
||||
// time during a walk.
|
||||
func (w *Walker) Update(g *AcyclicGraph) {
|
||||
log.Print("[TRACE] dag/walk: updating graph")
|
||||
var v, e *Set
|
||||
if g != nil {
|
||||
v, e = g.vertices, g.edges
|
||||
|
|
@ -381,25 +385,34 @@ func (w *Walker) walkVertex(v Vertex, info *walkerVertex) {
|
|||
}
|
||||
|
||||
// Run our callback or note that our upstream failed
|
||||
var err error
|
||||
var diags tfdiags.Diagnostics
|
||||
var upstreamFailed bool
|
||||
if depsSuccess {
|
||||
log.Printf("[TRACE] dag/walk: walking %q", VertexName(v))
|
||||
err = w.Callback(v)
|
||||
log.Printf("[TRACE] dag/walk: visiting %q", VertexName(v))
|
||||
diags = w.Callback(v)
|
||||
} else {
|
||||
log.Printf("[TRACE] dag/walk: upstream errored, not walking %q", VertexName(v))
|
||||
err = errWalkUpstream
|
||||
log.Printf("[TRACE] dag/walk: upstream of %q errored, so skipping", VertexName(v))
|
||||
// This won't be displayed to the user because we'll set upstreamFailed,
|
||||
// but we need to ensure there's at least one error in here so that
|
||||
// the failures will cascade downstream.
|
||||
diags = diags.Append(errors.New("upstream dependencies failed"))
|
||||
upstreamFailed = true
|
||||
}
|
||||
|
||||
// Record the error
|
||||
if err != nil {
|
||||
w.errLock.Lock()
|
||||
defer w.errLock.Unlock()
|
||||
|
||||
if w.errMap == nil {
|
||||
w.errMap = make(map[Vertex]error)
|
||||
}
|
||||
w.errMap[v] = err
|
||||
// Record the result (we must do this after execution because we mustn't
|
||||
// hold diagsLock while visiting a vertex.)
|
||||
w.diagsLock.Lock()
|
||||
if w.diagsMap == nil {
|
||||
w.diagsMap = make(map[Vertex]tfdiags.Diagnostics)
|
||||
}
|
||||
w.diagsMap[v] = diags
|
||||
if w.upstreamFailed == nil {
|
||||
w.upstreamFailed = make(map[Vertex]struct{})
|
||||
}
|
||||
if upstreamFailed {
|
||||
w.upstreamFailed[v] = struct{}{}
|
||||
}
|
||||
w.diagsLock.Unlock()
|
||||
}
|
||||
|
||||
func (w *Walker) waitDeps(
|
||||
|
|
@ -407,6 +420,7 @@ func (w *Walker) waitDeps(
|
|||
deps map[Vertex]<-chan struct{},
|
||||
doneCh chan<- bool,
|
||||
cancelCh <-chan struct{}) {
|
||||
|
||||
// For each dependency given to us, wait for it to complete
|
||||
for dep, depCh := range deps {
|
||||
DepSatisfied:
|
||||
|
|
@ -423,17 +437,17 @@ func (w *Walker) waitDeps(
|
|||
return
|
||||
|
||||
case <-time.After(time.Second * 5):
|
||||
log.Printf("[TRACE] dag/walk: vertex %q, waiting for: %q",
|
||||
log.Printf("[TRACE] dag/walk: vertex %q is waiting for %q",
|
||||
VertexName(v), VertexName(dep))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dependencies satisfied! We need to check if any errored
|
||||
w.errLock.Lock()
|
||||
defer w.errLock.Unlock()
|
||||
for dep, _ := range deps {
|
||||
if w.errMap[dep] != nil {
|
||||
w.diagsLock.Lock()
|
||||
defer w.diagsLock.Unlock()
|
||||
for dep := range deps {
|
||||
if w.diagsMap[dep].HasErrors() {
|
||||
// One of our dependencies failed, so return false
|
||||
doneCh <- false
|
||||
return
|
||||
|
|
|
|||
24
vendor/github.com/hashicorp/terraform/helper/didyoumean/name_suggestion.go
generated
vendored
Normal file
24
vendor/github.com/hashicorp/terraform/helper/didyoumean/name_suggestion.go
generated
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
package didyoumean
|
||||
|
||||
import (
|
||||
"github.com/agext/levenshtein"
|
||||
)
|
||||
|
||||
// NameSuggestion tries to find a name from the given slice of suggested names
|
||||
// that is close to the given name and returns it if found. If no suggestion
|
||||
// is close enough, returns the empty string.
|
||||
//
|
||||
// The suggestions are tried in order, so earlier suggestions take precedence
|
||||
// if the given string is similar to two or more suggestions.
|
||||
//
|
||||
// This function is intended to be used with a relatively-small number of
|
||||
// suggestions. It's not optimized for hundreds or thousands of them.
|
||||
func NameSuggestion(given string, suggestions []string) string {
|
||||
for _, suggestion := range suggestions {
|
||||
dist := levenshtein.Distance(given, suggestion, nil)
|
||||
if dist < 3 { // threshold determined experimentally
|
||||
return suggestion
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
6
vendor/github.com/hashicorp/terraform/helper/plugin/doc.go
generated
vendored
Normal file
6
vendor/github.com/hashicorp/terraform/helper/plugin/doc.go
generated
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
// Package plugin contains types and functions to help Terraform plugins
|
||||
// implement the plugin rpc interface.
|
||||
// The primary Provider type will be responsible for converting from the grpc
|
||||
// wire protocol to the types and methods known to the provider
|
||||
// implementations.
|
||||
package plugin
|
||||
1045
vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go
generated
vendored
Normal file
1045
vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
147
vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provisioner.go
generated
vendored
Normal file
147
vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provisioner.go
generated
vendored
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
package plugin
|
||||
|
||||
import (
|
||||
"log"
|
||||
|
||||
"github.com/hashicorp/terraform/helper/schema"
|
||||
proto "github.com/hashicorp/terraform/internal/tfplugin5"
|
||||
"github.com/hashicorp/terraform/plugin/convert"
|
||||
"github.com/hashicorp/terraform/terraform"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
ctyconvert "github.com/zclconf/go-cty/cty/convert"
|
||||
"github.com/zclconf/go-cty/cty/msgpack"
|
||||
context "golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// NewGRPCProvisionerServerShim wraps a terraform.ResourceProvisioner in a
|
||||
// proto.ProvisionerServer implementation. If the provided provisioner is not a
|
||||
// *schema.Provisioner, this will return nil,
|
||||
func NewGRPCProvisionerServerShim(p terraform.ResourceProvisioner) *GRPCProvisionerServer {
|
||||
sp, ok := p.(*schema.Provisioner)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return &GRPCProvisionerServer{
|
||||
provisioner: sp,
|
||||
}
|
||||
}
|
||||
|
||||
type GRPCProvisionerServer struct {
|
||||
provisioner *schema.Provisioner
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) GetSchema(_ context.Context, req *proto.GetProvisionerSchema_Request) (*proto.GetProvisionerSchema_Response, error) {
|
||||
resp := &proto.GetProvisionerSchema_Response{}
|
||||
|
||||
resp.Provisioner = &proto.Schema{
|
||||
Block: convert.ConfigSchemaToProto(schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()),
|
||||
}
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) ValidateProvisionerConfig(_ context.Context, req *proto.ValidateProvisionerConfig_Request) (*proto.ValidateProvisionerConfig_Response, error) {
|
||||
resp := &proto.ValidateProvisionerConfig_Response{}
|
||||
|
||||
cfgSchema := schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()
|
||||
|
||||
configVal, err := msgpack.Unmarshal(req.Config.Msgpack, cfgSchema.ImpliedType())
|
||||
if err != nil {
|
||||
resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
config := terraform.NewResourceConfigShimmed(configVal, cfgSchema)
|
||||
|
||||
warns, errs := s.provisioner.Validate(config)
|
||||
resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, convert.WarnsAndErrsToProto(warns, errs))
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// stringMapFromValue converts a cty.Value to a map[stirng]string.
|
||||
// This will panic if the val is not a cty.Map(cty.String).
|
||||
func stringMapFromValue(val cty.Value) map[string]string {
|
||||
m := map[string]string{}
|
||||
if val.IsNull() || !val.IsKnown() {
|
||||
return m
|
||||
}
|
||||
|
||||
for it := val.ElementIterator(); it.Next(); {
|
||||
ak, av := it.Element()
|
||||
name := ak.AsString()
|
||||
|
||||
if !av.IsKnown() || av.IsNull() {
|
||||
continue
|
||||
}
|
||||
|
||||
av, _ = ctyconvert.Convert(av, cty.String)
|
||||
m[name] = av.AsString()
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// uiOutput implements the terraform.UIOutput interface to adapt the grpc
|
||||
// stream to the legacy Provisioner.Apply method.
|
||||
type uiOutput struct {
|
||||
srv proto.Provisioner_ProvisionResourceServer
|
||||
}
|
||||
|
||||
func (o uiOutput) Output(s string) {
|
||||
err := o.srv.Send(&proto.ProvisionResource_Response{
|
||||
Output: s,
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("[ERROR] %s", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) ProvisionResource(req *proto.ProvisionResource_Request, srv proto.Provisioner_ProvisionResourceServer) error {
|
||||
// We send back a diagnostics over the stream if there was a
|
||||
// provisioner-side problem.
|
||||
srvResp := &proto.ProvisionResource_Response{}
|
||||
|
||||
cfgSchema := schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()
|
||||
cfgVal, err := msgpack.Unmarshal(req.Config.Msgpack, cfgSchema.ImpliedType())
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
return nil
|
||||
}
|
||||
resourceConfig := terraform.NewResourceConfigShimmed(cfgVal, cfgSchema)
|
||||
|
||||
connVal, err := msgpack.Unmarshal(req.Connection.Msgpack, cty.Map(cty.String))
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
return nil
|
||||
}
|
||||
|
||||
conn := stringMapFromValue(connVal)
|
||||
|
||||
instanceState := &terraform.InstanceState{
|
||||
Ephemeral: terraform.EphemeralState{
|
||||
ConnInfo: conn,
|
||||
},
|
||||
Meta: make(map[string]interface{}),
|
||||
}
|
||||
|
||||
err = s.provisioner.Apply(uiOutput{srv}, instanceState, resourceConfig)
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) Stop(_ context.Context, req *proto.Stop_Request) (*proto.Stop_Response, error) {
|
||||
resp := &proto.Stop_Response{}
|
||||
|
||||
err := s.provisioner.Stop()
|
||||
if err != nil {
|
||||
resp.Error = err.Error()
|
||||
}
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
43
vendor/github.com/hashicorp/terraform/helper/resource/grpc_test_provider.go
generated
vendored
Normal file
43
vendor/github.com/hashicorp/terraform/helper/resource/grpc_test_provider.go
generated
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
package resource
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"github.com/hashicorp/terraform/helper/plugin"
|
||||
proto "github.com/hashicorp/terraform/internal/tfplugin5"
|
||||
tfplugin "github.com/hashicorp/terraform/plugin"
|
||||
"github.com/hashicorp/terraform/providers"
|
||||
"github.com/hashicorp/terraform/terraform"
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/test/bufconn"
|
||||
)
|
||||
|
||||
// GRPCTestProvider takes a legacy ResourceProvider, wraps it in the new GRPC
|
||||
// shim and starts it in a grpc server using an inmem connection. It returns a
|
||||
// GRPCClient for this new server to test the shimmed resource provider.
|
||||
func GRPCTestProvider(rp terraform.ResourceProvider) providers.Interface {
|
||||
listener := bufconn.Listen(256 * 1024)
|
||||
grpcServer := grpc.NewServer()
|
||||
|
||||
p := plugin.NewGRPCProviderServerShim(rp)
|
||||
proto.RegisterProviderServer(grpcServer, p)
|
||||
|
||||
go grpcServer.Serve(listener)
|
||||
|
||||
conn, err := grpc.Dial("", grpc.WithDialer(func(string, time.Duration) (net.Conn, error) {
|
||||
return listener.Dial()
|
||||
}), grpc.WithInsecure())
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
var pp tfplugin.GRPCProviderPlugin
|
||||
client, _ := pp.GRPCClient(context.Background(), nil, conn)
|
||||
|
||||
grpcClient := client.(*tfplugin.GRPCProvider)
|
||||
grpcClient.TestListener = listener
|
||||
|
||||
return grpcClient
|
||||
}
|
||||
145
vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go
generated
vendored
Normal file
145
vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go
generated
vendored
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
package resource
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
|
||||
"github.com/hashicorp/terraform/config/hcl2shim"
|
||||
|
||||
"github.com/hashicorp/terraform/states"
|
||||
"github.com/hashicorp/terraform/terraform"
|
||||
)
|
||||
|
||||
func mustShimNewState(newState *states.State, schemas *terraform.Schemas) *terraform.State {
|
||||
s, err := shimNewState(newState, schemas)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// shimState takes a new *states.State and reverts it to a legacy state for the provider ACC tests
|
||||
func shimNewState(newState *states.State, schemas *terraform.Schemas) (*terraform.State, error) {
|
||||
state := terraform.NewState()
|
||||
|
||||
// in the odd case of a nil state, let the helper packages handle it
|
||||
if newState == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
for _, newMod := range newState.Modules {
|
||||
mod := state.AddModule(newMod.Addr)
|
||||
|
||||
for name, out := range newMod.OutputValues {
|
||||
outputType := ""
|
||||
val := hcl2shim.ConfigValueFromHCL2(out.Value)
|
||||
ty := out.Value.Type()
|
||||
switch {
|
||||
case ty == cty.String:
|
||||
outputType = "string"
|
||||
case ty.IsTupleType() || ty.IsListType():
|
||||
outputType = "list"
|
||||
case ty.IsMapType():
|
||||
outputType = "map"
|
||||
}
|
||||
|
||||
mod.Outputs[name] = &terraform.OutputState{
|
||||
Type: outputType,
|
||||
Value: val,
|
||||
Sensitive: out.Sensitive,
|
||||
}
|
||||
}
|
||||
|
||||
for _, res := range newMod.Resources {
|
||||
resType := res.Addr.Type
|
||||
providerType := res.ProviderConfig.ProviderConfig.Type
|
||||
|
||||
providerSchema := schemas.Providers[providerType]
|
||||
if providerSchema == nil {
|
||||
return nil, fmt.Errorf("missing schema for %q", providerType)
|
||||
}
|
||||
|
||||
var resSchema *configschema.Block
|
||||
switch res.Addr.Mode {
|
||||
case addrs.ManagedResourceMode:
|
||||
resSchema = providerSchema.ResourceTypes[resType]
|
||||
case addrs.DataResourceMode:
|
||||
resSchema = providerSchema.DataSources[resType]
|
||||
}
|
||||
|
||||
if resSchema == nil {
|
||||
return nil, fmt.Errorf("missing resource schema for %q in %q", resType, providerType)
|
||||
}
|
||||
|
||||
for key, i := range res.Instances {
|
||||
flatmap, err := shimmedAttributes(i.Current, resSchema.ImpliedType())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error decoding state for %q: %s", resType, err)
|
||||
}
|
||||
|
||||
resState := &terraform.ResourceState{
|
||||
Type: resType,
|
||||
Primary: &terraform.InstanceState{
|
||||
ID: flatmap["id"],
|
||||
Attributes: flatmap,
|
||||
Tainted: i.Current.Status == states.ObjectTainted,
|
||||
},
|
||||
}
|
||||
|
||||
for _, dep := range i.Current.Dependencies {
|
||||
resState.Dependencies = append(resState.Dependencies, dep.String())
|
||||
}
|
||||
|
||||
// convert the indexes to the old style flapmap indexes
|
||||
idx := ""
|
||||
switch key.(type) {
|
||||
case addrs.IntKey:
|
||||
// don't add numeric index values to resources with a count of 0
|
||||
if len(res.Instances) > 1 {
|
||||
idx = fmt.Sprintf(".%d", key)
|
||||
}
|
||||
case addrs.StringKey:
|
||||
idx = "." + key.String()
|
||||
}
|
||||
|
||||
mod.Resources[res.Addr.String()+idx] = resState
|
||||
|
||||
// add any deposed instances
|
||||
for _, dep := range i.Deposed {
|
||||
flatmap, err := shimmedAttributes(dep, resSchema.ImpliedType())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error decoding deposed state for %q: %s", resType, err)
|
||||
}
|
||||
|
||||
deposed := &terraform.InstanceState{
|
||||
ID: flatmap["id"],
|
||||
Attributes: flatmap,
|
||||
Tainted: dep.Status == states.ObjectTainted,
|
||||
}
|
||||
|
||||
resState.Deposed = append(resState.Deposed, deposed)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return state, nil
|
||||
}
|
||||
|
||||
func shimmedAttributes(instance *states.ResourceInstanceObjectSrc, ty cty.Type) (map[string]string, error) {
|
||||
flatmap := instance.AttrsFlat
|
||||
|
||||
// if we have json attrs, they need to be decoded
|
||||
if flatmap == nil {
|
||||
rio, err := instance.Decode(ty)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
flatmap = hcl2shim.FlatmapValueFromHCL2(rio.Value)
|
||||
}
|
||||
return flatmap, nil
|
||||
}
|
||||
169
vendor/github.com/hashicorp/terraform/helper/resource/testing.go
generated
vendored
169
vendor/github.com/hashicorp/terraform/helper/resource/testing.go
generated
vendored
|
|
@ -18,8 +18,13 @@ import (
|
|||
"github.com/hashicorp/errwrap"
|
||||
"github.com/hashicorp/go-multierror"
|
||||
"github.com/hashicorp/logutils"
|
||||
"github.com/hashicorp/terraform/config/module"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
"github.com/hashicorp/terraform/configs"
|
||||
"github.com/hashicorp/terraform/configs/configload"
|
||||
"github.com/hashicorp/terraform/helper/logging"
|
||||
"github.com/hashicorp/terraform/providers"
|
||||
"github.com/hashicorp/terraform/states"
|
||||
"github.com/hashicorp/terraform/terraform"
|
||||
)
|
||||
|
||||
|
|
@ -471,6 +476,7 @@ func Test(t TestT, c TestCase) {
|
|||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
opts := terraform.ContextOpts{ProviderResolver: providerResolver}
|
||||
|
||||
// A single state variable to track the lifecycle, starting with no state
|
||||
|
|
@ -625,7 +631,7 @@ func testProviderConfig(c TestCase) string {
|
|||
// test, while only calling the factory function once.
|
||||
// Any errors are stored so that they can be returned by the factory in
|
||||
// terraform to match non-test behavior.
|
||||
func testProviderResolver(c TestCase) (terraform.ResourceProviderResolver, error) {
|
||||
func testProviderResolver(c TestCase) (providers.Resolver, error) {
|
||||
ctxProviders := c.ProviderFactories
|
||||
if ctxProviders == nil {
|
||||
ctxProviders = make(map[string]terraform.ResourceProviderFactory)
|
||||
|
|
@ -636,23 +642,51 @@ func testProviderResolver(c TestCase) (terraform.ResourceProviderResolver, error
|
|||
ctxProviders[k] = terraform.ResourceProviderFactoryFixed(p)
|
||||
}
|
||||
|
||||
// reset the providers if needed
|
||||
// wrap the old provider factories in the test grpc server so they can be
|
||||
// called from terraform.
|
||||
newProviders := make(map[string]providers.Factory)
|
||||
|
||||
for k, pf := range ctxProviders {
|
||||
// we can ignore any errors here, if we don't have a provider to reset
|
||||
// the error will be handled later
|
||||
p, err := pf()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if p, ok := p.(TestProvider); ok {
|
||||
err := p.TestReset()
|
||||
newProviders[k] = func() (providers.Interface, error) {
|
||||
p, err := pf()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("[ERROR] failed to reset provider %q: %s", k, err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// The provider is wrapped in a GRPCTestProvider so that it can be
|
||||
// passed back to terraform core as a providers.Interface, rather
|
||||
// than the legacy ResourceProvider.
|
||||
return GRPCTestProvider(p), nil
|
||||
}
|
||||
}
|
||||
|
||||
return terraform.ResourceProviderResolverFixed(ctxProviders), nil
|
||||
return providers.ResolverFixed(newProviders), nil
|
||||
}
|
||||
|
||||
// testProviderFactores returns a fixed and reset factories for creating a resolver
|
||||
func testProviderFactories(c TestCase) (map[string]providers.Factory, error) {
|
||||
factories := c.ProviderFactories
|
||||
if factories == nil {
|
||||
factories = make(map[string]terraform.ResourceProviderFactory)
|
||||
}
|
||||
|
||||
// add any fixed providers
|
||||
for k, p := range c.Providers {
|
||||
factories[k] = terraform.ResourceProviderFactoryFixed(p)
|
||||
}
|
||||
|
||||
// wrap the providers to be GRPC mocks rather than legacy terraform.ResourceProvider
|
||||
newFactories := make(map[string]providers.Factory)
|
||||
for k, pf := range factories {
|
||||
newFactories[k] = func() (providers.Interface, error) {
|
||||
p, err := pf()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return GRPCTestProvider(p), nil
|
||||
}
|
||||
}
|
||||
return newFactories, nil
|
||||
}
|
||||
|
||||
// UnitTest is a helper to force the acceptance testing harness to run in the
|
||||
|
|
@ -670,33 +704,40 @@ func testIDOnlyRefresh(c TestCase, opts terraform.ContextOpts, step TestStep, r
|
|||
return nil
|
||||
}
|
||||
|
||||
name := fmt.Sprintf("%s.foo", r.Type)
|
||||
addr := addrs.Resource{
|
||||
Mode: addrs.ManagedResourceMode,
|
||||
Type: r.Type,
|
||||
Name: "foo",
|
||||
}.Instance(addrs.NoKey)
|
||||
absAddr := addr.Absolute(addrs.RootModuleInstance)
|
||||
|
||||
// Build the state. The state is just the resource with an ID. There
|
||||
// are no attributes. We only set what is needed to perform a refresh.
|
||||
state := terraform.NewState()
|
||||
state.RootModule().Resources[name] = &terraform.ResourceState{
|
||||
Type: r.Type,
|
||||
Primary: &terraform.InstanceState{
|
||||
ID: r.Primary.ID,
|
||||
state := states.NewState()
|
||||
state.RootModule().SetResourceInstanceCurrent(
|
||||
addr,
|
||||
&states.ResourceInstanceObjectSrc{
|
||||
AttrsFlat: r.Primary.Attributes,
|
||||
Status: states.ObjectReady,
|
||||
},
|
||||
}
|
||||
addrs.ProviderConfig{Type: "placeholder"}.Absolute(addrs.RootModuleInstance),
|
||||
)
|
||||
|
||||
// Create the config module. We use the full config because Refresh
|
||||
// doesn't have access to it and we may need things like provider
|
||||
// configurations. The initial implementation of id-only checks used
|
||||
// an empty config module, but that caused the aforementioned problems.
|
||||
mod, err := testModule(opts, step)
|
||||
cfg, err := testConfig(opts, step)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Initialize the context
|
||||
opts.Module = mod
|
||||
opts.Config = cfg
|
||||
opts.State = state
|
||||
ctx, err := terraform.NewContext(&opts)
|
||||
if err != nil {
|
||||
return err
|
||||
ctx, ctxDiags := terraform.NewContext(&opts)
|
||||
if ctxDiags.HasErrors() {
|
||||
return ctxDiags.Err()
|
||||
}
|
||||
if diags := ctx.Validate(); len(diags) > 0 {
|
||||
if diags.HasErrors() {
|
||||
|
|
@ -707,20 +748,20 @@ func testIDOnlyRefresh(c TestCase, opts terraform.ContextOpts, step TestStep, r
|
|||
}
|
||||
|
||||
// Refresh!
|
||||
state, err = ctx.Refresh()
|
||||
if err != nil {
|
||||
return fmt.Errorf("Error refreshing: %s", err)
|
||||
state, refreshDiags := ctx.Refresh()
|
||||
if refreshDiags.HasErrors() {
|
||||
return refreshDiags.Err()
|
||||
}
|
||||
|
||||
// Verify attribute equivalence.
|
||||
actualR := state.RootModule().Resources[name]
|
||||
actualR := state.ResourceInstance(absAddr)
|
||||
if actualR == nil {
|
||||
return fmt.Errorf("Resource gone!")
|
||||
}
|
||||
if actualR.Primary == nil {
|
||||
if actualR.Current == nil {
|
||||
return fmt.Errorf("Resource has no primary instance")
|
||||
}
|
||||
actual := actualR.Primary.Attributes
|
||||
actual := actualR.Current.AttrsFlat
|
||||
expected := r.Primary.Attributes
|
||||
// Remove fields we're ignoring
|
||||
for _, v := range c.IDRefreshIgnore {
|
||||
|
|
@ -756,15 +797,14 @@ func testIDOnlyRefresh(c TestCase, opts terraform.ContextOpts, step TestStep, r
|
|||
return nil
|
||||
}
|
||||
|
||||
func testModule(opts terraform.ContextOpts, step TestStep) (*module.Tree, error) {
|
||||
func testConfig(opts terraform.ContextOpts, step TestStep) (*configs.Config, error) {
|
||||
if step.PreConfig != nil {
|
||||
step.PreConfig()
|
||||
}
|
||||
|
||||
cfgPath, err := ioutil.TempDir("", "tf-test")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf(
|
||||
"Error creating temporary directory for config: %s", err)
|
||||
return nil, fmt.Errorf("Error creating temporary directory for config: %s", err)
|
||||
}
|
||||
|
||||
if step.PreventDiskCleanup {
|
||||
|
|
@ -773,38 +813,37 @@ func testModule(opts terraform.ContextOpts, step TestStep) (*module.Tree, error)
|
|||
defer os.RemoveAll(cfgPath)
|
||||
}
|
||||
|
||||
// Write the configuration
|
||||
cfgF, err := os.Create(filepath.Join(cfgPath, "main.tf"))
|
||||
// Write the main configuration file
|
||||
err = ioutil.WriteFile(filepath.Join(cfgPath, "main.tf"), []byte(step.Config), os.ModePerm)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf(
|
||||
"Error creating temporary file for config: %s", err)
|
||||
return nil, fmt.Errorf("Error creating temporary file for config: %s", err)
|
||||
}
|
||||
|
||||
_, err = io.Copy(cfgF, strings.NewReader(step.Config))
|
||||
cfgF.Close()
|
||||
// Create directory for our child modules, if any.
|
||||
modulesDir := filepath.Join(cfgPath, ".modules")
|
||||
err = os.Mkdir(modulesDir, os.ModePerm)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf(
|
||||
"Error creating temporary file for config: %s", err)
|
||||
return nil, fmt.Errorf("Error creating child modules directory: %s", err)
|
||||
}
|
||||
|
||||
// Parse the configuration
|
||||
mod, err := module.NewTreeModule("", cfgPath)
|
||||
loader, err := configload.NewLoader(&configload.Config{
|
||||
ModulesDir: modulesDir,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf(
|
||||
"Error loading configuration: %s", err)
|
||||
return nil, fmt.Errorf("failed to create config loader: %s", err)
|
||||
}
|
||||
|
||||
// Load the modules
|
||||
modStorage := &module.Storage{
|
||||
StorageDir: filepath.Join(cfgPath, ".tfmodules"),
|
||||
Mode: module.GetModeGet,
|
||||
}
|
||||
err = mod.Load(modStorage)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error downloading modules: %s", err)
|
||||
installDiags := loader.InstallModules(cfgPath, true, configload.InstallHooksImpl{})
|
||||
if installDiags.HasErrors() {
|
||||
return nil, installDiags
|
||||
}
|
||||
|
||||
return mod, nil
|
||||
config, configDiags := loader.LoadConfig(cfgPath)
|
||||
if configDiags.HasErrors() {
|
||||
return nil, configDiags
|
||||
}
|
||||
|
||||
return config, nil
|
||||
}
|
||||
|
||||
func testResource(c TestStep, state *terraform.State) (*terraform.ResourceState, error) {
|
||||
|
|
@ -881,8 +920,9 @@ func TestCheckResourceAttrSet(name, key string) TestCheckFunc {
|
|||
// TestCheckModuleResourceAttrSet - as per TestCheckResourceAttrSet but with
|
||||
// support for non-root modules
|
||||
func TestCheckModuleResourceAttrSet(mp []string, name string, key string) TestCheckFunc {
|
||||
mpt := addrs.Module(mp).UnkeyedInstanceShim()
|
||||
return func(s *terraform.State) error {
|
||||
is, err := modulePathPrimaryInstanceState(s, mp, name)
|
||||
is, err := modulePathPrimaryInstanceState(s, mpt, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -915,8 +955,9 @@ func TestCheckResourceAttr(name, key, value string) TestCheckFunc {
|
|||
// TestCheckModuleResourceAttr - as per TestCheckResourceAttr but with
|
||||
// support for non-root modules
|
||||
func TestCheckModuleResourceAttr(mp []string, name string, key string, value string) TestCheckFunc {
|
||||
mpt := addrs.Module(mp).UnkeyedInstanceShim()
|
||||
return func(s *terraform.State) error {
|
||||
is, err := modulePathPrimaryInstanceState(s, mp, name)
|
||||
is, err := modulePathPrimaryInstanceState(s, mpt, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -957,8 +998,9 @@ func TestCheckNoResourceAttr(name, key string) TestCheckFunc {
|
|||
// TestCheckModuleNoResourceAttr - as per TestCheckNoResourceAttr but with
|
||||
// support for non-root modules
|
||||
func TestCheckModuleNoResourceAttr(mp []string, name string, key string) TestCheckFunc {
|
||||
mpt := addrs.Module(mp).UnkeyedInstanceShim()
|
||||
return func(s *terraform.State) error {
|
||||
is, err := modulePathPrimaryInstanceState(s, mp, name)
|
||||
is, err := modulePathPrimaryInstanceState(s, mpt, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -991,8 +1033,9 @@ func TestMatchResourceAttr(name, key string, r *regexp.Regexp) TestCheckFunc {
|
|||
// TestModuleMatchResourceAttr - as per TestMatchResourceAttr but with
|
||||
// support for non-root modules
|
||||
func TestModuleMatchResourceAttr(mp []string, name string, key string, r *regexp.Regexp) TestCheckFunc {
|
||||
mpt := addrs.Module(mp).UnkeyedInstanceShim()
|
||||
return func(s *terraform.State) error {
|
||||
is, err := modulePathPrimaryInstanceState(s, mp, name)
|
||||
is, err := modulePathPrimaryInstanceState(s, mpt, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -1052,13 +1095,15 @@ func TestCheckResourceAttrPair(nameFirst, keyFirst, nameSecond, keySecond string
|
|||
// TestCheckModuleResourceAttrPair - as per TestCheckResourceAttrPair but with
|
||||
// support for non-root modules
|
||||
func TestCheckModuleResourceAttrPair(mpFirst []string, nameFirst string, keyFirst string, mpSecond []string, nameSecond string, keySecond string) TestCheckFunc {
|
||||
mptFirst := addrs.Module(mpFirst).UnkeyedInstanceShim()
|
||||
mptSecond := addrs.Module(mpSecond).UnkeyedInstanceShim()
|
||||
return func(s *terraform.State) error {
|
||||
isFirst, err := modulePathPrimaryInstanceState(s, mpFirst, nameFirst)
|
||||
isFirst, err := modulePathPrimaryInstanceState(s, mptFirst, nameFirst)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
isSecond, err := modulePathPrimaryInstanceState(s, mpSecond, nameSecond)
|
||||
isSecond, err := modulePathPrimaryInstanceState(s, mptSecond, nameSecond)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -1163,7 +1208,7 @@ func modulePrimaryInstanceState(s *terraform.State, ms *terraform.ModuleState, n
|
|||
|
||||
// modulePathPrimaryInstanceState returns the primary instance state for the
|
||||
// given resource name in a given module path.
|
||||
func modulePathPrimaryInstanceState(s *terraform.State, mp []string, name string) (*terraform.InstanceState, error) {
|
||||
func modulePathPrimaryInstanceState(s *terraform.State, mp addrs.ModuleInstance, name string) (*terraform.InstanceState, error) {
|
||||
ms := s.ModuleByPath(mp)
|
||||
if ms == nil {
|
||||
return nil, fmt.Errorf("No module found at: %s", mp)
|
||||
|
|
|
|||
318
vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go
generated
vendored
318
vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go
generated
vendored
|
|
@ -1,13 +1,23 @@
|
|||
package resource
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/hashicorp/terraform/addrs"
|
||||
"github.com/hashicorp/terraform/config"
|
||||
"github.com/hashicorp/terraform/config/hcl2shim"
|
||||
"github.com/hashicorp/terraform/states"
|
||||
|
||||
"github.com/hashicorp/errwrap"
|
||||
"github.com/hashicorp/terraform/plans"
|
||||
"github.com/hashicorp/terraform/terraform"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
// testStepConfig runs a config-mode test step
|
||||
|
|
@ -18,69 +28,82 @@ func testStepConfig(
|
|||
return testStep(opts, state, step)
|
||||
}
|
||||
|
||||
func testStep(
|
||||
opts terraform.ContextOpts,
|
||||
state *terraform.State,
|
||||
step TestStep) (*terraform.State, error) {
|
||||
// Pre-taint any resources that have been defined in Taint, as long as this
|
||||
// is not a destroy step.
|
||||
func testStep(opts terraform.ContextOpts, state *terraform.State, step TestStep) (*terraform.State, error) {
|
||||
if !step.Destroy {
|
||||
if err := testStepTaint(state, step); err != nil {
|
||||
return state, err
|
||||
}
|
||||
}
|
||||
|
||||
mod, err := testModule(opts, step)
|
||||
cfg, err := testConfig(opts, step)
|
||||
if err != nil {
|
||||
return state, err
|
||||
}
|
||||
|
||||
var stepDiags tfdiags.Diagnostics
|
||||
|
||||
// Build the context
|
||||
opts.Module = mod
|
||||
opts.State = state
|
||||
opts.Destroy = step.Destroy
|
||||
ctx, err := terraform.NewContext(&opts)
|
||||
opts.Config = cfg
|
||||
opts.State, err = terraform.ShimLegacyState(state)
|
||||
if err != nil {
|
||||
return state, fmt.Errorf("Error initializing context: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
if diags := ctx.Validate(); len(diags) > 0 {
|
||||
if diags.HasErrors() {
|
||||
return nil, errwrap.Wrapf("config is invalid: {{err}}", diags.Err())
|
||||
|
||||
opts.Destroy = step.Destroy
|
||||
ctx, stepDiags := terraform.NewContext(&opts)
|
||||
if stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error initializing context: %s", stepDiags.Err())
|
||||
}
|
||||
if stepDiags := ctx.Validate(); len(stepDiags) > 0 {
|
||||
if stepDiags.HasErrors() {
|
||||
return state, errwrap.Wrapf("config is invalid: {{err}}", stepDiags.Err())
|
||||
}
|
||||
|
||||
log.Printf("[WARN] Config warnings:\n%s", diags)
|
||||
log.Printf("[WARN] Config warnings:\n%s", stepDiags)
|
||||
}
|
||||
|
||||
// We will need access to the schemas in order to shim to the old-style
|
||||
// testing API.
|
||||
schemas := ctx.Schemas()
|
||||
|
||||
// Refresh!
|
||||
state, err = ctx.Refresh()
|
||||
newState, stepDiags := ctx.Refresh()
|
||||
// shim the state first so the test can check the state on errors
|
||||
state, err = shimNewState(newState, schemas)
|
||||
if err != nil {
|
||||
return state, fmt.Errorf(
|
||||
"Error refreshing: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
if stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error refreshing: %s", stepDiags.Err())
|
||||
}
|
||||
|
||||
// If this step is a PlanOnly step, skip over this first Plan and subsequent
|
||||
// Apply, and use the follow up Plan that checks for perpetual diffs
|
||||
if !step.PlanOnly {
|
||||
// Plan!
|
||||
if p, err := ctx.Plan(); err != nil {
|
||||
return state, fmt.Errorf(
|
||||
"Error planning: %s", err)
|
||||
if p, stepDiags := ctx.Plan(); stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error planning: %s", stepDiags.Err())
|
||||
} else {
|
||||
log.Printf("[WARN] Test: Step plan: %s", p)
|
||||
log.Printf("[WARN] Test: Step plan: %s", legacyPlanComparisonString(newState, p.Changes))
|
||||
}
|
||||
|
||||
// We need to keep a copy of the state prior to destroying
|
||||
// such that destroy steps can verify their behaviour in the check
|
||||
// such that destroy steps can verify their behavior in the check
|
||||
// function
|
||||
stateBeforeApplication := state.DeepCopy()
|
||||
|
||||
// Apply!
|
||||
state, err = ctx.Apply()
|
||||
// Apply the diff, creating real resources.
|
||||
newState, stepDiags = ctx.Apply()
|
||||
// shim the state first so the test can check the state on errors
|
||||
state, err = shimNewState(newState, schemas)
|
||||
if err != nil {
|
||||
return state, fmt.Errorf("Error applying: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
if stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error applying: %s", stepDiags.Err())
|
||||
}
|
||||
|
||||
// Check! Excitement!
|
||||
// Run any configured checks
|
||||
if step.Check != nil {
|
||||
if step.Destroy {
|
||||
if err := step.Check(stateBeforeApplication); err != nil {
|
||||
|
|
@ -96,31 +119,35 @@ func testStep(
|
|||
|
||||
// Now, verify that Plan is now empty and we don't have a perpetual diff issue
|
||||
// We do this with TWO plans. One without a refresh.
|
||||
var p *terraform.Plan
|
||||
if p, err = ctx.Plan(); err != nil {
|
||||
return state, fmt.Errorf("Error on follow-up plan: %s", err)
|
||||
var p *plans.Plan
|
||||
if p, stepDiags = ctx.Plan(); stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error on follow-up plan: %s", stepDiags.Err())
|
||||
}
|
||||
if p.Diff != nil && !p.Diff.Empty() {
|
||||
if !p.Changes.Empty() {
|
||||
if step.ExpectNonEmptyPlan {
|
||||
log.Printf("[INFO] Got non-empty plan, as expected:\n\n%s", p)
|
||||
log.Printf("[INFO] Got non-empty plan, as expected:\n\n%s", legacyPlanComparisonString(newState, p.Changes))
|
||||
} else {
|
||||
return state, fmt.Errorf(
|
||||
"After applying this step, the plan was not empty:\n\n%s", p)
|
||||
"After applying this step, the plan was not empty:\n\n%s", legacyPlanComparisonString(newState, p.Changes))
|
||||
}
|
||||
}
|
||||
|
||||
// And another after a Refresh.
|
||||
if !step.Destroy || (step.Destroy && !step.PreventPostDestroyRefresh) {
|
||||
state, err = ctx.Refresh()
|
||||
newState, stepDiags = ctx.Refresh()
|
||||
if stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error on follow-up refresh: %s", stepDiags.Err())
|
||||
}
|
||||
|
||||
state, err = shimNewState(newState, schemas)
|
||||
if err != nil {
|
||||
return state, fmt.Errorf(
|
||||
"Error on follow-up refresh: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if p, err = ctx.Plan(); err != nil {
|
||||
return state, fmt.Errorf("Error on second follow-up plan: %s", err)
|
||||
if p, stepDiags = ctx.Plan(); stepDiags.HasErrors() {
|
||||
return state, fmt.Errorf("Error on second follow-up plan: %s", stepDiags.Err())
|
||||
}
|
||||
empty := p.Diff == nil || p.Diff.Empty()
|
||||
empty := p.Changes.Empty()
|
||||
|
||||
// Data resources are tricky because they legitimately get instantiated
|
||||
// during refresh so that they will be already populated during the
|
||||
|
|
@ -128,35 +155,28 @@ func testStep(
|
|||
// config we'll end up wanting to destroy them again here. This is
|
||||
// acceptable and expected, and we'll treat it as "empty" for the
|
||||
// sake of this testing.
|
||||
if step.Destroy {
|
||||
if step.Destroy && !empty {
|
||||
empty = true
|
||||
|
||||
for _, moduleDiff := range p.Diff.Modules {
|
||||
for k, instanceDiff := range moduleDiff.Resources {
|
||||
if !strings.HasPrefix(k, "data.") {
|
||||
empty = false
|
||||
break
|
||||
}
|
||||
|
||||
if !instanceDiff.Destroy {
|
||||
empty = false
|
||||
}
|
||||
for _, change := range p.Changes.Resources {
|
||||
if change.Addr.Resource.Resource.Mode != addrs.DataResourceMode {
|
||||
empty = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !empty {
|
||||
if step.ExpectNonEmptyPlan {
|
||||
log.Printf("[INFO] Got non-empty plan, as expected:\n\n%s", p)
|
||||
log.Printf("[INFO] Got non-empty plan, as expected:\n\n%s", legacyPlanComparisonString(newState, p.Changes))
|
||||
} else {
|
||||
return state, fmt.Errorf(
|
||||
"After applying this step and refreshing, "+
|
||||
"the plan was not empty:\n\n%s", p)
|
||||
"the plan was not empty:\n\n%s", legacyPlanComparisonString(newState, p.Changes))
|
||||
}
|
||||
}
|
||||
|
||||
// Made it here, but expected a non-empty plan, fail!
|
||||
if step.ExpectNonEmptyPlan && (p.Diff == nil || p.Diff.Empty()) {
|
||||
if step.ExpectNonEmptyPlan && empty {
|
||||
return state, fmt.Errorf("Expected a non-empty plan, but got an empty plan!")
|
||||
}
|
||||
|
||||
|
|
@ -164,6 +184,194 @@ func testStep(
|
|||
return state, nil
|
||||
}
|
||||
|
||||
// legacyPlanComparisonString produces a string representation of the changes
|
||||
// from a plan and a given state togther, as was formerly produced by the
|
||||
// String method of terraform.Plan.
|
||||
//
|
||||
// This is here only for compatibility with existing tests that predate our
|
||||
// new plan and state types, and should not be used in new tests. Instead, use
|
||||
// a library like "cmp" to do a deep equality check and diff on the two
|
||||
// data structures.
|
||||
func legacyPlanComparisonString(state *states.State, changes *plans.Changes) string {
|
||||
return fmt.Sprintf(
|
||||
"DIFF:\n\n%s\n\nSTATE:\n\n%s",
|
||||
legacyDiffComparisonString(changes),
|
||||
state.String(),
|
||||
)
|
||||
}
|
||||
|
||||
// legacyDiffComparisonString produces a string representation of the changes
|
||||
// from a planned changes object, as was formerly produced by the String method
|
||||
// of terraform.Diff.
|
||||
//
|
||||
// This is here only for compatibility with existing tests that predate our
|
||||
// new plan types, and should not be used in new tests. Instead, use a library
|
||||
// like "cmp" to do a deep equality check and diff on the two data structures.
|
||||
func legacyDiffComparisonString(changes *plans.Changes) string {
|
||||
// The old string representation of a plan was grouped by module, but
|
||||
// our new plan structure is not grouped in that way and so we'll need
|
||||
// to preprocess it in order to produce that grouping.
|
||||
type ResourceChanges struct {
|
||||
Current *plans.ResourceInstanceChangeSrc
|
||||
Deposed map[states.DeposedKey]*plans.ResourceInstanceChangeSrc
|
||||
}
|
||||
byModule := map[string]map[string]*ResourceChanges{}
|
||||
resourceKeys := map[string][]string{}
|
||||
var moduleKeys []string
|
||||
for _, rc := range changes.Resources {
|
||||
if rc.Action == plans.NoOp {
|
||||
// We won't mention no-op changes here at all, since the old plan
|
||||
// model we are emulating here didn't have such a concept.
|
||||
continue
|
||||
}
|
||||
moduleKey := rc.Addr.Module.String()
|
||||
if _, exists := byModule[moduleKey]; !exists {
|
||||
moduleKeys = append(moduleKeys, moduleKey)
|
||||
byModule[moduleKey] = make(map[string]*ResourceChanges)
|
||||
}
|
||||
resourceKey := rc.Addr.Resource.String()
|
||||
if _, exists := byModule[moduleKey][resourceKey]; !exists {
|
||||
resourceKeys[moduleKey] = append(resourceKeys[moduleKey], resourceKey)
|
||||
byModule[moduleKey][resourceKey] = &ResourceChanges{
|
||||
Deposed: make(map[states.DeposedKey]*plans.ResourceInstanceChangeSrc),
|
||||
}
|
||||
}
|
||||
|
||||
if rc.DeposedKey == states.NotDeposed {
|
||||
byModule[moduleKey][resourceKey].Current = rc
|
||||
} else {
|
||||
byModule[moduleKey][resourceKey].Deposed[rc.DeposedKey] = rc
|
||||
}
|
||||
}
|
||||
sort.Strings(moduleKeys)
|
||||
for _, ks := range resourceKeys {
|
||||
sort.Strings(ks)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
|
||||
for _, moduleKey := range moduleKeys {
|
||||
rcs := byModule[moduleKey]
|
||||
var mBuf bytes.Buffer
|
||||
|
||||
for _, resourceKey := range resourceKeys[moduleKey] {
|
||||
rc := rcs[resourceKey]
|
||||
|
||||
crud := "UPDATE"
|
||||
if rc.Current != nil {
|
||||
switch rc.Current.Action {
|
||||
case plans.DeleteThenCreate:
|
||||
crud = "DESTROY/CREATE"
|
||||
case plans.CreateThenDelete:
|
||||
crud = "CREATE/DESTROY"
|
||||
case plans.Delete:
|
||||
crud = "DESTROY"
|
||||
case plans.Create:
|
||||
crud = "CREATE"
|
||||
}
|
||||
} else {
|
||||
// We must be working on a deposed object then, in which
|
||||
// case destroying is the only possible action.
|
||||
crud = "DESTROY"
|
||||
}
|
||||
|
||||
extra := ""
|
||||
if rc.Current == nil && len(rc.Deposed) > 0 {
|
||||
extra = " (deposed only)"
|
||||
}
|
||||
|
||||
fmt.Fprintf(
|
||||
&mBuf, "%s: %s%s\n",
|
||||
crud, resourceKey, extra,
|
||||
)
|
||||
|
||||
attrNames := map[string]bool{}
|
||||
var oldAttrs map[string]string
|
||||
var newAttrs map[string]string
|
||||
if rc.Current != nil {
|
||||
if before := rc.Current.Before; before != nil {
|
||||
ty, err := before.ImpliedType()
|
||||
if err == nil {
|
||||
val, err := before.Decode(ty)
|
||||
if err == nil {
|
||||
oldAttrs = hcl2shim.FlatmapValueFromHCL2(val)
|
||||
for k := range oldAttrs {
|
||||
attrNames[k] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if after := rc.Current.After; after != nil {
|
||||
ty, err := after.ImpliedType()
|
||||
if err == nil {
|
||||
val, err := after.Decode(ty)
|
||||
if err == nil {
|
||||
newAttrs = hcl2shim.FlatmapValueFromHCL2(val)
|
||||
for k := range newAttrs {
|
||||
attrNames[k] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if oldAttrs == nil {
|
||||
oldAttrs = make(map[string]string)
|
||||
}
|
||||
if newAttrs == nil {
|
||||
newAttrs = make(map[string]string)
|
||||
}
|
||||
|
||||
attrNamesOrder := make([]string, 0, len(attrNames))
|
||||
keyLen := 0
|
||||
for n := range attrNames {
|
||||
attrNamesOrder = append(attrNamesOrder, n)
|
||||
if len(n) > keyLen {
|
||||
keyLen = len(n)
|
||||
}
|
||||
}
|
||||
sort.Strings(attrNamesOrder)
|
||||
|
||||
for _, attrK := range attrNamesOrder {
|
||||
v := newAttrs[attrK]
|
||||
u := oldAttrs[attrK]
|
||||
|
||||
if v == config.UnknownVariableValue {
|
||||
v = "<computed>"
|
||||
}
|
||||
// NOTE: we don't support <sensitive> here because we would
|
||||
// need schema to do that. Excluding sensitive values
|
||||
// is now done at the UI layer, and so should not be tested
|
||||
// at the core layer.
|
||||
|
||||
updateMsg := ""
|
||||
// TODO: Mark " (forces new resource)" in updateMsg when appropriate.
|
||||
|
||||
fmt.Fprintf(
|
||||
&mBuf, " %s:%s %#v => %#v%s\n",
|
||||
attrK,
|
||||
strings.Repeat(" ", keyLen-len(attrK)),
|
||||
u, v,
|
||||
updateMsg,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
if moduleKey == "" { // root module
|
||||
buf.Write(mBuf.Bytes())
|
||||
buf.WriteByte('\n')
|
||||
continue
|
||||
}
|
||||
|
||||
fmt.Fprintf(&buf, "%s:\n", moduleKey)
|
||||
s := bufio.NewScanner(&mBuf)
|
||||
for s.Scan() {
|
||||
buf.WriteString(fmt.Sprintf(" %s\n", s.Text()))
|
||||
}
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func testStepTaint(state *terraform.State, step TestStep) error {
|
||||
for _, p := range step.Taint {
|
||||
m := state.RootModule()
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user