blob: 40c4e3201f54302c2562b48d6f78cee2f622ddec [file] [log] [blame]
// Copyright 2019 The LUCI Authors.
//
// 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.
package exe
import (
"bytes"
"encoding/json"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
structpb "github.com/golang/protobuf/ptypes/struct"
"go.chromium.org/luci/common/errors"
)
// ParseProperties interprets a protobuf 'struct' as structured Go data.
//
// `outputs` is a mapping of a property name to an output structure. An output
// structure may be one of two things:
//
// * a non-nil proto.Message. The data in this field will be interpreted as
// JSONPB and Unmarshaled into the proto.Message.
// * a valid "encoding/json" unmarshal target. The data in this field will be
// unmarshaled into with the stdlib "encoding/json" package.
//
// This function will scan the props (usually `build.Input.Properties`) and
// unmarshal them as appropriate into the outputs.
//
// Example:
//
// myProto := &myprotos.Message{}
// myStruct := &MyStruct{}
// err := ParseProperties(build.Input.Properties, map[string]interface{}{
// "proto": myProto, "$namespaced/struct": myStruct})
// // handle err :)
// fmt.Println("Got:", myProto.Field)
// fmt.Println("Got:", myStruct.Field)
func ParseProperties(props *structpb.Struct, outputs map[string]interface{}) error {
ret := errors.NewLazyMultiError(len(outputs))
idx := -1
for field, output := range outputs {
idx++
val := props.Fields[field]
if val == nil {
continue
}
var jsonBuf bytes.Buffer
if err := (&jsonpb.Marshaler{}).Marshal(&jsonBuf, val); err != nil {
ret.Assign(idx, errors.Annotate(err, "marshaling %q", field).Err())
continue
}
var err error
switch x := output.(type) {
case proto.Message:
err = jsonpb.Unmarshal(&jsonBuf, x)
default:
err = json.NewDecoder(&jsonBuf).Decode(x)
}
ret.Assign(idx, errors.Annotate(err, "unmarshalling %q", field).Err())
}
return ret.Get()
}
// WriteProperties updates a protobuf 'struct' with structured Go data.
//
// `inputs` is a mapping of a property name to an input structure. An input
// structure may be one of two things:
//
// * a non-nil proto.Message. The data in this field will be interpreted as
// JSONPB and Unmarshaled into the proto.Message.
// * a valid "json/encoding" marshal source. The data in this field will be
// interpreted as json and marshaled with the stdlib "encoding/json" package.
//
// This function will scan the inputs and marshal them as appropriate into
// `props` (usually `build.Output.Properties`).
//
// Example:
//
// myProto := &myprotos.Message{Field: "something"}
// myStruct := &MyStruct{Field: 100}
// err := WriteProperties(build.Output.Properties, map[string]interface{}{
// "proto": myProto, "$namespaced/struct": myStruct})
// // handle err :)
func WriteProperties(props *structpb.Struct, inputs map[string]interface{}) error {
if props.Fields == nil {
props.Fields = make(map[string]*structpb.Value, len(inputs))
}
ret := errors.NewLazyMultiError(len(inputs))
idx := -1
for field, input := range inputs {
idx++
var buf bytes.Buffer
var err error
fieldVal := props.Fields[field]
if fieldVal == nil {
fieldVal = &structpb.Value{}
props.Fields[field] = fieldVal
}
switch x := input.(type) {
case proto.Message:
err = (&jsonpb.Marshaler{OrigName: true}).Marshal(&buf, x)
default:
var data []byte
data, err = json.Marshal(x)
buf.Write(data)
}
if err != nil {
ret.Assign(idx, errors.Annotate(err, "marshaling %q", field).Err())
continue
}
ret.Assign(idx, errors.Annotate(
jsonpb.Unmarshal(&buf, fieldVal), "unmarshalling %q", field,
).Err())
}
return ret.Get()
}