github.com/caicloud/helm@v2.5.0+incompatible/cmd/rudder/rudder.go (about)

     1  /*
     2  Copyright 2017 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 main
    18  
    19  import (
    20  	"bytes"
    21  	"fmt"
    22  	"net"
    23  
    24  	"golang.org/x/net/context"
    25  	"google.golang.org/grpc"
    26  	"google.golang.org/grpc/grpclog"
    27  	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
    28  
    29  	"k8s.io/helm/pkg/kube"
    30  	rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder"
    31  	"k8s.io/helm/pkg/rudder"
    32  	"k8s.io/helm/pkg/tiller"
    33  	"k8s.io/helm/pkg/version"
    34  )
    35  
    36  var kubeClient *kube.Client
    37  var clientset internalclientset.Interface
    38  
    39  func main() {
    40  	var err error
    41  	kubeClient = kube.New(nil)
    42  	clientset, err = kubeClient.ClientSet()
    43  	if err != nil {
    44  		grpclog.Fatalf("Cannot initialize Kubernetes connection: %s", err)
    45  	}
    46  
    47  	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", rudder.GrpcPort))
    48  	if err != nil {
    49  		grpclog.Fatalf("failed to listen: %v", err)
    50  	}
    51  	grpcServer := grpc.NewServer()
    52  	rudderAPI.RegisterReleaseModuleServiceServer(grpcServer, &ReleaseModuleServiceServer{})
    53  
    54  	grpclog.Print("Server starting")
    55  	grpcServer.Serve(lis)
    56  	grpclog.Print("Server started")
    57  }
    58  
    59  // ReleaseModuleServiceServer provides implementation for rudderAPI.ReleaseModuleServiceServer
    60  type ReleaseModuleServiceServer struct{}
    61  
    62  // Version returns Rudder version based on helm version
    63  func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *rudderAPI.VersionReleaseRequest) (*rudderAPI.VersionReleaseResponse, error) {
    64  	grpclog.Print("version")
    65  	return &rudderAPI.VersionReleaseResponse{
    66  		Name:    "helm-rudder-native",
    67  		Version: version.Version,
    68  	}, nil
    69  }
    70  
    71  // InstallRelease creates a release using kubeClient.Create
    72  func (r *ReleaseModuleServiceServer) InstallRelease(ctx context.Context, in *rudderAPI.InstallReleaseRequest) (*rudderAPI.InstallReleaseResponse, error) {
    73  	grpclog.Print("install")
    74  	b := bytes.NewBufferString(in.Release.Manifest)
    75  	err := kubeClient.Create(in.Release.Namespace, b, 500, false)
    76  	if err != nil {
    77  		grpclog.Printf("error when creating release: %v", err)
    78  	}
    79  	return &rudderAPI.InstallReleaseResponse{}, err
    80  }
    81  
    82  // DeleteRelease deletes a provided release
    83  func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *rudderAPI.DeleteReleaseRequest) (*rudderAPI.DeleteReleaseResponse, error) {
    84  	grpclog.Print("delete")
    85  
    86  	resp := &rudderAPI.DeleteReleaseResponse{}
    87  	rel := in.Release
    88  	vs, err := tiller.GetVersionSet(clientset.Discovery())
    89  	if err != nil {
    90  		return resp, fmt.Errorf("Could not get apiVersions from Kubernetes: %v", err)
    91  	}
    92  
    93  	kept, errs := tiller.DeleteRelease(rel, vs, kubeClient)
    94  	rel.Manifest = kept
    95  
    96  	allErrors := ""
    97  	for _, e := range errs {
    98  		allErrors = allErrors + "\n" + e.Error()
    99  	}
   100  
   101  	if len(allErrors) > 0 {
   102  		err = fmt.Errorf(allErrors)
   103  	}
   104  
   105  	return &rudderAPI.DeleteReleaseResponse{
   106  		Release: rel,
   107  	}, err
   108  }
   109  
   110  // RollbackRelease rolls back the release
   111  func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *rudderAPI.RollbackReleaseRequest) (*rudderAPI.RollbackReleaseResponse, error) {
   112  	grpclog.Print("rollback")
   113  	c := bytes.NewBufferString(in.Current.Manifest)
   114  	t := bytes.NewBufferString(in.Target.Manifest)
   115  	err := kubeClient.Update(in.Target.Namespace, c, t, in.Force, in.Recreate, in.Timeout, in.Wait)
   116  	return &rudderAPI.RollbackReleaseResponse{}, err
   117  }
   118  
   119  // UpgradeRelease upgrades manifests using kubernetes client
   120  func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *rudderAPI.UpgradeReleaseRequest) (*rudderAPI.UpgradeReleaseResponse, error) {
   121  	grpclog.Print("upgrade")
   122  	c := bytes.NewBufferString(in.Current.Manifest)
   123  	t := bytes.NewBufferString(in.Target.Manifest)
   124  	err := kubeClient.Update(in.Target.Namespace, c, t, in.Force, in.Recreate, in.Timeout, in.Wait)
   125  	// upgrade response object should be changed to include status
   126  	return &rudderAPI.UpgradeReleaseResponse{}, err
   127  }
   128  
   129  // ReleaseStatus retrieves release status
   130  func (r *ReleaseModuleServiceServer) ReleaseStatus(ctx context.Context, in *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatusResponse, error) {
   131  	grpclog.Print("status")
   132  
   133  	resp, err := kubeClient.Get(in.Release.Namespace, bytes.NewBufferString(in.Release.Manifest))
   134  	in.Release.Info.Status.Resources = resp
   135  	return &rudderAPI.ReleaseStatusResponse{
   136  		Release: in.Release,
   137  		Info:    in.Release.Info,
   138  	}, err
   139  }