-
Notifications
You must be signed in to change notification settings - Fork 8
/
loader.go
126 lines (113 loc) · 3 KB
/
loader.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
package azure
import (
"embed"
"encoding/json"
"fmt"
"log"
"sort"
"strings"
"sync"
"github.com/Azure/azapi-lsp/internal/azure/types"
)
var schema *Schema
//go:embed generated
var StaticFiles embed.FS
var mutex sync.Mutex
func GetAzureSchema() *Schema {
mutex.Lock()
defer mutex.Unlock()
if schema == nil {
data, err := StaticFiles.ReadFile("generated/index.json")
if err != nil {
log.Printf("[ERROR] failed to load schema index: %+v", err)
return nil
}
err = json.Unmarshal(data, &schema)
if err != nil {
log.Printf("[ERROR] failed to unmarshal schema index: %+v", err)
return nil
}
}
// preload the first definition
for _, resource := range schema.Resources {
if len(resource.Definitions) > 0 {
_, _ = resource.Definitions[0].GetDefinition()
}
}
return schema
}
func GetApiVersions(resourceType string) []string {
azureSchema := GetAzureSchema()
if azureSchema == nil {
return []string{}
}
res := make([]string, 0)
for key, value := range azureSchema.Resources {
if strings.EqualFold(key, resourceType) {
for _, v := range value.Definitions {
res = append(res, v.ApiVersion)
}
}
}
sort.Strings(res)
return res
}
func GetResourceDefinitionByResourceType(azureResourceType string) (*types.ResourceType, error) {
parts := strings.Split(azureResourceType, "@")
if len(parts) != 2 {
return nil, fmt.Errorf("input %s is invalid", azureResourceType)
}
return GetResourceDefinition(parts[0], parts[1])
}
func GetResourceDefinition(resourceType, apiVersion string) (*types.ResourceType, error) {
azureSchema := GetAzureSchema()
if azureSchema == nil {
return nil, fmt.Errorf("failed to load azure schema index")
}
for key, value := range azureSchema.Resources {
if strings.EqualFold(key, resourceType) {
for _, v := range value.Definitions {
if v.ApiVersion == apiVersion {
return v.GetDefinition()
}
}
}
}
return nil, fmt.Errorf("failed to find resource type %s api-version %s in azure schema index", resourceType, apiVersion)
}
func ListResourceFunctions(resourceType, apiVersion string) ([]FunctionDefinition, error) {
res := make([]FunctionDefinition, 0)
azureSchema := GetAzureSchema()
if azureSchema == nil {
return nil, fmt.Errorf("failed to load azure schema index")
}
for key, value := range azureSchema.Functions {
if strings.EqualFold(key, resourceType) {
for _, v := range value.Definitions {
if v.ApiVersion == apiVersion {
res = append(res, v)
}
}
}
}
return res, nil
}
func GetResourceFunction(resourceType, apiVersion, name string) (*types.ResourceFunctionType, error) {
azureSchema := GetAzureSchema()
if azureSchema == nil {
return nil, fmt.Errorf("failed to load azure schema index")
}
for key, value := range azureSchema.Functions {
if strings.EqualFold(key, resourceType) {
for _, v := range value.Definitions {
if v.ApiVersion == apiVersion {
def, err := v.GetDefinition()
if err == nil && def.Name == name {
return def, nil
}
}
}
}
}
return nil, nil
}