## we do not need to fail here, since we are going to test
## upgrading to master, healing and being able to recover
## the last version.
if [ $failed_count_site1 -ne 0 ]; then
	echo "failed with multipart on site1 uploads ${failed_count_site1}"
fi

if [ $failed_count_site2 -ne 0 ]; then

	if flag.NArg() != 1 {
		usage()
	}

	f, err := objfile.Open(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	tab, err := f.PCLineTable()
	if err != nil {
		log.Fatalf("reading %s: %v", flag.Arg(0), err)
	}

	stdin := bufio.NewScanner(os.Stdin)
	stdout := bufio.NewWriter(os.Stdout)

	for stdin.Scan() {
		p := stdin.Text()
		if strings.Contains(p, ":") {

	// ensure that this error is sticky.
	err error
}

type fileReader interface {
	io.Reader
	fileState

	WriteTo(io.Writer) (int64, error)
}

// NewReader creates a new [Reader] reading from r.
func NewReader(r io.Reader) *Reader {
	return &Reader{r: r, curr: &regFileReader{r, 0}}
}

// Next advances to the next entry in the tar archive.

labels.jobStatus=Status
labels.labelTypeIds=Labels
labels.lang=Language
labels.outputs=Outputs
labels.pos=Part-of-speech
labels.purgeJobLogDay=Delete old job logs
labels.purgeUserInfoDay=Delete old user logs
labels.reading=Reading
labels.roleTypeIds=Role IDs
labels.scriptData=Script
labels.scriptResult=Result
labels.scriptType=Execution Method
labels.segmentation=Segmentation
labels.startTime=Start Time
labels.target=Target

     * @param externalRepositories The external (and already mirrored) repositories to merge into the result list, may
     *            be {@code null}.
     * @param request The project building request holding further settings like repository settings, must not be
     *            {@code null}.
     * @return The effective artifact repositories, never {@code null}.
     * @throws InvalidRepositoryException
     */

		if err := setxattr(path, name, value); err != nil {
			log.Fatalln(fmt.Errorf("setting attribute %s failed with: %v", name, err))
		}
	} else {
		if name == "" {
			log.Fatalln("you must specify an attribute name for reading")
		}
		var names []string
		if name == "." {
			attrs, err := listxattr(path)
			if err != nil {
				log.Fatalln(fmt.Errorf("listing attributes failed with: %v", err))
			}
			names = append(names, attrs...)

    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)
    assertThat(statusLine.code).isEqualTo(code)
  }

  /**
   * This is not defined in the protocol but some servers won't add the leading empty space when the
   * message is empty. http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1
   */
  @Test
  fun emptyMessageAndNoLeadingSpace() {
    val version = 1
    val code = 503

		os.Mkdir(extractDir, 0o755)
		w, err := os.Create(dst)
		if err != nil {
			return fmt.Errorf("creating output file: %w", err)
		}
		_, err = io.Copy(w, stream)
		if err != nil {
			return fmt.Errorf("reading inspect stream: %w", err)
		}
		fmt.Printf("Extracted: %s\n", dst)
		extracted = true
	}

# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Java serialization is inherently Java-centric and does not support cross-language scenarios well.

- **Type Safety:**
Java serialization does not enforce type safety as strictly as some alternatives, potentially leading to runtime errors.

## Decision

We do not use Java serialization.
Instead, we use custom serialization where we explicitly describe how data objects should be serialized and deserialized.