upload/koji/uploadChunk: fix compilation errors

The API of kolo/xmlrpc changed after the commit that is shipped in
Fedora. Pin the vendored version to that and adjust the API usage.

This should make the RPM compile in both RHEL and Fedora.

Signed-off-by: Tom Gundersen <teg@jklm.no>

vendor/github.com/kolo/xmlrpc/client.go

@@ -31,7 +31,7 @@ type clientCodec struct {
 	responses map[uint64]*http.Response
 	mutex     sync.Mutex
 
-	response Response
+	response *Response
 
 	// ready presents channel, that is used to link request and it`s response.
 	ready chan uint64
@@ -43,16 +43,16 @@ type clientCodec struct {
 func (codec *clientCodec) WriteRequest(request *rpc.Request, args interface{}) (err error) {
 	httpRequest, err := NewRequest(codec.url.String(), request.ServiceMethod, args)
 
-	if err != nil {
-		return err
-	}
-
 	if codec.cookies != nil {
 		for _, cookie := range codec.cookies.Cookies(codec.url) {
 			httpRequest.AddCookie(cookie)
 		}
 	}
 
+	if err != nil {
+		return err
+	}
+
 	var httpResponse *http.Response
 	httpResponse, err = codec.httpClient.Do(httpRequest)
 
@@ -75,39 +75,43 @@ func (codec *clientCodec) WriteRequest(request *rpc.Request, args interface{}) (
 
 func (codec *clientCodec) ReadResponseHeader(response *rpc.Response) (err error) {
 	var seq uint64
+
 	select {
 	case seq = <-codec.ready:
 	case <-codec.close:
 		return errors.New("codec is closed")
 	}
-	response.Seq = seq
 
 	codec.mutex.Lock()
 	httpResponse := codec.responses[seq]
-	delete(codec.responses, seq)
 	codec.mutex.Unlock()
 
-	defer httpResponse.Body.Close()
-
 	if httpResponse.StatusCode < 200 || httpResponse.StatusCode >= 300 {
-		response.Error = fmt.Sprintf("request error: bad status code - %d", httpResponse.StatusCode)
-		return nil
+		return fmt.Errorf("request error: bad status code - %d", httpResponse.StatusCode)
 	}
 
-	body, err := ioutil.ReadAll(httpResponse.Body)
+	respData, err := ioutil.ReadAll(httpResponse.Body)
+
 	if err != nil {
-		response.Error = err.Error()
-		return nil
+		return err
 	}
 
-	resp := Response(body)
-	if err := resp.Err(); err != nil {
-		response.Error = err.Error()
-		return nil
+	httpResponse.Body.Close()
+
+	resp := NewResponse(respData)
+
+	if resp.Failed() {
+		response.Error = fmt.Sprintf("%v", resp.Err())
 	}
 
 	codec.response = resp
 
+	response.Seq = seq
+
+	codec.mutex.Lock()
+	delete(codec.responses, seq)
+	codec.mutex.Unlock()
+
 	return nil
 }
 
@@ -115,7 +119,12 @@ func (codec *clientCodec) ReadResponseBody(v interface{}) (err error) {
 	if v == nil {
 		return nil
 	}
-	return codec.response.Unmarshal(v)
+
+	if err = codec.response.Unmarshal(v); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (codec *clientCodec) Close() error {

vendor/github.com/kolo/xmlrpc/decoder.go

@@ -130,9 +130,8 @@ func (dec *decoder) decodeValue(val reflect.Value) error {
 				ismap = true
 			} else if checkType(val, reflect.Interface) == nil && val.IsNil() {
 				var dummy map[string]interface{}
-				valType = reflect.TypeOf(dummy)
-				pmap = reflect.New(valType).Elem()
-				val.Set(pmap)
+				pmap = reflect.New(reflect.TypeOf(dummy)).Elem()
+				valType = pmap.Type()
 				ismap = true
 			} else {
 				return err

vendor/github.com/kolo/xmlrpc/encoder.go

@@ -10,9 +10,6 @@ import (
 	"time"
 )
 
-// Base64 represents value in base64 encoding
-type Base64 string
-
 type encodeFunc func(reflect.Value) ([]byte, error)
 
 func marshal(v interface{}) ([]byte, error) {

vendor/github.com/kolo/xmlrpc/response.go

@@ -1,7 +1,6 @@
 package xmlrpc
 
 import (
-	"fmt"
 	"regexp"
 )
 
@@ -9,32 +8,43 @@ var (
 	faultRx = regexp.MustCompile(`<fault>(\s|\S)+</fault>`)
 )
 
-// FaultError is returned from the server when an invalid call is made
-type FaultError struct {
-	Code   int    `xmlrpc:"faultCode"`
-	String string `xmlrpc:"faultString"`
+type failedResponse struct {
+	Code  int    `xmlrpc:"faultCode"`
+	Error string `xmlrpc:"faultString"`
 }
 
-// Error implements the error interface
-func (e FaultError) Error() string {
-	return fmt.Sprintf("Fault(%d): %s", e.Code, e.String)
-}
-
-type Response []byte
-
-func (r Response) Err() error {
-	if !faultRx.Match(r) {
-		return nil
+func (r *failedResponse) err() error {
+	return &xmlrpcError{
+		code: r.Code,
+		err:  r.Error,
 	}
-	var fault FaultError
-	if err := unmarshal(r, &fault); err != nil {
+}
+
+type Response struct {
+	data []byte
+}
+
+func NewResponse(data []byte) *Response {
+	return &Response{
+		data: data,
+	}
+}
+
+func (r *Response) Failed() bool {
+	return faultRx.Match(r.data)
+}
+
+func (r *Response) Err() error {
+	failedResp := new(failedResponse)
+	if err := unmarshal(r.data, failedResp); err != nil {
 		return err
 	}
-	return fault
+
+	return failedResp.err()
 }
 
-func (r Response) Unmarshal(v interface{}) error {
-	if err := unmarshal(r, v); err != nil {
+func (r *Response) Unmarshal(v interface{}) error {
+	if err := unmarshal(r.data, v); err != nil {
 		return err
 	}
 

vendor/github.com/kolo/xmlrpc/test_server.rb

@@ -15,9 +15,9 @@ class Service
     x + y
   end
 
-  def error
-    raise XMLRPC::FaultException.new(500, "Server error")
-  end
+	def error
+		raise XMLRPC::FaultException.new(500, "Server error")
+	end
 end
 
 server = XMLRPC::Server.new 5001, 'localhost'

vendor/github.com/kolo/xmlrpc/xmlrpc.go

@@ -0,0 +1,19 @@
+package xmlrpc
+
+import (
+	"fmt"
+)
+
+// xmlrpcError represents errors returned on xmlrpc request.
+type xmlrpcError struct {
+	code int
+	err  string
+}
+
+// Error() method implements Error interface
+func (e *xmlrpcError) Error() string {
+	return fmt.Sprintf("error: \"%s\" code: %d", e.err, e.code)
+}
+
+// Base64 represents value in base64 encoding
+type Base64 string

vendor/modules.txt

@@ -119,7 +119,7 @@ github.com/gophercloud/gophercloud/pagination
 github.com/jmespath/go-jmespath
 # github.com/julienschmidt/httprouter v1.2.0
 github.com/julienschmidt/httprouter
-# github.com/kolo/xmlrpc v0.0.0-20190909154602-56d5ec7c422e
+# github.com/kolo/xmlrpc v0.0.0-20190417161013-de6d879202d7
 github.com/kolo/xmlrpc
 # github.com/kr/pretty v0.1.0
 github.com/kr/pretty