<!-- Ignore constant name for architecture tests since we want to use snake case there -->
    <suppress checks="ConstantName"
              files=".*[/\\]architecture-test[/\\]src[/\\]test[/\\]java[/\\]org[/\\]gradle[/\\].+" />
    <suppress checks="ConstantName"
              files=".*[/\\]internal-architecture-testing[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\].+" />

## Consequences

* X
* Y
* Z
```

## Status

ACCEPTED

## Consequences

* We start to use Architectural Decision Records
* We use the proposed template from this ADR
* We locate `.md` files in the folder `/architecture/standards`
* We highly encourage usage of ADR to communicate decisions

Most source code targets the daemon and the remaining code either targets a single runtime, for example the Gradle client, or is shared across multiple runtimes.

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the runtimes.
Not every module contributes to every runtime.

The core-runtime module defines each runtime:

	buildcfg.GOOS = "linux" // obj can handle this OS for all architectures.
	buildcfg.GOARCH = goarch
	architecture := arch.Set(goarch, false)
	if architecture == nil {
		panic("asm: unrecognized architecture " + goarch)
	}
	ctxt := obj.Linknew(architecture.LinkArch)
	ctxt.Pkgpath = "pkg"
	return architecture, ctxt
}

func newParser(goarch string) *Parser {
	architecture, ctxt := setArch(goarch)

the offsets being used to access them are correct.
</p>

<h2 id="architectures">Architecture-specific details</h2>

<p>
It is impractical to list all the instructions and other details for each machine.
To see what instructions are defined for a given machine, say ARM,
look in the source for the <code>obj</code> support library for
that architecture, located in the directory <code>src/cmd/internal/obj/arm</code>.

The project state is managed by the `ProjectState` class.
It is created for each project in the build definition, once per build execution and is discarded at the end of the execution.

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the elements.
Not every module contributes to every element.

```bash
# Generate code coverage reports
mvn jacoco:report

# License header validation
mvn apache-rat:check

# API compatibility checking
mvn clirr:check
```

### Architecture Overview

The library follows a layered architecture:

- **Context Layer**: `CIFSContext` interface provides the main entry point
- **Resource Layer**: `SmbResource` interface represents SMB network resources  

```Dockerfile
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7

COPY ./app /app/app
```

### Raspberry Pi et autres architectures

Si vous utilisez Docker sur un Raspberry Pi (qui a un processeur ARM) ou toute autre architecture, vous pouvez créer un `Dockerfile` à partir de zéro, basé sur une image de base Python (qui est multi-architecture) et utiliser Uvicorn seul.

Dans ce cas, votre `Dockerfile` pourrait ressembler à ceci :

```Dockerfile

# Distributed Server Design Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

This document explains the design, architecture and advanced use cases of the MinIO distributed server.

## Command-line

```
NAME:
  minio server - start object storage server

USAGE:
  minio server [FLAGS] DIR1 [DIR2..]
  minio server [FLAGS] DIR{1...64}
  minio server [FLAGS] DIR{1...64} DIR{65...128}

DIR:

	chmod +x /go/bin/curl
}

case $TARGETARCH in
"arm64")
	download_arch_specific_executable aarch64
	;;
"s390x")
	echo "Not downloading static cURL because it does not exist for the $TARGETARCH architecture."
	;;
*)
	download_arch_specific_executable "$TARGETARCH"
	;;