Inital import

.gitignore

@@ -10,3 +10,5 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+bin/
\ No newline at end of file

Makefile

+build:
+	go build -o bin/jcli
\ No newline at end of file

app/cmd/crumbIssuer.go

+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+
+	"github.com/spf13/cobra"
+)
+
+// Start contains the command line options
+type CrumbIssuerOptions struct {
+	Upload bool
+}
+
+func init() {
+	rootCmd.AddCommand(versionCmd)
+}
+
+var versionCmd = &cobra.Command{
+	Use:   "crumb",
+	Short: "Print the version number of Hugo",
+	Long:  `Manage the plugin of Jenkins`,
+	Run: func(cmd *cobra.Command, args []string) {
+		//curl -k -u $JENKINS_USER:$JENKINS_TOKEN $JENKINS_URL/crumbIssuer/api/json -s
+	},
+}
+
+type CrumbIssuer struct {
+	Crumb             string `json:"crumb"`
+	CrumbRequestField string `json:"crumbRequestField"`
+}
+
+func getCrumb() (CrumbIssuer, Config) {
+	config := getConfig()
+	fmt.Println(config)
+
+	jenkinsRoot := config.JenkinsServers[0].URL
+	api := fmt.Sprintf("%s/crumbIssuer/api/json", jenkinsRoot)
+
+	req, err := http.NewRequest("GET", api, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	req.SetBasicAuth(config.JenkinsServers[0].UserName, config.JenkinsServers[0].Token)
+
+	var crumbIssuer CrumbIssuer
+	client := &http.Client{}
+	if response, err := client.Do(req); err == nil {
+		if data, err := ioutil.ReadAll(response.Body); err == nil {
+			fmt.Println("crumbe success")
+			fmt.Println(string(data))
+			json.Unmarshal(data, &crumbIssuer)
+		} else {
+			log.Fatal(err)
+		}
+	} else {
+		log.Fatal(err)
+	}
+	return crumbIssuer, config
+}
+
+func init() {
+}

app/cmd/plugin.go

+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Start contains the command line options
+type PluginOptions struct {
+	Upload bool
+}
+
+func init() {
+	rootCmd.AddCommand(pluginCmd)
+}
+
+var author PluginOptions
+
+var pluginCmd = &cobra.Command{
+	Use:   "plugin",
+	Short: "Print the version number of Hugo",
+	Long:  `Manage the plugin of Jenkins`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")
+
+		fmt.Printf("upload: %v\n", author.Upload)
+		if author.Upload {
+			crumb, config := getCrumb()
+
+			fmt.Println("crumb", crumb)
+
+			jenkinsRoot := getConfig().JenkinsServers[0].URL
+			api := fmt.Sprintf("%s/pluginManager/uploadPlugin", jenkinsRoot)
+
+			path, _ := os.Getwd()
+			path += "/target/alauda-devops-sync.hpi"
+			fmt.Println("target path", path)
+			extraParams := map[string]string{}
+			request, err := newfileUploadRequest(api, extraParams, "@name", path)
+			if err != nil {
+				log.Fatal(err)
+			}
+			request.SetBasicAuth(config.JenkinsServers[0].UserName, config.JenkinsServers[0].Token)
+			request.Header.Add("Accept", "*/*")
+			request.Header.Add(crumb.CrumbRequestField, crumb.Crumb)
+			fmt.Println(request.Header)
+			if err == nil {
+				client := &http.Client{}
+				var response *http.Response
+				response, err = client.Do(request)
+				if err != nil {
+					fmt.Println(err)
+				} else if response.StatusCode != 200 {
+					var data []byte
+					if data, err = ioutil.ReadAll(response.Body); err == nil {
+						fmt.Println(string(data))
+					} else {
+						log.Fatal(err)
+					}
+				}
+			} else {
+				log.Fatal(err)
+			}
+		}
+	},
+}
+
+func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
+	if err != nil {
+		return nil, err
+	}
+	_, err = io.Copy(part, file)
+
+	for key, val := range params {
+		_ = writer.WriteField(key, val)
+	}
+	err = writer.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", uri, body)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	return req, err
+}
+
+func init() {
+	rootCmd.PersistentFlags().BoolVar(&author.Upload, "upload", false, "Upload plugin to your Jenkins server")
+	viper.BindPFlag("upload", rootCmd.PersistentFlags().Lookup("upload"))
+}

app/cmd/root.go

+package cmd
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"gopkg.in/yaml.v2"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "hugo",
+	Short: "Hugo is a very fast static site generator",
+	Long: `A Fast and Flexible Static Site Generator built with
+				  love by spf13 and friends in Go.
+				  Complete documentation is available at http://hugo.spf13.com`,
+	Run: func(cmd *cobra.Command, args []string) {
+		// Do Stuff Here
+		fmt.Println("hello")
+	},
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+type JenkinsServer struct {
+	URL      string `yaml:"url"`
+	UserName string `yaml:"username"`
+	Token    string `yaml:"token"`
+}
+
+type Config struct {
+	JenkinsServers []JenkinsServer `yaml:"jenkins_servers"`
+}
+
+func init() {
+	cobra.OnInitialize(initConfig)
+	rootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")
+	viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))
+	viper.BindPFlag("projectbase", rootCmd.PersistentFlags().Lookup("projectbase"))
+	viper.BindPFlag("useViper", rootCmd.PersistentFlags().Lookup("viper"))
+	viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")
+	viper.SetDefault("license", "apache")
+}
+
+var config Config
+
+func getConfig() Config {
+	return config
+}
+
+func initConfig() {
+	content, err := ioutil.ReadFile("/Users/mac/.jenkins-cli.yaml")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = yaml.Unmarshal([]byte(content), &config)
+	if err != nil {
+		log.Fatalf("error: %v", err)
+	}
+}

main.go

+package main
+
+import (
+	"github.com/linuxsuren/jenkins-cli/app/cmd"
+)
+
+func main() {
+	cmd.Execute()
+}