github.com/felipejfc/helm@v2.1.2+incompatible/pkg/helm/client.go (about) 1 /* 2 Copyright 2016 The Kubernetes Authors All rights reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package helm // import "k8s.io/helm/pkg/helm" 18 19 import ( 20 "golang.org/x/net/context" 21 "google.golang.org/grpc" 22 23 "k8s.io/helm/pkg/chartutil" 24 rls "k8s.io/helm/pkg/proto/hapi/services" 25 ) 26 27 // Client manages client side of the helm-tiller protocol 28 type Client struct { 29 opts options 30 } 31 32 // NewClient creates a new client. 33 func NewClient(opts ...Option) *Client { 34 var c Client 35 return c.Option(opts...) 36 } 37 38 // Option configures the helm client with the provided options 39 func (h *Client) Option(opts ...Option) *Client { 40 for _, opt := range opts { 41 opt(&h.opts) 42 } 43 return h 44 } 45 46 // ListReleases lists the current releases. 47 func (h *Client) ListReleases(opts ...ReleaseListOption) (*rls.ListReleasesResponse, error) { 48 for _, opt := range opts { 49 opt(&h.opts) 50 } 51 req := &h.opts.listReq 52 ctx := NewContext() 53 54 if h.opts.before != nil { 55 if err := h.opts.before(ctx, req); err != nil { 56 return nil, err 57 } 58 } 59 return h.list(ctx, req) 60 } 61 62 // InstallRelease installs a new chart and returns the release response. 63 func (h *Client) InstallRelease(chstr, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { 64 // load the chart to install 65 chart, err := chartutil.Load(chstr) 66 if err != nil { 67 return nil, err 68 } 69 70 // apply the install options 71 for _, opt := range opts { 72 opt(&h.opts) 73 } 74 req := &h.opts.instReq 75 req.Chart = chart 76 req.Namespace = ns 77 req.DryRun = h.opts.dryRun 78 req.DisableHooks = h.opts.disableHooks 79 req.ReuseName = h.opts.reuseName 80 ctx := NewContext() 81 82 if h.opts.before != nil { 83 if err := h.opts.before(ctx, req); err != nil { 84 return nil, err 85 } 86 } 87 return h.install(ctx, req) 88 } 89 90 // DeleteRelease uninstalls a named release and returns the response. 91 func (h *Client) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error) { 92 // apply the uninstall options 93 for _, opt := range opts { 94 opt(&h.opts) 95 } 96 97 if h.opts.dryRun { 98 // In the dry run case, just see if the release exists 99 r, err := h.ReleaseContent(rlsName) 100 if err != nil { 101 return &rls.UninstallReleaseResponse{}, err 102 } 103 return &rls.UninstallReleaseResponse{Release: r.Release}, nil 104 } 105 106 req := &h.opts.uninstallReq 107 req.Name = rlsName 108 req.DisableHooks = h.opts.disableHooks 109 ctx := NewContext() 110 111 if h.opts.before != nil { 112 if err := h.opts.before(ctx, req); err != nil { 113 return nil, err 114 } 115 } 116 return h.delete(ctx, req) 117 } 118 119 // UpdateRelease updates a release to a new/different chart 120 func (h *Client) UpdateRelease(rlsName string, chstr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { 121 // load the chart to update 122 chart, err := chartutil.Load(chstr) 123 if err != nil { 124 return nil, err 125 } 126 127 // apply the update options 128 for _, opt := range opts { 129 opt(&h.opts) 130 } 131 req := &h.opts.updateReq 132 req.Chart = chart 133 req.DryRun = h.opts.dryRun 134 req.Name = rlsName 135 req.DisableHooks = h.opts.disableHooks 136 ctx := NewContext() 137 138 if h.opts.before != nil { 139 if err := h.opts.before(ctx, req); err != nil { 140 return nil, err 141 } 142 } 143 return h.update(ctx, req) 144 } 145 146 // GetVersion returns the server version 147 func (h *Client) GetVersion(opts ...VersionOption) (*rls.GetVersionResponse, error) { 148 for _, opt := range opts { 149 opt(&h.opts) 150 } 151 req := &rls.GetVersionRequest{} 152 ctx := NewContext() 153 154 if h.opts.before != nil { 155 if err := h.opts.before(ctx, req); err != nil { 156 return nil, err 157 } 158 } 159 return h.version(ctx, req) 160 } 161 162 // RollbackRelease rolls back a release to the previous version 163 func (h *Client) RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.RollbackReleaseResponse, error) { 164 for _, opt := range opts { 165 opt(&h.opts) 166 } 167 req := &h.opts.rollbackReq 168 req.DisableHooks = h.opts.disableHooks 169 req.DryRun = h.opts.dryRun 170 req.Name = rlsName 171 ctx := NewContext() 172 173 if h.opts.before != nil { 174 if err := h.opts.before(ctx, req); err != nil { 175 return nil, err 176 } 177 } 178 return h.rollback(ctx, req) 179 } 180 181 // ReleaseStatus returns the given release's status. 182 func (h *Client) ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error) { 183 for _, opt := range opts { 184 opt(&h.opts) 185 } 186 req := &h.opts.statusReq 187 req.Name = rlsName 188 ctx := NewContext() 189 190 if h.opts.before != nil { 191 if err := h.opts.before(ctx, req); err != nil { 192 return nil, err 193 } 194 } 195 return h.status(ctx, req) 196 } 197 198 // ReleaseContent returns the configuration for a given release. 199 func (h *Client) ReleaseContent(rlsName string, opts ...ContentOption) (*rls.GetReleaseContentResponse, error) { 200 for _, opt := range opts { 201 opt(&h.opts) 202 } 203 req := &h.opts.contentReq 204 req.Name = rlsName 205 ctx := NewContext() 206 207 if h.opts.before != nil { 208 if err := h.opts.before(ctx, req); err != nil { 209 return nil, err 210 } 211 } 212 return h.content(ctx, req) 213 } 214 215 // ReleaseHistory returns a release's revision history. 216 func (h *Client) ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.GetHistoryResponse, error) { 217 for _, opt := range opts { 218 opt(&h.opts) 219 } 220 221 req := &h.opts.histReq 222 req.Name = rlsName 223 ctx := NewContext() 224 225 if h.opts.before != nil { 226 if err := h.opts.before(ctx, req); err != nil { 227 return nil, err 228 } 229 } 230 return h.history(ctx, req) 231 } 232 233 // Executes tiller.ListReleases RPC. 234 func (h *Client) list(ctx context.Context, req *rls.ListReleasesRequest) (*rls.ListReleasesResponse, error) { 235 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 236 if err != nil { 237 return nil, err 238 } 239 defer c.Close() 240 241 rlc := rls.NewReleaseServiceClient(c) 242 s, err := rlc.ListReleases(ctx, req) 243 if err != nil { 244 return nil, err 245 } 246 247 return s.Recv() 248 } 249 250 // Executes tiller.InstallRelease RPC. 251 func (h *Client) install(ctx context.Context, req *rls.InstallReleaseRequest) (*rls.InstallReleaseResponse, error) { 252 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 253 if err != nil { 254 return nil, err 255 } 256 defer c.Close() 257 258 rlc := rls.NewReleaseServiceClient(c) 259 return rlc.InstallRelease(ctx, req) 260 } 261 262 // Executes tiller.UninstallRelease RPC. 263 func (h *Client) delete(ctx context.Context, req *rls.UninstallReleaseRequest) (*rls.UninstallReleaseResponse, error) { 264 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 265 if err != nil { 266 return nil, err 267 } 268 defer c.Close() 269 270 rlc := rls.NewReleaseServiceClient(c) 271 return rlc.UninstallRelease(ctx, req) 272 } 273 274 // Executes tiller.UpdateRelease RPC. 275 func (h *Client) update(ctx context.Context, req *rls.UpdateReleaseRequest) (*rls.UpdateReleaseResponse, error) { 276 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 277 if err != nil { 278 return nil, err 279 } 280 defer c.Close() 281 282 rlc := rls.NewReleaseServiceClient(c) 283 return rlc.UpdateRelease(ctx, req) 284 } 285 286 // Executes tiller.RollbackRelease RPC. 287 func (h *Client) rollback(ctx context.Context, req *rls.RollbackReleaseRequest) (*rls.RollbackReleaseResponse, error) { 288 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 289 if err != nil { 290 return nil, err 291 } 292 defer c.Close() 293 294 rlc := rls.NewReleaseServiceClient(c) 295 return rlc.RollbackRelease(ctx, req) 296 } 297 298 // Executes tiller.GetReleaseStatus RPC. 299 func (h *Client) status(ctx context.Context, req *rls.GetReleaseStatusRequest) (*rls.GetReleaseStatusResponse, error) { 300 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 301 if err != nil { 302 return nil, err 303 } 304 defer c.Close() 305 306 rlc := rls.NewReleaseServiceClient(c) 307 return rlc.GetReleaseStatus(ctx, req) 308 } 309 310 // Executes tiller.GetReleaseContent RPC. 311 func (h *Client) content(ctx context.Context, req *rls.GetReleaseContentRequest) (*rls.GetReleaseContentResponse, error) { 312 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 313 if err != nil { 314 return nil, err 315 } 316 defer c.Close() 317 318 rlc := rls.NewReleaseServiceClient(c) 319 return rlc.GetReleaseContent(ctx, req) 320 } 321 322 // Executes tiller.GetVersion RPC. 323 func (h *Client) version(ctx context.Context, req *rls.GetVersionRequest) (*rls.GetVersionResponse, error) { 324 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 325 if err != nil { 326 return nil, err 327 } 328 defer c.Close() 329 330 rlc := rls.NewReleaseServiceClient(c) 331 return rlc.GetVersion(ctx, req) 332 } 333 334 // Executes tiller.GetHistory RPC. 335 func (h *Client) history(ctx context.Context, req *rls.GetHistoryRequest) (*rls.GetHistoryResponse, error) { 336 c, err := grpc.Dial(h.opts.host, grpc.WithInsecure()) 337 if err != nil { 338 return nil, err 339 } 340 defer c.Close() 341 342 rlc := rls.NewReleaseServiceClient(c) 343 return rlc.GetHistory(ctx, req) 344 }