fix(drivers/139): move GetSectionReader outside retry loop

- Move ss.GetSectionReader() before retry.Do() so the sequential
  stream section reader is only called once per chunk
- Remove redundant ss.FreeSectionReader() calls from inside the
  retry closure since the reader is now owned by the outer scope
- Fixes 'stream not cached' errors when retrying failed chunk
  uploads during cross-storage WebDAV COPY operations

Co-authored-by: GitHub Copilot <copilot@github.com>

Author: xrgzs

drivers/139/driver.go

@@ -902,22 +902,19 @@ func (d *Yun139) Put(ctx context.Context, dstDir model.Obj, stream model.FileStr
 			start := i * partSize
 			byteSize := min(size-start, partSize)
 
-			var rd io.ReadSeeker
+			rd, getErr := ss.GetSectionReader(start, byteSize)
+			if getErr != nil {
+				return getErr
+			}
+
 			err = retry.Do(
 				func() error {
-					var getErr error
-					rd, getErr = ss.GetSectionReader(start, byteSize)
-					if getErr != nil {
-						return getErr
-					}
 					if _, err := rd.Seek(0, io.SeekStart); err != nil {
-						ss.FreeSectionReader(rd)
 						return err
 					}
 					req, reqErr := http.NewRequestWithContext(ctx, http.MethodPost, resp.Data.UploadResult.RedirectionURL,
 						io.TeeReader(rd, p))
 					if reqErr != nil {
-						ss.FreeSectionReader(rd)
 						return reqErr
 					}
 					req.Header.Set("Content-Type", "text/plain;name="+unicode(stream.GetName()))
@@ -929,27 +926,22 @@ func (d *Yun139) Put(ctx context.Context, dstDir model.Obj, stream model.FileStr
 
 					res, doErr := base.HttpClient.Do(req)
 					if doErr != nil {
-						ss.FreeSectionReader(rd)
 						return doErr
 					}
 					defer res.Body.Close()
 					bodyBytes, readErr := io.ReadAll(res.Body)
 					if readErr != nil {
-						ss.FreeSectionReader(rd)
 						return fmt.Errorf("error reading response body: %v", readErr)
 					}
 					if res.StatusCode != http.StatusOK {
-						ss.FreeSectionReader(rd)
 						return fmt.Errorf("unexpected status code: %d, body: %s", res.StatusCode, string(bodyBytes))
 					}
 					var result InterLayerUploadResult
 					xmlErr := xml.Unmarshal(bodyBytes, &result)
 					if xmlErr != nil {
-						ss.FreeSectionReader(rd)
 						return fmt.Errorf("error parsing XML: %v", xmlErr)
 					}
 					if result.ResultCode != 0 {
-						ss.FreeSectionReader(rd)
 						return fmt.Errorf("upload failed with result code: %d, message: %s", result.ResultCode, result.Msg)
 					}
 					return nil

drivers/139/util.go

@@ -716,22 +716,18 @@ func (d *Yun139) uploadPersonalParts(ctx context.Context, partInfos []PartInfo,
 		offset := partInfos[index].ParallelHashCtx.PartOffset
 		log.Debugf("[139] uploading part %+v/%+v", index, len(partInfos))
 
-		var rd io.ReadSeeker
+		rd, getErr := ss.GetSectionReader(offset, partSize)
+		if getErr != nil {
+			return getErr
+		}
+
 		err := retry.Do(
 			func() error {
-				var getErr error
-				rd, getErr = ss.GetSectionReader(offset, partSize)
-				if getErr != nil {
-					return getErr
-				}
-				_, seekErr := rd.Seek(0, io.SeekStart)
-				if seekErr != nil {
-					ss.FreeSectionReader(rd)
+				if _, seekErr := rd.Seek(0, io.SeekStart); seekErr != nil {
 					return seekErr
 				}
 				req, reqErr := http.NewRequestWithContext(ctx, http.MethodPut, uploadPartInfo.UploadUrl, io.TeeReader(rd, p))
 				if reqErr != nil {
-					ss.FreeSectionReader(rd)
 					return reqErr
 				}
 				req.Header.Set("Content-Type", "application/octet-stream")
@@ -742,14 +738,12 @@ func (d *Yun139) uploadPersonalParts(ctx context.Context, partInfos []PartInfo,
 
 				res, doErr := base.HttpClient.Do(req)
 				if doErr != nil {
-					ss.FreeSectionReader(rd)
 					return doErr
 				}
 				defer res.Body.Close()
 				log.Debugf("[139] uploaded: %+v", res)
 				if res.StatusCode != http.StatusOK {
 					body, _ := io.ReadAll(res.Body)
-					ss.FreeSectionReader(rd)
 					return fmt.Errorf("unexpected status code: %d, body: %s", res.StatusCode, string(body))
 				}
 				return nil