mirror of
https://github.com/restic/restic.git
synced 2024-08-28 15:17:22 +02:00
737 lines
16 KiB
Go
737 lines
16 KiB
Go
package main
|
|
|
|
// To run this package...
|
|
// go run gen.go -- --sdk 3.14.16
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
do "gopkg.in/godo.v2"
|
|
)
|
|
|
|
type service struct {
|
|
Name string
|
|
Fullname string
|
|
Namespace string
|
|
Packages []string
|
|
TaskName string
|
|
Version string
|
|
Input string
|
|
Output string
|
|
Swagger string
|
|
SubServices []service
|
|
Modeler modeler
|
|
Extension extension
|
|
}
|
|
|
|
type modeler string
|
|
|
|
const (
|
|
swagger modeler = "Swagger"
|
|
compSwagger modeler = "CompositeSwagger"
|
|
)
|
|
|
|
type extension string
|
|
|
|
const (
|
|
md extension = "md"
|
|
json extension = "json"
|
|
)
|
|
|
|
const (
|
|
testsSubDir = "tests"
|
|
)
|
|
|
|
type mapping struct {
|
|
Plane string
|
|
InputPrefix string
|
|
Services []service
|
|
}
|
|
|
|
var (
|
|
gopath = os.Getenv("GOPATH")
|
|
sdkVersion string
|
|
autorestDir string
|
|
swaggersDir string
|
|
testGen bool
|
|
deps do.S
|
|
services = []*service{}
|
|
servicesMapping = []mapping{
|
|
{
|
|
Plane: "arm",
|
|
InputPrefix: "arm-",
|
|
Services: []service{
|
|
{
|
|
Name: "advisor",
|
|
Version: "2017-04-19",
|
|
},
|
|
{
|
|
Name: "analysisservices",
|
|
Version: "2016-05-16",
|
|
},
|
|
{
|
|
Name: "apimanagement",
|
|
Swagger: "compositeApiManagementClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "appinsights",
|
|
Swagger: "compositeAppInsightsManagementClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "authorization",
|
|
Version: "2015-07-01",
|
|
},
|
|
{
|
|
Name: "automation",
|
|
Swagger: "compositeAutomation",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "batch",
|
|
Version: "2017-01-01",
|
|
Swagger: "BatchManagement",
|
|
},
|
|
{
|
|
Name: "billing",
|
|
Version: "2017-04-24-preview",
|
|
},
|
|
{
|
|
Name: "cdn",
|
|
Version: "2016-10-02",
|
|
},
|
|
{
|
|
// bug in AutoRest (duplicated files)
|
|
Name: "cognitiveservices",
|
|
// Version: "2017-04-18",
|
|
Version: "2016-02-01-preview",
|
|
},
|
|
{
|
|
Name: "commerce",
|
|
Version: "2015-06-01-preview",
|
|
},
|
|
{
|
|
Name: "compute",
|
|
Version: "2016-04-30-preview",
|
|
},
|
|
{
|
|
Name: "containerservice",
|
|
Version: "2017-01-31",
|
|
Swagger: "containerService",
|
|
Input: "compute",
|
|
},
|
|
{
|
|
Name: "consumption",
|
|
Version: "2017-04-24-preview",
|
|
},
|
|
{
|
|
Name: "containerregistry",
|
|
Version: "2017-03-01",
|
|
},
|
|
{
|
|
Name: "cosmos-db",
|
|
Version: "2015-04-08",
|
|
},
|
|
{
|
|
Name: "customer-insights",
|
|
Version: "2017-01-01",
|
|
},
|
|
{
|
|
Name: "datalake-analytics",
|
|
SubServices: []service{
|
|
{
|
|
Name: "account",
|
|
Version: "2016-11-01",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "datalake-store",
|
|
SubServices: []service{
|
|
{
|
|
Name: "account",
|
|
Version: "2016-11-01",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "devtestlabs",
|
|
Version: "2016-05-15",
|
|
Swagger: "DTL",
|
|
},
|
|
{
|
|
Name: "disk",
|
|
Version: "2016-04-30-preview",
|
|
Swagger: "disk",
|
|
Input: "compute",
|
|
},
|
|
{
|
|
Name: "dns",
|
|
Version: "2016-04-01",
|
|
},
|
|
// {
|
|
// Name: "documentdb",
|
|
// Version: "2015-04-08",
|
|
// },
|
|
{
|
|
Name: "eventhub",
|
|
Version: "2015-08-01",
|
|
Swagger: "EventHub",
|
|
},
|
|
{
|
|
Name: "graphrbac",
|
|
Swagger: "compositeGraphRbacManagementClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "hdinsight",
|
|
Swagger: "compositeHDInsight",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "insights",
|
|
Swagger: "compositeInsightsManagementClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "intune",
|
|
Version: "2015-01-14-preview",
|
|
},
|
|
{
|
|
Name: "iothub",
|
|
Version: "2016-02-03",
|
|
},
|
|
{
|
|
Name: "keyvault",
|
|
Version: "2015-06-01",
|
|
},
|
|
{
|
|
Name: "logic",
|
|
Version: "2016-06-01",
|
|
},
|
|
{
|
|
Name: "machinelearning",
|
|
SubServices: []service{
|
|
{
|
|
Name: "commitmentplans",
|
|
Version: "2016-05-01-preview",
|
|
Swagger: "commitmentPlans",
|
|
Input: "machinelearning",
|
|
},
|
|
{
|
|
Name: "webservices",
|
|
Version: "2017-01-01",
|
|
Input: "machinelearning",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "mediaservices",
|
|
Version: "2015-10-01",
|
|
Swagger: "media",
|
|
},
|
|
{
|
|
Name: "mobileengagement",
|
|
Version: "2014-12-01",
|
|
Swagger: "mobile-engagement",
|
|
},
|
|
{
|
|
Name: "monitor",
|
|
Swagger: "compositeMonitorManagementClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "mysql",
|
|
Version: "2017-04-30-preview",
|
|
},
|
|
{
|
|
Name: "network",
|
|
Swagger: "compositeNetworkClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
{
|
|
Name: "notificationhubs",
|
|
Version: "2017-04-01",
|
|
},
|
|
{
|
|
// bug in the Go generator https://github.com/Azure/autorest/issues/2219
|
|
Name: "operationalinsights",
|
|
// Swagger: "compositeOperationalInsights",
|
|
// Modeler: compSwagger,
|
|
Version: "2015-11-01-preview",
|
|
},
|
|
{
|
|
Name: "postgresql",
|
|
Version: "2017-04-30-preview",
|
|
},
|
|
{
|
|
Name: "powerbiembedded",
|
|
Version: "2016-01-29",
|
|
},
|
|
{
|
|
// bug in the go generator
|
|
Name: "recoveryservices",
|
|
// Swagger: "compositeRecoveryServicesClient",
|
|
// Modeler: compSwagger,
|
|
Version: "2016-06-01",
|
|
Swagger: "vaults",
|
|
},
|
|
{
|
|
// When using the readme.md, there is an exception in the modeler
|
|
Name: "recoveryservicesbackup",
|
|
Version: "2016-12-01",
|
|
// Swagger: "readme",
|
|
// Extension: md,
|
|
Swagger: "backupManagement",
|
|
},
|
|
{
|
|
Name: "recoveryservicessiterecovery",
|
|
Version: "2016-08-10",
|
|
Swagger: "service",
|
|
},
|
|
{
|
|
Name: "redis",
|
|
Version: "2016-04-01",
|
|
},
|
|
{
|
|
Name: "relay",
|
|
Version: "2016-07-01",
|
|
},
|
|
{
|
|
Name: "resourcehealth",
|
|
Version: "2015-01-01",
|
|
},
|
|
{
|
|
Name: "resources",
|
|
SubServices: []service{
|
|
{
|
|
Name: "features",
|
|
Version: "2015-12-01",
|
|
},
|
|
{
|
|
Name: "links",
|
|
Version: "2016-09-01",
|
|
},
|
|
{
|
|
Name: "locks",
|
|
Version: "2016-09-01",
|
|
},
|
|
{
|
|
Name: "managedapplications",
|
|
Version: "2016-09-01-preview",
|
|
},
|
|
{
|
|
Name: "policy",
|
|
Version: "2016-12-01",
|
|
},
|
|
{
|
|
Name: "resources",
|
|
Version: "2016-09-01",
|
|
// Version: "2017-05-10",
|
|
},
|
|
{
|
|
Name: "subscriptions",
|
|
Version: "2016-06-01",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "scheduler",
|
|
Version: "2016-03-01",
|
|
},
|
|
{
|
|
Name: "search",
|
|
Version: "2015-08-19",
|
|
},
|
|
{
|
|
Name: "servermanagement",
|
|
Version: "2016-07-01-preview",
|
|
},
|
|
{
|
|
Name: "service-map",
|
|
Version: "2015-11-01-preview",
|
|
Swagger: "arm-service-map",
|
|
},
|
|
{
|
|
Name: "servicebus",
|
|
Version: "2015-08-01",
|
|
},
|
|
{
|
|
Name: "servicefabric",
|
|
Version: "2016-09-01",
|
|
},
|
|
// {
|
|
// Name: "sql",
|
|
// Swagger: "compositeSql",
|
|
// Modeler: compSwagger,
|
|
// },
|
|
{
|
|
Name: "storage",
|
|
Version: "2016-12-01",
|
|
},
|
|
{
|
|
Name: "storageimportexport",
|
|
Version: "2016-11-01",
|
|
},
|
|
{
|
|
Name: "storsimple8000series",
|
|
Version: "2017-06-01",
|
|
Swagger: "storsimple",
|
|
},
|
|
{
|
|
Name: "streamanalytics",
|
|
Swagger: "compositeStreamAnalytics",
|
|
Modeler: compSwagger,
|
|
},
|
|
// {
|
|
// error in the modeler
|
|
// Name: "timeseriesinsights",
|
|
// Version: "2017-02-28-preview",
|
|
// },
|
|
{
|
|
Name: "trafficmanager",
|
|
Version: "2015-11-01",
|
|
},
|
|
{
|
|
Name: "web",
|
|
Swagger: "compositeWebAppClient",
|
|
Modeler: compSwagger,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Plane: "dataplane",
|
|
InputPrefix: "",
|
|
Services: []service{
|
|
// {
|
|
// Name: "batch",
|
|
// Version: "2017-01-01.4.0",
|
|
// Swagger: "BatchService",
|
|
// },
|
|
// {
|
|
// Name: "insights",
|
|
// Swagger: "compositeInsightsClient",
|
|
// Modeler: compSwagger,
|
|
// },
|
|
{
|
|
Name: "keyvault",
|
|
Version: "2016-10-01",
|
|
},
|
|
// {
|
|
// Name: "monitor",
|
|
// Swagger: "compositeMonitorClient",
|
|
// Modeler: compSwagger,
|
|
// },
|
|
// {
|
|
// Name: "search",
|
|
// SubServices: []service{
|
|
// {
|
|
// Name: "searchindex",
|
|
// Version: "2016-09-01",
|
|
// Input: "search",
|
|
// },
|
|
// {
|
|
// Name: "searchservice",
|
|
// Version: "2016-09-01",
|
|
// Input: "search",
|
|
// },
|
|
// },
|
|
// },
|
|
// {
|
|
// Name: "servicefabric",
|
|
// Version: "2016-01-28",
|
|
// },
|
|
},
|
|
},
|
|
{
|
|
Plane: "",
|
|
InputPrefix: "arm-",
|
|
Services: []service{
|
|
{
|
|
Name: "datalake-store",
|
|
SubServices: []service{
|
|
{
|
|
Name: "filesystem",
|
|
Version: "2016-11-01",
|
|
},
|
|
},
|
|
},
|
|
// {
|
|
// Name: "datalake-analytics",
|
|
// SubServices: []service{
|
|
// {
|
|
// Name: "catalog",
|
|
// Version: "2016-11-01",
|
|
// },
|
|
// {
|
|
// Name: "job",
|
|
// Version: "2016-11-01",
|
|
// },
|
|
// },
|
|
// },
|
|
},
|
|
},
|
|
}
|
|
)
|
|
|
|
func main() {
|
|
for _, swaggerGroup := range servicesMapping {
|
|
swg := swaggerGroup
|
|
for _, service := range swg.Services {
|
|
s := service
|
|
initAndAddService(&s, swg.InputPrefix, swg.Plane)
|
|
}
|
|
}
|
|
do.Godo(tasks)
|
|
}
|
|
|
|
func initAndAddService(service *service, inputPrefix, plane string) {
|
|
if service.Swagger == "" {
|
|
service.Swagger = service.Name
|
|
}
|
|
if service.Extension == "" {
|
|
service.Extension = json
|
|
}
|
|
packages := append(service.Packages, service.Name)
|
|
service.TaskName = fmt.Sprintf("%s>%s", plane, strings.Join(packages, ">"))
|
|
service.Fullname = filepath.Join(plane, strings.Join(packages, string(os.PathSeparator)))
|
|
if service.Modeler == compSwagger {
|
|
service.Input = filepath.Join(inputPrefix+strings.Join(packages, string(os.PathSeparator)), service.Swagger)
|
|
} else {
|
|
input := []string{}
|
|
if service.Input == "" {
|
|
input = append(input, inputPrefix+strings.Join(packages, string(os.PathSeparator)))
|
|
} else {
|
|
input = append(input, inputPrefix+service.Input)
|
|
}
|
|
input = append(input, service.Version)
|
|
if service.Extension == json {
|
|
input = append(input, "swagger")
|
|
}
|
|
input = append(input, service.Swagger)
|
|
service.Input = filepath.Join(input...)
|
|
service.Modeler = swagger
|
|
}
|
|
service.Namespace = filepath.Join("github.com", "Azure", "azure-sdk-for-go", service.Fullname)
|
|
service.Output = filepath.Join(gopath, "src", service.Namespace)
|
|
|
|
if service.SubServices != nil {
|
|
for _, subs := range service.SubServices {
|
|
ss := subs
|
|
ss.Packages = append(ss.Packages, service.Name)
|
|
initAndAddService(&ss, inputPrefix, plane)
|
|
}
|
|
} else {
|
|
services = append(services, service)
|
|
deps = append(deps, service.TaskName)
|
|
}
|
|
}
|
|
|
|
func tasks(p *do.Project) {
|
|
p.Task("default", do.S{"setvars", "generate:all", "management"}, nil)
|
|
p.Task("setvars", nil, setVars)
|
|
p.Use("generate", generateTasks)
|
|
p.Use("gofmt", formatTasks)
|
|
p.Use("gobuild", buildTasks)
|
|
p.Use("golint", lintTasks)
|
|
p.Use("govet", vetTasks)
|
|
p.Use("delete", deleteTasks)
|
|
p.Task("management", do.S{"setvars"}, managementVersion)
|
|
p.Task("addVersion", nil, addVersion)
|
|
}
|
|
|
|
func setVars(c *do.Context) {
|
|
if gopath == "" {
|
|
panic("Gopath not set\n")
|
|
}
|
|
|
|
sdkVersion = c.Args.MustString("s", "sdk", "version")
|
|
autorestDir = c.Args.MayString("", "a", "ar", "autorest")
|
|
swaggersDir = c.Args.MayString("C:/", "w", "sw", "swagger")
|
|
testGen = c.Args.MayBool(false, "t", "testgen")
|
|
}
|
|
|
|
func generateTasks(p *do.Project) {
|
|
addTasks(generate, p)
|
|
}
|
|
|
|
func generate(service *service) {
|
|
codegen := "Go"
|
|
if testGen {
|
|
codegen = "Go.TestGen"
|
|
service.Fullname = strings.Join([]string{service.Fullname, testsSubDir}, string(os.PathSeparator))
|
|
service.Output = filepath.Join(service.Output, testsSubDir)
|
|
}
|
|
|
|
fmt.Printf("Generating %s...\n\n", service.Fullname)
|
|
|
|
delete(service)
|
|
|
|
execCommand := "autorest"
|
|
commandArgs := []string{
|
|
"-Input", filepath.Join(swaggersDir, "azure-rest-api-specs", service.Input+"."+string(service.Extension)),
|
|
"-CodeGenerator", codegen,
|
|
"-Header", "MICROSOFT_APACHE",
|
|
"-Namespace", service.Name,
|
|
"-OutputDirectory", service.Output,
|
|
"-Modeler", string(service.Modeler),
|
|
"-PackageVersion", sdkVersion,
|
|
}
|
|
if testGen {
|
|
commandArgs = append([]string{"-LEGACY"}, commandArgs...)
|
|
}
|
|
|
|
// default to the current directory
|
|
workingDir := ""
|
|
|
|
if autorestDir != "" {
|
|
// if an AutoRest directory was specified then assume
|
|
// the caller wants to use a locally-built version.
|
|
execCommand = "gulp"
|
|
commandArgs = append([]string{"autorest"}, commandArgs...)
|
|
workingDir = filepath.Join(autorestDir, "autorest")
|
|
}
|
|
|
|
autorest := exec.Command(execCommand, commandArgs...)
|
|
autorest.Dir = workingDir
|
|
|
|
if _, err := runner(autorest); err != nil {
|
|
panic(fmt.Errorf("Autorest error: %s", err))
|
|
}
|
|
|
|
format(service)
|
|
build(service)
|
|
lint(service)
|
|
vet(service)
|
|
}
|
|
|
|
func deleteTasks(p *do.Project) {
|
|
addTasks(format, p)
|
|
}
|
|
|
|
func delete(service *service) {
|
|
fmt.Printf("Deleting %s...\n\n", service.Fullname)
|
|
err := os.RemoveAll(service.Output)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("Error deleting %s : %s\n", service.Output, err))
|
|
}
|
|
}
|
|
|
|
func formatTasks(p *do.Project) {
|
|
addTasks(format, p)
|
|
}
|
|
|
|
func format(service *service) {
|
|
fmt.Printf("Formatting %s...\n\n", service.Fullname)
|
|
gofmt := exec.Command("gofmt", "-w", service.Output)
|
|
_, err := runner(gofmt)
|
|
if err != nil {
|
|
panic(fmt.Errorf("gofmt error: %s", err))
|
|
}
|
|
}
|
|
|
|
func buildTasks(p *do.Project) {
|
|
addTasks(build, p)
|
|
}
|
|
|
|
func build(service *service) {
|
|
fmt.Printf("Building %s...\n\n", service.Fullname)
|
|
gobuild := exec.Command("go", "build", service.Namespace)
|
|
_, err := runner(gobuild)
|
|
if err != nil {
|
|
panic(fmt.Errorf("go build error: %s", err))
|
|
}
|
|
}
|
|
|
|
func lintTasks(p *do.Project) {
|
|
addTasks(lint, p)
|
|
}
|
|
|
|
func lint(service *service) {
|
|
fmt.Printf("Linting %s...\n\n", service.Fullname)
|
|
golint := exec.Command(filepath.Join(gopath, "bin", "golint"), service.Namespace)
|
|
_, err := runner(golint)
|
|
if err != nil {
|
|
panic(fmt.Errorf("golint error: %s", err))
|
|
}
|
|
}
|
|
|
|
func vetTasks(p *do.Project) {
|
|
addTasks(vet, p)
|
|
}
|
|
|
|
func vet(service *service) {
|
|
fmt.Printf("Vetting %s...\n\n", service.Fullname)
|
|
govet := exec.Command("go", "vet", service.Namespace)
|
|
_, err := runner(govet)
|
|
if err != nil {
|
|
panic(fmt.Errorf("go vet error: %s", err))
|
|
}
|
|
}
|
|
|
|
func addVersion(c *do.Context) {
|
|
gitStatus := exec.Command("git", "status", "-s")
|
|
out, err := runner(gitStatus)
|
|
if err != nil {
|
|
panic(fmt.Errorf("Git error: %s", err))
|
|
}
|
|
files := strings.Split(out, "\n")
|
|
|
|
for _, f := range files {
|
|
if strings.HasPrefix(f, " M ") && strings.HasSuffix(f, "version.go") {
|
|
gitAdd := exec.Command("git", "add", f[3:])
|
|
_, err := runner(gitAdd)
|
|
if err != nil {
|
|
panic(fmt.Errorf("Git error: %s", err))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func managementVersion(c *do.Context) {
|
|
version("management")
|
|
}
|
|
|
|
func version(packageName string) {
|
|
versionFile := filepath.Join(packageName, "version.go")
|
|
os.Remove(versionFile)
|
|
template := `package %s
|
|
|
|
var (
|
|
sdkVersion = "%s"
|
|
)
|
|
`
|
|
data := []byte(fmt.Sprintf(template, packageName, sdkVersion))
|
|
ioutil.WriteFile(versionFile, data, 0644)
|
|
}
|
|
|
|
func addTasks(fn func(*service), p *do.Project) {
|
|
for _, service := range services {
|
|
s := service
|
|
p.Task(s.TaskName, nil, func(c *do.Context) {
|
|
fn(s)
|
|
})
|
|
}
|
|
p.Task("all", deps, nil)
|
|
}
|
|
|
|
func runner(cmd *exec.Cmd) (string, error) {
|
|
var stdout, stderr bytes.Buffer
|
|
cmd.Stdout, cmd.Stderr = &stdout, &stderr
|
|
err := cmd.Run()
|
|
if stdout.Len() > 0 {
|
|
fmt.Println(stdout.String())
|
|
}
|
|
if stderr.Len() > 0 {
|
|
fmt.Println(stderr.String())
|
|
}
|
|
return stdout.String(), err
|
|
}
|