api.snapshot.restore.go 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. // Licensed to Elasticsearch B.V. under one or more contributor
  2. // license agreements. See the NOTICE file distributed with
  3. // this work for additional information regarding copyright
  4. // ownership. Elasticsearch B.V. licenses this file to you under
  5. // the Apache License, Version 2.0 (the "License"); you may
  6. // not use this file except in compliance with the License.
  7. // You may obtain a copy of the License at
  8. //
  9. // http://www.apache.org/licenses/LICENSE-2.0
  10. //
  11. // Unless required by applicable law or agreed to in writing,
  12. // software distributed under the License is distributed on an
  13. // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14. // KIND, either express or implied. See the License for the
  15. // specific language governing permissions and limitations
  16. // under the License.
  17. //
  18. // Code generated from specification version 7.17.10: DO NOT EDIT
  19. package esapi
  20. import (
  21. "context"
  22. "io"
  23. "net/http"
  24. "strconv"
  25. "strings"
  26. "time"
  27. )
  28. func newSnapshotRestoreFunc(t Transport) SnapshotRestore {
  29. return func(repository string, snapshot string, o ...func(*SnapshotRestoreRequest)) (*Response, error) {
  30. var r = SnapshotRestoreRequest{Repository: repository, Snapshot: snapshot}
  31. for _, f := range o {
  32. f(&r)
  33. }
  34. return r.Do(r.ctx, t)
  35. }
  36. }
  37. // ----- API Definition -------------------------------------------------------
  38. // SnapshotRestore restores a snapshot.
  39. //
  40. // See full documentation at https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html.
  41. type SnapshotRestore func(repository string, snapshot string, o ...func(*SnapshotRestoreRequest)) (*Response, error)
  42. // SnapshotRestoreRequest configures the Snapshot Restore API request.
  43. type SnapshotRestoreRequest struct {
  44. Body io.Reader
  45. Repository string
  46. Snapshot string
  47. MasterTimeout time.Duration
  48. WaitForCompletion *bool
  49. Pretty bool
  50. Human bool
  51. ErrorTrace bool
  52. FilterPath []string
  53. Header http.Header
  54. ctx context.Context
  55. }
  56. // Do executes the request and returns response or error.
  57. func (r SnapshotRestoreRequest) Do(ctx context.Context, transport Transport) (*Response, error) {
  58. var (
  59. method string
  60. path strings.Builder
  61. params map[string]string
  62. )
  63. method = "POST"
  64. path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(r.Snapshot) + 1 + len("_restore"))
  65. path.WriteString("/")
  66. path.WriteString("_snapshot")
  67. path.WriteString("/")
  68. path.WriteString(r.Repository)
  69. path.WriteString("/")
  70. path.WriteString(r.Snapshot)
  71. path.WriteString("/")
  72. path.WriteString("_restore")
  73. params = make(map[string]string)
  74. if r.MasterTimeout != 0 {
  75. params["master_timeout"] = formatDuration(r.MasterTimeout)
  76. }
  77. if r.WaitForCompletion != nil {
  78. params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion)
  79. }
  80. if r.Pretty {
  81. params["pretty"] = "true"
  82. }
  83. if r.Human {
  84. params["human"] = "true"
  85. }
  86. if r.ErrorTrace {
  87. params["error_trace"] = "true"
  88. }
  89. if len(r.FilterPath) > 0 {
  90. params["filter_path"] = strings.Join(r.FilterPath, ",")
  91. }
  92. req, err := newRequest(method, path.String(), r.Body)
  93. if err != nil {
  94. return nil, err
  95. }
  96. if len(params) > 0 {
  97. q := req.URL.Query()
  98. for k, v := range params {
  99. q.Set(k, v)
  100. }
  101. req.URL.RawQuery = q.Encode()
  102. }
  103. if len(r.Header) > 0 {
  104. if len(req.Header) == 0 {
  105. req.Header = r.Header
  106. } else {
  107. for k, vv := range r.Header {
  108. for _, v := range vv {
  109. req.Header.Add(k, v)
  110. }
  111. }
  112. }
  113. }
  114. if r.Body != nil && req.Header.Get(headerContentType) == "" {
  115. req.Header[headerContentType] = headerContentTypeJSON
  116. }
  117. if ctx != nil {
  118. req = req.WithContext(ctx)
  119. }
  120. res, err := transport.Perform(req)
  121. if err != nil {
  122. return nil, err
  123. }
  124. response := Response{
  125. StatusCode: res.StatusCode,
  126. Body: res.Body,
  127. Header: res.Header,
  128. }
  129. return &response, nil
  130. }
  131. // WithContext sets the request context.
  132. func (f SnapshotRestore) WithContext(v context.Context) func(*SnapshotRestoreRequest) {
  133. return func(r *SnapshotRestoreRequest) {
  134. r.ctx = v
  135. }
  136. }
  137. // WithBody - Details of what to restore.
  138. func (f SnapshotRestore) WithBody(v io.Reader) func(*SnapshotRestoreRequest) {
  139. return func(r *SnapshotRestoreRequest) {
  140. r.Body = v
  141. }
  142. }
  143. // WithMasterTimeout - explicit operation timeout for connection to master node.
  144. func (f SnapshotRestore) WithMasterTimeout(v time.Duration) func(*SnapshotRestoreRequest) {
  145. return func(r *SnapshotRestoreRequest) {
  146. r.MasterTimeout = v
  147. }
  148. }
  149. // WithWaitForCompletion - should this request wait until the operation has completed before returning.
  150. func (f SnapshotRestore) WithWaitForCompletion(v bool) func(*SnapshotRestoreRequest) {
  151. return func(r *SnapshotRestoreRequest) {
  152. r.WaitForCompletion = &v
  153. }
  154. }
  155. // WithPretty makes the response body pretty-printed.
  156. func (f SnapshotRestore) WithPretty() func(*SnapshotRestoreRequest) {
  157. return func(r *SnapshotRestoreRequest) {
  158. r.Pretty = true
  159. }
  160. }
  161. // WithHuman makes statistical values human-readable.
  162. func (f SnapshotRestore) WithHuman() func(*SnapshotRestoreRequest) {
  163. return func(r *SnapshotRestoreRequest) {
  164. r.Human = true
  165. }
  166. }
  167. // WithErrorTrace includes the stack trace for errors in the response body.
  168. func (f SnapshotRestore) WithErrorTrace() func(*SnapshotRestoreRequest) {
  169. return func(r *SnapshotRestoreRequest) {
  170. r.ErrorTrace = true
  171. }
  172. }
  173. // WithFilterPath filters the properties of the response body.
  174. func (f SnapshotRestore) WithFilterPath(v ...string) func(*SnapshotRestoreRequest) {
  175. return func(r *SnapshotRestoreRequest) {
  176. r.FilterPath = v
  177. }
  178. }
  179. // WithHeader adds the headers to the HTTP request.
  180. func (f SnapshotRestore) WithHeader(h map[string]string) func(*SnapshotRestoreRequest) {
  181. return func(r *SnapshotRestoreRequest) {
  182. if r.Header == nil {
  183. r.Header = make(http.Header)
  184. }
  185. for k, v := range h {
  186. r.Header.Add(k, v)
  187. }
  188. }
  189. }
  190. // WithOpaqueID adds the X-Opaque-Id header to the HTTP request.
  191. func (f SnapshotRestore) WithOpaqueID(s string) func(*SnapshotRestoreRequest) {
  192. return func(r *SnapshotRestoreRequest) {
  193. if r.Header == nil {
  194. r.Header = make(http.Header)
  195. }
  196. r.Header.Set("X-Opaque-Id", s)
  197. }
  198. }