hunk.code_window:       - elasticsearch
         - prometheus
         - grafana
       command: postgres:5432 minio:9000 inbucket:10080 openldap:389 elasticsearch:9200 prometheus:9090 grafana:3000
       networks:
         default:
   networks:
  
hunk.labels: keep keep keep replace keep keep keep keep keep
hunk.after_edit:     command: postgres:5432 minio:9000 inbucket:9001 openldap:389 elasticsearch:9200 prometheus:9090 grafana:3000
  
hunk.file_path: build/gitlab-dc.postgres.yml
hunk.type: replace
file: // Copyright 2019 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package proto
  
  import (
  	"fmt"
  
  	"google.golang.org/protobuf/reflect/protoreflect"
  	"google.golang.org/protobuf/runtime/protoiface"
  )
  
  // Merge merges src into dst, which must be a message with the same descriptor.
  //
  // Populated scalar fields in src are copied to dst, while populated
  // singular messages in src are merged into dst by recursively calling Merge.
  // The elements of every list field in src is appended to the corresponded
  // list fields in dst. The entries of every map field in src is copied into
  // the corresponding map field in dst, possibly replacing existing entries.
  // The unknown fields of src are appended to the unknown fields of dst.
  //
  // It is semantically equivalent to unmarshaling the encoded form of src
  // into dst with the UnmarshalOptions.Merge option specified.
  func Merge(dst, src Message) {
  	// TODO: Should nil src be treated as semantically equivalent to a
  	// untyped, read-only, empty message? What about a nil dst?
  
  	dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
  	if dstMsg.Descriptor() != srcMsg.Descriptor() {
  		if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
  			panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
  		}
  		panic("descriptor mismatch")
  	}
  	mergeOptions{}.mergeMessage(dstMsg, srcMsg)
  }
  
  // Clone returns a deep copy of m.
  // If the top-level message is invalid, it returns an invalid message as well.
  func Clone(m Message) Message {
  	// NOTE: Most usages of Clone assume the following properties:
  	//	t := reflect.TypeOf(m)
  	//	t == reflect.TypeOf(m.ProtoReflect().New().Interface())
  	//	t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
  	//
  	// Embedding protobuf messages breaks this since the parent type will have
  	// a forwarded ProtoReflect method, but the Interface method will return
  	// the underlying embedded message type.
  	if m == nil {
  		return nil
  	}
  	src := m.ProtoReflect()
  	if !src.IsValid() {
  		return src.Type().Zero().Interface()
  	}
  	dst := src.New()
  	mergeOptions{}.mergeMessage(dst, src)
  	return dst.Interface()
  }
  
  // mergeOptions provides a namespace for merge functions, and can be
  // exported in the future if we add user-visible merge options.
  type mergeOptions struct{}
  
  func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
  	methods := protoMethods(dst)
  	if methods != nil && methods.Merge != nil {
  		in := protoiface.MergeInput{
  			Destination: dst,
  			Source:      src,
  		}
  		out := methods.Merge(in)
  		if out.Flags&protoiface.MergeComplete != 0 {
  			return
  		}
  	}
  
  	if !dst.IsValid() {
  		panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
  	}
  
  	src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
  		switch {
  		case fd.IsList():
  			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
  		case fd.IsMap():
  			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
  		case fd.Message() != nil:
  			o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
  		case fd.Kind() == protoreflect.BytesKind:
  			dst.Set(fd, o.cloneBytes(v))
  		default:
  			dst.Set(fd, v)
  		}
  		return true
  	})
  
  	if len(src.GetUnknown()) > 0 {
  		dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
  	}
  }
  
  func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
  	// Merge semantics appends to the end of the existing list.
  	for i, n := 0, src.Len(); i < n; i++ {
  		switch v := src.Get(i); {
  		case fd.Message() != nil:
  			dstv := dst.NewElement()
  			o.mergeMessage(dstv.Message(), v.Message())
  			dst.Append(dstv)
  		case fd.Kind() == protoreflect.BytesKind:
  			dst.Append(o.cloneBytes(v))
  		default:
  			dst.Append(v)
  		}
  	}
  }
  
  func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
  	// Merge semantics replaces, rather than merges into existing entries.
  	src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
  		switch {
  		case fd.Message() != nil:
  			dstv := dst.NewValue()
  			o.mergeMessage(dstv.Message(), v.Message())
  			dst.Set(k, dstv)
  		case fd.Kind() == protoreflect.BytesKind:
  			dst.Set(k, o.cloneBytes(v))
  		default:
  			dst.Set(k, v)
  		}
  		return true
  	})
  }
  
  func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
  	return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
  }
  