mirror of
https://github.com/kubernetes-sigs/prometheus-adapter.git
synced 2026-04-06 17:57:51 +00:00
393 lines
11 KiB
Go
393 lines
11 KiB
Go
// Copyright 2017 Google Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//go:generate ./COMPILE-PROTOS.sh
|
|
|
|
// Gnostic is a tool for building better REST APIs through knowledge.
|
|
//
|
|
// Gnostic reads declarative descriptions of REST APIs that conform
|
|
// to the OpenAPI Specification, reports errors, resolves internal
|
|
// dependencies, and puts the results in a binary form that can
|
|
// be used in any language that is supported by the Protocol Buffer
|
|
// tools.
|
|
//
|
|
// Gnostic models are validated and typed. This allows API tool
|
|
// developers to focus on their product and not worry about input
|
|
// validation and type checking.
|
|
//
|
|
// Gnostic calls plugins that implement a variety of API implementation
|
|
// and support features including generation of client and server
|
|
// support code.
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
"github.com/googleapis/gnostic/OpenAPIv2"
|
|
"github.com/googleapis/gnostic/OpenAPIv3"
|
|
"github.com/googleapis/gnostic/compiler"
|
|
plugins "github.com/googleapis/gnostic/plugins"
|
|
)
|
|
|
|
const ( // OpenAPI Version
|
|
OpenAPIvUnknown = 0
|
|
OpenAPIv2 = 2
|
|
OpenAPIv3 = 3
|
|
)
|
|
|
|
func openapi_version(info interface{}) int {
|
|
m, ok := compiler.UnpackMap(info)
|
|
if !ok {
|
|
return OpenAPIvUnknown
|
|
}
|
|
swagger, ok := compiler.MapValueForKey(m, "swagger").(string)
|
|
if ok && swagger == "2.0" {
|
|
return OpenAPIv2
|
|
}
|
|
openapi, ok := compiler.MapValueForKey(m, "openapi").(string)
|
|
if ok && openapi == "3.0" {
|
|
return OpenAPIv3
|
|
}
|
|
return OpenAPIvUnknown
|
|
}
|
|
|
|
type PluginCall struct {
|
|
Name string
|
|
Invocation string
|
|
}
|
|
|
|
func (pluginCall *PluginCall) perform(document proto.Message, openapi_version int, sourceName string) error {
|
|
if pluginCall.Name != "" {
|
|
request := &plugins.Request{}
|
|
|
|
// Infer the name of the executable by adding the prefix.
|
|
executableName := "gnostic_" + pluginCall.Name
|
|
|
|
// validate invocation string with regular expression
|
|
invocation := pluginCall.Invocation
|
|
|
|
//
|
|
// Plugin invocations must consist of
|
|
// zero or more comma-separated key=value pairs followed by a path.
|
|
// If pairs are present, a colon separates them from the path.
|
|
// Keys and values must be alphanumeric strings and may contain
|
|
// dashes, underscores, periods, or forward slashes.
|
|
// A path can contain any characters other than the separators ',', ':', and '='.
|
|
//
|
|
invocation_regex := regexp.MustCompile(`^([\w-_\/\.]+=[\w-_\/\.]+(,[\w-_\/\.]+=[\w-_\/\.]+)*:)?[^,:=]+$`)
|
|
if !invocation_regex.Match([]byte(pluginCall.Invocation)) {
|
|
return errors.New(fmt.Sprintf("Invalid invocation of %s: %s", executableName, invocation))
|
|
}
|
|
|
|
invocationParts := strings.Split(pluginCall.Invocation, ":")
|
|
var outputLocation string
|
|
switch len(invocationParts) {
|
|
case 1:
|
|
outputLocation = invocationParts[0]
|
|
case 2:
|
|
parameters := strings.Split(invocationParts[0], ",")
|
|
for _, keyvalue := range parameters {
|
|
pair := strings.Split(keyvalue, "=")
|
|
if len(pair) == 2 {
|
|
request.Parameters = append(request.Parameters, &plugins.Parameter{Name: pair[0], Value: pair[1]})
|
|
}
|
|
}
|
|
outputLocation = invocationParts[1]
|
|
default:
|
|
// badly-formed request
|
|
outputLocation = invocationParts[len(invocationParts)-1]
|
|
}
|
|
|
|
version := &plugins.Version{}
|
|
version.Major = 0
|
|
version.Minor = 1
|
|
version.Patch = 0
|
|
request.CompilerVersion = version
|
|
|
|
request.OutputPath = outputLocation
|
|
|
|
wrapper := &plugins.Wrapper{}
|
|
wrapper.Name = sourceName
|
|
switch openapi_version {
|
|
case OpenAPIv2:
|
|
wrapper.Version = "v2"
|
|
case OpenAPIv3:
|
|
wrapper.Version = "v3"
|
|
default:
|
|
wrapper.Version = "unknown"
|
|
}
|
|
protoBytes, _ := proto.Marshal(document)
|
|
wrapper.Value = protoBytes
|
|
request.Wrapper = wrapper
|
|
requestBytes, _ := proto.Marshal(request)
|
|
|
|
cmd := exec.Command(executableName)
|
|
cmd.Stdin = bytes.NewReader(requestBytes)
|
|
cmd.Stderr = os.Stderr
|
|
output, err := cmd.Output()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
response := &plugins.Response{}
|
|
err = proto.Unmarshal(output, response)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if response.Errors != nil {
|
|
return errors.New(fmt.Sprintf("Plugin error: %+v", response.Errors))
|
|
}
|
|
|
|
// write files to the specified directory
|
|
var writer io.Writer
|
|
if outputLocation == "!" {
|
|
// write nothing
|
|
} else if outputLocation == "-" {
|
|
writer = os.Stdout
|
|
for _, file := range response.Files {
|
|
writer.Write([]byte("\n\n" + file.Name + " -------------------- \n"))
|
|
writer.Write(file.Data)
|
|
}
|
|
} else if isFile(outputLocation) {
|
|
return errors.New(fmt.Sprintf("Error, unable to overwrite %s\n", outputLocation))
|
|
} else {
|
|
if !isDirectory(outputLocation) {
|
|
os.Mkdir(outputLocation, 0755)
|
|
}
|
|
for _, file := range response.Files {
|
|
p := outputLocation + "/" + file.Name
|
|
dir := path.Dir(p)
|
|
os.MkdirAll(dir, 0755)
|
|
f, _ := os.Create(p)
|
|
defer f.Close()
|
|
f.Write(file.Data)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isFile(path string) bool {
|
|
fileInfo, err := os.Stat(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return !fileInfo.IsDir()
|
|
}
|
|
|
|
func isDirectory(path string) bool {
|
|
fileInfo, err := os.Stat(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return fileInfo.IsDir()
|
|
}
|
|
|
|
func writeFile(name string, bytes []byte, source string, extension string) {
|
|
var writer io.Writer
|
|
if name == "!" {
|
|
return
|
|
} else if name == "-" {
|
|
writer = os.Stdout
|
|
} else if name == "=" {
|
|
writer = os.Stderr
|
|
} else if isDirectory(name) {
|
|
base := filepath.Base(source)
|
|
// remove the original source extension
|
|
base = base[0 : len(base)-len(filepath.Ext(base))]
|
|
// build the path that puts the result in the passed-in directory
|
|
filename := name + "/" + base + "." + extension
|
|
file, _ := os.Create(filename)
|
|
defer file.Close()
|
|
writer = file
|
|
} else {
|
|
file, _ := os.Create(name)
|
|
defer file.Close()
|
|
writer = file
|
|
}
|
|
writer.Write(bytes)
|
|
if name == "-" || name == "=" {
|
|
writer.Write([]byte("\n"))
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
usage := `
|
|
Usage: gnostic OPENAPI_SOURCE [OPTIONS]
|
|
OPENAPI_SOURCE is the filename or URL of an OpenAPI description to read.
|
|
Options:
|
|
--pb_out=PATH Write a binary proto to the specified location.
|
|
--json_out=PATH Write a json proto to the specified location.
|
|
--text_out=PATH Write a text proto to the specified location.
|
|
--errors_out=PATH Write compilation errors to the specified location.
|
|
--PLUGIN_out=PATH Run the plugin named gnostic_PLUGIN and write results
|
|
to the specified location.
|
|
--resolve_refs Explicitly resolve $ref references.
|
|
This could have problems with recursive definitions.
|
|
--extension=NAME Run the specified gnostic extension to process
|
|
extensions found in OpenAPI descriptions.
|
|
`
|
|
// default values for all options
|
|
sourceName := ""
|
|
binaryProtoPath := ""
|
|
jsonProtoPath := ""
|
|
textProtoPath := ""
|
|
errorPath := ""
|
|
pluginCalls := make([]*PluginCall, 0)
|
|
resolveReferences := false
|
|
extensionHandlers := make([]compiler.ExtensionHandler, 0)
|
|
|
|
// arg processing matches patterns of the form "--PLUGIN_out=PATH"
|
|
plugin_regex := regexp.MustCompile("--(.+)_out=(.+)")
|
|
|
|
// arg processing matches patterns of the form "--extension=GENERATOR_NAME"
|
|
extensionHandler_regex, err := regexp.Compile("--extension=(.+)")
|
|
defaultPrefixForExtensions := "openapi_extensions_"
|
|
|
|
for i, arg := range os.Args {
|
|
if i == 0 {
|
|
continue // skip the tool name
|
|
}
|
|
var m [][]byte
|
|
if m = plugin_regex.FindSubmatch([]byte(arg)); m != nil {
|
|
pluginName := string(m[1])
|
|
invocation := string(m[2])
|
|
switch pluginName {
|
|
case "pb":
|
|
binaryProtoPath = invocation
|
|
case "json":
|
|
jsonProtoPath = invocation
|
|
case "text":
|
|
textProtoPath = invocation
|
|
case "errors":
|
|
errorPath = invocation
|
|
default:
|
|
pluginCall := &PluginCall{Name: pluginName, Invocation: invocation}
|
|
pluginCalls = append(pluginCalls, pluginCall)
|
|
}
|
|
} else if m = extensionHandler_regex.FindSubmatch([]byte(arg)); m != nil {
|
|
extensionHandlers = append(extensionHandlers, compiler.ExtensionHandler{Name: defaultPrefixForExtensions + string(m[1])})
|
|
} else if arg == "--resolve_refs" {
|
|
resolveReferences = true
|
|
} else if arg[0] == '-' {
|
|
fmt.Fprintf(os.Stderr, "Unknown option: %s.\n%s\n", arg, usage)
|
|
os.Exit(-1)
|
|
} else {
|
|
sourceName = arg
|
|
}
|
|
}
|
|
|
|
if binaryProtoPath == "" &&
|
|
jsonProtoPath == "" &&
|
|
textProtoPath == "" &&
|
|
errorPath == "" &&
|
|
len(pluginCalls) == 0 {
|
|
fmt.Fprintf(os.Stderr, "Missing output directives.\n%s\n", usage)
|
|
os.Exit(-1)
|
|
}
|
|
|
|
if sourceName == "" {
|
|
fmt.Fprintf(os.Stderr, "No input specified.\n%s\n", usage)
|
|
os.Exit(-1)
|
|
}
|
|
|
|
errorPrefix := "Errors reading " + sourceName + "\n"
|
|
|
|
// If we get here and the error output is unspecified, write errors to stderr.
|
|
if errorPath == "" {
|
|
errorPath = "="
|
|
}
|
|
|
|
// Read the OpenAPI source.
|
|
info, err := compiler.ReadInfoForFile(sourceName)
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
os.Exit(-1)
|
|
}
|
|
|
|
// Determine the OpenAPI version.
|
|
openapi_version := openapi_version(info)
|
|
if openapi_version == OpenAPIvUnknown {
|
|
fmt.Fprintf(os.Stderr, "Unknown OpenAPI Version\n")
|
|
os.Exit(-1)
|
|
}
|
|
|
|
var message proto.Message
|
|
if openapi_version == OpenAPIv2 {
|
|
document, err := openapi_v2.NewDocument(info, compiler.NewContextWithExtensions("$root", nil, &extensionHandlers))
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
os.Exit(-1)
|
|
}
|
|
// optionally resolve internal references
|
|
if resolveReferences {
|
|
_, err = document.ResolveReferences(sourceName)
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
os.Exit(-1)
|
|
}
|
|
}
|
|
message = document
|
|
} else if openapi_version == OpenAPIv3 {
|
|
document, err := openapi_v3.NewDocument(info, compiler.NewContextWithExtensions("$root", nil, &extensionHandlers))
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
os.Exit(-1)
|
|
}
|
|
// optionally resolve internal references
|
|
if resolveReferences {
|
|
_, err = document.ResolveReferences(sourceName)
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
os.Exit(-1)
|
|
}
|
|
}
|
|
message = document
|
|
}
|
|
|
|
// perform all specified actions
|
|
if binaryProtoPath != "" {
|
|
// write proto in binary format
|
|
protoBytes, _ := proto.Marshal(message)
|
|
writeFile(binaryProtoPath, protoBytes, sourceName, "pb")
|
|
}
|
|
if jsonProtoPath != "" {
|
|
// write proto in json format
|
|
jsonBytes, _ := json.Marshal(message)
|
|
writeFile(jsonProtoPath, jsonBytes, sourceName, "json")
|
|
}
|
|
if textProtoPath != "" {
|
|
// write proto in text format
|
|
bytes := []byte(proto.MarshalTextString(message))
|
|
writeFile(textProtoPath, bytes, sourceName, "text")
|
|
}
|
|
for _, pluginCall := range pluginCalls {
|
|
err = pluginCall.perform(message, openapi_version, sourceName)
|
|
if err != nil {
|
|
writeFile(errorPath, []byte(errorPrefix+err.Error()), sourceName, "errors")
|
|
defer os.Exit(-1)
|
|
}
|
|
}
|
|
}
|