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  }