-
Notifications
You must be signed in to change notification settings - Fork 786
/
create_micro.go
163 lines (138 loc) · 4.24 KB
/
create_micro.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
package cmd
import (
"fmt"
"io"
"os"
"path/filepath"
"runtime"
"github.com/spf13/cobra"
"gopkg.in/AlecAivazis/survey.v1/terminal"
"github.com/jenkins-x/jx/pkg/jx/cmd/templates"
"github.com/jenkins-x/jx/pkg/log"
"github.com/jenkins-x/jx/pkg/util"
)
var (
createMicroLong = templates.LongDesc(`
Creates a new micro application and then optionally setups CI/CD pipelines and GitOps promotion.
Micro is an application generator for gRPC services in Go with a set of tools/libraries.
This command is expected to be run within your '$GOHOME' directory. e.g. at '$GOHOME/src/github.com/myOrgOrUser/'
For more documentation about micro see: [https://github.com/microio/micro](https://github.com/microio/micro)
`)
createMicroExample = templates.Examples(`
# Create a micro application and be prompted for the folder name
jx create micro
# Create a micro application under test1
jx create micro -o test1
`)
)
// CreateMicroOptions the options for the create spring command
type CreateMicroOptions struct {
CreateProjectOptions
}
// NewCmdCreateMicro creates a command object for the "create" command
func NewCmdCreateMicro(f Factory, in terminal.FileReader, out terminal.FileWriter, errOut io.Writer) *cobra.Command {
options := &CreateMicroOptions{
CreateProjectOptions: CreateProjectOptions{
ImportOptions: ImportOptions{
CommonOptions: CommonOptions{
Factory: f,
In: in,
Out: out,
Err: errOut,
},
},
},
}
cmd := &cobra.Command{
Use: "micro [github.com/myuser/myapp]",
Short: "Create a new micro based application and import the generated code into Git and Jenkins for CI/CD",
Long: createMicroLong,
Example: createMicroExample,
Run: func(cmd *cobra.Command, args []string) {
options.Cmd = cmd
options.Args = args
err := options.Run()
CheckErr(err)
},
}
return cmd
}
// checkMicroInstalled lazily install micro if its not installed already
func (o CreateMicroOptions) checkMicroInstalled() error {
_, err := o.getCommandOutput("", "micro", "help")
if err != nil {
log.Infoln("Installing micro's dependencies...")
// lets install micro
err = o.installBrewIfRequired()
if err != nil {
return err
}
if runtime.GOOS == "darwin" && !o.NoBrew {
err = o.RunCommand("brew", "install", "protobuf")
if err != nil {
return err
}
}
log.Infoln("Downloading and building micro dependencies...")
packages := []string{"github.com/golang/protobuf/proto", "github.com/golang/protobuf/protoc-gen-go", "github.com/micro/protoc-gen-micro"}
for _, p := range packages {
log.Infof("Installing %s\n", p)
err = o.RunCommand("go", "get", "-u", p)
if err != nil {
return fmt.Errorf("Failed to install %s: %s", p, err)
}
}
log.Infoln("Installed micro dependencies")
log.Infoln("Downloading and building micro - this can take a minute or so...")
err = o.RunCommand("go", "get", "-u", "github.com/micro/micro")
if err == nil {
log.Infoln("Installed micro and its dependencies!")
}
}
return err
}
// GenerateMicro creates a fresh micro project by running micro on local shell
func (o CreateMicroOptions) GenerateMicro(dir string) error {
return o.RunCommand("micro", "new", dir)
}
// Run implements the command
func (o *CreateMicroOptions) Run() error {
gopath := os.Getenv("GOPATH")
if gopath == "" {
log.Warnf(`No $GOPATH found.
You need to have installed go on your machine to be able to create micro services.
For instructions please see: %s
`, util.ColorInfo("https://golang.org/doc/install#install"))
return nil
}
err := o.checkMicroInstalled()
if err != nil {
return err
}
dir := ""
args := o.Args
if len(args) > 0 {
dir = args[0]
}
if dir == "" {
if o.BatchMode {
return util.MissingOption(optionOutputDir)
}
dir, err = util.PickValue("Pick a fully qualified name for the new project:", "github.com/myuser/myapp", true, o.In, o.Out, o.Err)
if err != nil {
return err
}
if dir == "" || dir == "." {
return fmt.Errorf("Invalid project name: %s", dir)
}
}
log.Blank()
// generate micro project
err = o.GenerateMicro(dir)
if err != nil {
return err
}
path := filepath.Join(gopath, "src", dir)
log.Infof("Created micro project at %s\n\n", util.ColorInfo(path))
return o.ImportCreatedProject(path)
}