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
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
package automation
import (
"fmt"
"log"
"os"
"path/filepath"
"strings"
"github.com/Azure/azure-sdk-for-go/eng/tools/generator/autorest"
"github.com/Azure/azure-sdk-for-go/eng/tools/generator/autorest/model"
"github.com/Azure/azure-sdk-for-go/eng/tools/generator/cmd/automation/validate"
"github.com/Azure/azure-sdk-for-go/eng/tools/internal/exports"
"github.com/Azure/azure-sdk-for-go/eng/tools/internal/utils"
)
type generateContext struct {
sdkRoot string
specRoot string
commitHash string
repoContent map[string]exports.Content
existingPackages packagesForReadme
defaultOptions model.Options
additionalOptions []model.Option
}
func (ctx generateContext) SDKRoot() string {
return ctx.sdkRoot
}
func (ctx generateContext) SpecRoot() string {
return ctx.specRoot
}
func (ctx generateContext) RepoContent() map[string]exports.Content {
return ctx.repoContent
}
var _ autorest.GenerateContext = (*generateContext)(nil)
func (ctx generateContext) generate(readme string) ([]autorest.GenerateResult, []error) {
absReadme := filepath.Join(ctx.specRoot, readme)
absReadmeGo := filepath.Join(filepath.Dir(absReadme), "readme.go.md")
log.Printf("Reading tags from readme.go.md '%s'...", absReadmeGo)
reader, err := os.Open(absReadmeGo)
if err != nil {
return nil, []error{
fmt.Errorf("cannot read from readme.go.md: %+v", err),
}
}
log.Printf("Parsing tags from readme.go.md '%s'...", absReadmeGo)
tags, err := autorest.ReadBatchTags(reader)
if err != nil {
return nil, []error{
fmt.Errorf("cannot read batch tags in readme.go.md '%s': %+v", absReadmeGo, err),
}
}
log.Printf("Cleaning all the packages from readme '%s'...", readme)
removedPackages, err := clean(ctx.sdkRoot, ctx.existingPackages)
if err != nil {
return nil, []error{
fmt.Errorf("cannot clean packages from readme '%s': %+v", readme, err),
}
}
log.Printf("Generating the following tags: \n[%s]", strings.Join(tags, ", "))
var packageResults []autorest.GenerateResult
var errors []error
for _, tag := range tags {
result, err := ctx.generateForTag(readme, tag)
if err != nil {
errors = append(errors, err)
continue
}
packageResults = append(packageResults, *result)
}
// also add the removed packages in the results if it is not regenerated
for _, removedPackage := range removedPackages {
if !contains(packageResults, removedPackage.packageName) {
// this package is not regenerated, therefore it is removed
packageResults = append(packageResults, autorest.GenerateResult{
Package: autorest.ChangelogResult{
Tag: removedPackage.Tag,
PackageName: removedPackage.packageName,
PackageFullPath: utils.NormalizePath(filepath.Join(ctx.sdkRoot, removedPackage.packageName)),
Changelog: model.Changelog{
RemovedPackage: true,
},
},
})
}
}
return packageResults, errors
}
func (ctx generateContext) generateForTag(readme, tag string) (*autorest.GenerateResult, error) {
var options model.Options
// Get the proper options to use depending on whether this tag has been already generated in the SDK or not
if metadata, ok := ctx.existingPackages[tag]; ok {
// this tag has been generated, use the existing parameters in its metadata
additionalOptions, err := model.ParseOptions(strings.Split(metadata.AdditionalProperties.AdditionalOptions, " "))
if err != nil {
return nil, fmt.Errorf("cannot parse existing defaultOptions for readme '%s'/tag '%s': %+v", readme, tag, err)
}
options = ctx.defaultOptions.MergeOptions(additionalOptions.Arguments()...)
} else {
// this is a new tag
options = ctx.defaultOptions.MergeOptions(ctx.additionalOptions...)
}
input := autorest.GenerateInput{
Readme: readme,
Tag: tag,
CommitHash: ctx.commitHash,
Options: options,
}
validateCtx := validate.MetadataValidateContext{
Readme: readme,
SDKRoot: ctx.sdkRoot,
}
return autorest.GeneratePackage(ctx, input, autorest.GenerateOptions{
Stderr: os.Stderr,
Stdout: os.Stdout,
AutoRestLogPrefix: "[AUTOREST] ",
ChangelogTitle: "Unreleased",
Validators: []autorest.MetadataValidateFunc{
validateCtx.PreviewCheck,
validateCtx.MgmtCheck,
validateCtx.NamespaceCheck,
},
})
}
|
