github.com/sinangedik/terraform@v0.3.5/remote/atlas.go (about) 1 package remote 2 3 import ( 4 "bytes" 5 "crypto/md5" 6 "encoding/base64" 7 "fmt" 8 "io" 9 "net/http" 10 "net/url" 11 "path" 12 "strings" 13 ) 14 15 const ( 16 // defaultAtlasServer is used when no address is given 17 defaultAtlasServer = "https://atlas.hashicorp.com/" 18 ) 19 20 // AtlasRemoteClient implements the RemoteClient interface 21 // for an Atlas compatible server. 22 type AtlasRemoteClient struct { 23 server string 24 serverURL *url.URL 25 user string 26 name string 27 accessToken string 28 } 29 30 func NewAtlasRemoteClient(conf map[string]string) (*AtlasRemoteClient, error) { 31 client := &AtlasRemoteClient{} 32 if err := client.validateConfig(conf); err != nil { 33 return nil, err 34 } 35 return client, nil 36 } 37 38 func (c *AtlasRemoteClient) validateConfig(conf map[string]string) error { 39 server, ok := conf["address"] 40 if !ok || server == "" { 41 server = defaultAtlasServer 42 } 43 url, err := url.Parse(server) 44 if err != nil { 45 return err 46 } 47 c.server = server 48 c.serverURL = url 49 50 token, ok := conf["access_token"] 51 if !ok || token == "" { 52 return fmt.Errorf("missing 'access_token' configuration") 53 } 54 c.accessToken = token 55 56 name, ok := conf["name"] 57 if !ok || name == "" { 58 return fmt.Errorf("missing 'name' configuration") 59 } 60 61 parts := strings.Split(name, "/") 62 if len(parts) != 2 { 63 return fmt.Errorf("malformed name '%s'", name) 64 } 65 c.user = parts[0] 66 c.name = parts[1] 67 return nil 68 } 69 70 func (c *AtlasRemoteClient) GetState() (*RemoteStatePayload, error) { 71 // Make the HTTP request 72 req, err := http.NewRequest("GET", c.url().String(), nil) 73 if err != nil { 74 return nil, fmt.Errorf("Failed to make HTTP request: %v", err) 75 } 76 77 // Request the url 78 resp, err := http.DefaultClient.Do(req) 79 if err != nil { 80 return nil, err 81 } 82 defer resp.Body.Close() 83 84 // Handle the common status codes 85 switch resp.StatusCode { 86 case http.StatusOK: 87 // Handled after 88 case http.StatusNoContent: 89 return nil, nil 90 case http.StatusNotFound: 91 return nil, nil 92 case http.StatusUnauthorized: 93 return nil, ErrRequireAuth 94 case http.StatusForbidden: 95 return nil, ErrInvalidAuth 96 case http.StatusInternalServerError: 97 return nil, ErrRemoteInternal 98 default: 99 return nil, fmt.Errorf("Unexpected HTTP response code %d", resp.StatusCode) 100 } 101 102 // Read in the body 103 buf := bytes.NewBuffer(nil) 104 if _, err := io.Copy(buf, resp.Body); err != nil { 105 return nil, fmt.Errorf("Failed to read remote state: %v", err) 106 } 107 108 // Create the payload 109 payload := &RemoteStatePayload{ 110 State: buf.Bytes(), 111 } 112 113 // Check for the MD5 114 if raw := resp.Header.Get("Content-MD5"); raw != "" { 115 md5, err := base64.StdEncoding.DecodeString(raw) 116 if err != nil { 117 return nil, fmt.Errorf("Failed to decode Content-MD5 '%s': %v", raw, err) 118 } 119 payload.MD5 = md5 120 121 } else { 122 // Generate the MD5 123 hash := md5.Sum(payload.State) 124 payload.MD5 = hash[:md5.Size] 125 } 126 127 return payload, nil 128 } 129 130 func (c *AtlasRemoteClient) PutState(state []byte, force bool) error { 131 // Get the target URL 132 base := c.url() 133 134 // Generate the MD5 135 hash := md5.Sum(state) 136 b64 := base64.StdEncoding.EncodeToString(hash[:md5.Size]) 137 138 // Set the force query parameter if needed 139 if force { 140 values := base.Query() 141 values.Set("force", "true") 142 base.RawQuery = values.Encode() 143 } 144 145 // Make the HTTP client and request 146 req, err := http.NewRequest("PUT", base.String(), bytes.NewReader(state)) 147 if err != nil { 148 return fmt.Errorf("Failed to make HTTP request: %v", err) 149 } 150 151 // Prepare the request 152 req.Header.Set("Content-MD5", b64) 153 req.Header.Set("Content-Type", "application/json") 154 req.ContentLength = int64(len(state)) 155 156 // Make the request 157 resp, err := http.DefaultClient.Do(req) 158 if err != nil { 159 return fmt.Errorf("Failed to upload state: %v", err) 160 } 161 defer resp.Body.Close() 162 163 // Handle the error codes 164 switch resp.StatusCode { 165 case http.StatusOK: 166 return nil 167 case http.StatusConflict: 168 return ErrConflict 169 case http.StatusPreconditionFailed: 170 return ErrServerNewer 171 case http.StatusUnauthorized: 172 return ErrRequireAuth 173 case http.StatusForbidden: 174 return ErrInvalidAuth 175 case http.StatusInternalServerError: 176 return ErrRemoteInternal 177 default: 178 return fmt.Errorf("Unexpected HTTP response code %d", resp.StatusCode) 179 } 180 } 181 182 func (c *AtlasRemoteClient) DeleteState() error { 183 // Make the HTTP request 184 req, err := http.NewRequest("DELETE", c.url().String(), nil) 185 if err != nil { 186 return fmt.Errorf("Failed to make HTTP request: %v", err) 187 } 188 189 // Make the request 190 resp, err := http.DefaultClient.Do(req) 191 if err != nil { 192 return fmt.Errorf("Failed to delete state: %v", err) 193 } 194 defer resp.Body.Close() 195 196 // Handle the error codes 197 switch resp.StatusCode { 198 case http.StatusOK: 199 return nil 200 case http.StatusNoContent: 201 return nil 202 case http.StatusNotFound: 203 return nil 204 case http.StatusUnauthorized: 205 return ErrRequireAuth 206 case http.StatusForbidden: 207 return ErrInvalidAuth 208 case http.StatusInternalServerError: 209 return ErrRemoteInternal 210 default: 211 return fmt.Errorf("Unexpected HTTP response code %d", resp.StatusCode) 212 } 213 return nil 214 } 215 216 func (c *AtlasRemoteClient) url() *url.URL { 217 return &url.URL{ 218 Scheme: c.serverURL.Scheme, 219 Host: c.serverURL.Host, 220 Path: path.Join("api/v1/terraform/state", c.user, c.name), 221 RawQuery: fmt.Sprintf("access_token=%s", c.accessToken), 222 } 223 }