hunk.code_window: type BaseMarketplacePlugin struct {
   	HomepageURL     string `json:"homepage_url"`
   	IconData        string `json:"icon_data"`
   	DownloadURL     string `json:"download_url"`
   	ReleaseNotesURL string `json:"release_notes_url"`
   	// Signature represents a signature of a plugin saved in base64 encoding.
   	Signature string    `json:"signature"`
   	Manifest  *Manifest `json:"manifest"`
   }
  
hunk.labels: keep replace replace replace replace replace replace replace keep keep
hunk.after_edit: 	HomepageURL     string             `json:"homepage_url"`
   	IconData        string             `json:"icon_data"`
   	DownloadURL     string             `json:"download_url"`
   	ReleaseNotesURL string             `json:"release_notes_url"`
   	Labels          []MarketplaceLabel `json:"labels"`
   	Signature       string             `json:"signature"` // Signature represents a signature of a plugin saved in base64 encoding.
   	Manifest        *Manifest          `json:"manifest"`
  
hunk.file_path: model/marketplace_plugin.go
hunk.type: replace
file: // Copyright 2018 The Prometheus 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 procfs
  
  import (
  	"bufio"
  	"errors"
  	"fmt"
  	"io"
  	"os"
  	"strconv"
  	"strings"
  )
  
  // For the proc file format details,
  // see https://elixir.bootlin.com/linux/v4.17/source/net/unix/af_unix.c#L2815
  // and https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/net.h#L48.
  
  const (
  	netUnixKernelPtrIdx = iota
  	netUnixRefCountIdx
  	_
  	netUnixFlagsIdx
  	netUnixTypeIdx
  	netUnixStateIdx
  	netUnixInodeIdx
  
  	// Inode and Path are optional.
  	netUnixStaticFieldsCnt = 6
  )
  
  const (
  	netUnixTypeStream    = 1
  	netUnixTypeDgram     = 2
  	netUnixTypeSeqpacket = 5
  
  	netUnixFlagListen = 1 << 16
  
  	netUnixStateUnconnected  = 1
  	netUnixStateConnecting   = 2
  	netUnixStateConnected    = 3
  	netUnixStateDisconnected = 4
  )
  
  var errInvalidKernelPtrFmt = errors.New("Invalid Num(the kernel table slot number) format")
  
  // NetUnixType is the type of the type field.
  type NetUnixType uint64
  
  // NetUnixFlags is the type of the flags field.
  type NetUnixFlags uint64
  
  // NetUnixState is the type of the state field.
  type NetUnixState uint64
  
  // NetUnixLine represents a line of /proc/net/unix.
  type NetUnixLine struct {
  	KernelPtr string
  	RefCount  uint64
  	Protocol  uint64
  	Flags     NetUnixFlags
  	Type      NetUnixType
  	State     NetUnixState
  	Inode     uint64
  	Path      string
  }
  
  // NetUnix holds the data read from /proc/net/unix.
  type NetUnix struct {
  	Rows []*NetUnixLine
  }
  
  // NewNetUnix returns data read from /proc/net/unix.
  func NewNetUnix() (*NetUnix, error) {
  	fs, err := NewFS(DefaultMountPoint)
  	if err != nil {
  		return nil, err
  	}
  
  	return fs.NewNetUnix()
  }
  
  // NewNetUnix returns data read from /proc/net/unix.
  func (fs FS) NewNetUnix() (*NetUnix, error) {
  	return NewNetUnixByPath(fs.proc.Path("net/unix"))
  }
  
  // NewNetUnixByPath returns data read from /proc/net/unix by file path.
  // It might returns an error with partial parsed data, if an error occur after some data parsed.
  func NewNetUnixByPath(path string) (*NetUnix, error) {
  	f, err := os.Open(path)
  	if err != nil {
  		return nil, err
  	}
  	defer f.Close()
  	return NewNetUnixByReader(f)
  }
  
  // NewNetUnixByReader returns data read from /proc/net/unix by a reader.
  // It might returns an error with partial parsed data, if an error occur after some data parsed.
  func NewNetUnixByReader(reader io.Reader) (*NetUnix, error) {
  	nu := &NetUnix{
  		Rows: make([]*NetUnixLine, 0, 32),
  	}
  	scanner := bufio.NewScanner(reader)
  	// Omit the header line.
  	scanner.Scan()
  	header := scanner.Text()
  	// From the man page of proc(5), it does not contain an Inode field,
  	// but in actually it exists.
  	// This code works for both cases.
  	hasInode := strings.Contains(header, "Inode")
  
  	minFieldsCnt := netUnixStaticFieldsCnt
  	if hasInode {
  		minFieldsCnt++
  	}
  	for scanner.Scan() {
  		line := scanner.Text()
  		item, err := nu.parseLine(line, hasInode, minFieldsCnt)
  		if err != nil {
  			return nu, err
  		}
  		nu.Rows = append(nu.Rows, item)
  	}
  
  	return nu, scanner.Err()
  }
  
  func (u *NetUnix) parseLine(line string, hasInode bool, minFieldsCnt int) (*NetUnixLine, error) {
  	fields := strings.Fields(line)
  	fieldsLen := len(fields)
  	if fieldsLen < minFieldsCnt {
  		return nil, fmt.Errorf(
  			"Parse Unix domain failed: expect at least %d fields but got %d",
  			minFieldsCnt, fieldsLen)
  	}
  	kernelPtr, err := u.parseKernelPtr(fields[netUnixKernelPtrIdx])
  	if err != nil {
  		return nil, fmt.Errorf("Parse Unix domain num(%s) failed: %s", fields[netUnixKernelPtrIdx], err)
  	}
  	users, err := u.parseUsers(fields[netUnixRefCountIdx])
  	if err != nil {
  		return nil, fmt.Errorf("Parse Unix domain ref count(%s) failed: %s", fields[netUnixRefCountIdx], err)
  	}
  	flags, err := u.parseFlags(fields[netUnixFlagsIdx])
  	if err != nil {
  		return nil, fmt.Errorf("Parse Unix domain flags(%s) failed: %s", fields[netUnixFlagsIdx], err)
  	}
  	typ, err := u.parseType(fields[netUnixTypeIdx])
  	if err != nil {
  		return nil, fmt.Errorf("Parse Unix domain type(%s) failed: %s", fields[netUnixTypeIdx], err)
  	}
  	state, err := u.parseState(fields[netUnixStateIdx])
  	if err != nil {
  		return nil, fmt.Errorf("Parse Unix domain state(%s) failed: %s", fields[netUnixStateIdx], err)
  	}
  	var inode uint64
  	if hasInode {
  		inodeStr := fields[netUnixInodeIdx]
  		inode, err = u.parseInode(inodeStr)
  		if err != nil {
  			return nil, fmt.Errorf("Parse Unix domain inode(%s) failed: %s", inodeStr, err)
  		}
  	}
  
  	nuLine := &NetUnixLine{
  		KernelPtr: kernelPtr,
  		RefCount:  users,
  		Type:      typ,
  		Flags:     flags,
  		State:     state,
  		Inode:     inode,
  	}
  
  	// Path field is optional.
  	if fieldsLen > minFieldsCnt {
  		pathIdx := netUnixInodeIdx + 1
  		if !hasInode {
  			pathIdx--
  		}
  		nuLine.Path = fields[pathIdx]
  	}
  
  	return nuLine, nil
  }
  
  func (u NetUnix) parseKernelPtr(str string) (string, error) {
  	if !strings.HasSuffix(str, ":") {
  		return "", errInvalidKernelPtrFmt
  	}
  	return str[:len(str)-1], nil
  }
  
  func (u NetUnix) parseUsers(hexStr string) (uint64, error) {
  	return strconv.ParseUint(hexStr, 16, 32)
  }
  
  func (u NetUnix) parseProtocol(hexStr string) (uint64, error) {
  	return strconv.ParseUint(hexStr, 16, 32)
  }
  
  func (u NetUnix) parseType(hexStr string) (NetUnixType, error) {
  	typ, err := strconv.ParseUint(hexStr, 16, 16)
  	if err != nil {
  		return 0, err
  	}
  	return NetUnixType(typ), nil
  }
  
  func (u NetUnix) parseFlags(hexStr string) (NetUnixFlags, error) {
  	flags, err := strconv.ParseUint(hexStr, 16, 32)
  	if err != nil {
  		return 0, err
  	}
  	return NetUnixFlags(flags), nil
  }
  
  func (u NetUnix) parseState(hexStr string) (NetUnixState, error) {
  	st, err := strconv.ParseInt(hexStr, 16, 8)
  	if err != nil {
  		return 0, err
  	}
  	return NetUnixState(st), nil
  }
  
  func (u NetUnix) parseInode(inodeStr string) (uint64, error) {
  	return strconv.ParseUint(inodeStr, 10, 64)
  }
  
  func (t NetUnixType) String() string {
  	switch t {
  	case netUnixTypeStream:
  		return "stream"
  	case netUnixTypeDgram:
  		return "dgram"
  	case netUnixTypeSeqpacket:
  		return "seqpacket"
  	}
  	return "unknown"
  }
  
  func (f NetUnixFlags) String() string {
  	switch f {
  	case netUnixFlagListen:
  		return "listen"
  	default:
  		return "default"
  	}
  }
  
  func (s NetUnixState) String() string {
  	switch s {
  	case netUnixStateUnconnected:
  		return "unconnected"
  	case netUnixStateConnecting:
  		return "connecting"
  	case netUnixStateConnected:
  		return "connected"
  	case netUnixStateDisconnected:
  		return "disconnected"
  	}
  	return "unknown"
  }
  