raise HTTPException(status_code=422, detail="Invalid YAML")
    try:
        item = Item.model_validate(data)
    except ValidationError as e:
        raise HTTPException(status_code=422, detail=e.errors(include_url=False))

                            .error(e.getMessage())
                            .build());
                } catch (Exception e) {
                    systemRegistry.trace(e);
                    context.writer.accept(context.invokerRequest
                            .messageBuilderFactory()
                            .builder()
                            .error("Error: " + e.getMessage())

// * controls incoming connections only doing HTTP protocol
func newHTTPListener(ctx context.Context, serverAddrs []string, opts TCPOptions) (listener *httpListener, listenErrs []error) {
	listeners := make([]net.Listener, 0, len(serverAddrs))
	listenErrs = make([]error, len(serverAddrs))

	if opts.Trace == nil {
		opts.Trace = func(msg string) {} // Noop if not defined.
	}

	// Unix listener with special TCP options.

                    }
                } catch (Exception e) {
                    log.error("Failed to load handle file: " + handleFile, e);
                    try {
                        Files.deleteIfExists(handleFile);
                    } catch (IOException deleteEx) {
                        log.error("Failed to delete corrupted handle file: " + handleFile, deleteEx);
                    }
                }

```

If the error type is `*RemoteErr`, then the error was returned by the remote server. Otherwise it is a local error.

Context timeouts are propagated, and a default timeout of 1 minute is added if none is specified.

There is no cancellation propagation for single payload requests.
When the context is canceled, the request will return at once with an appropriate error.

	"github.com/minio/mux"
	"github.com/minio/pkg/v3/policy"
)

var (
	// error returned when remote tier already exists
	errTierAlreadyExists = AdminError{
		Code:       "XMinioAdminTierAlreadyExists",
		Message:    "Specified remote tier already exists",
		StatusCode: http.StatusConflict,
	}
	// error returned when remote tier is not found
	errTierNotFound = AdminError{
		Code:       "XMinioAdminTierNotFound",

    //
    // 4) Create MavenSession.
    //
    // 5) Execute AbstractLifecycleParticipant.afterSessionStart(session)
    //
    // 6) Get reactor projects looking for general POM errors
    //
    // 7) Create ProjectDependencyGraph using trimming which takes into account --projects and reactor mode.
    // This ensures that the projects passed into the ReactorReader are only those specified.
    //

	setSQL, getSQL := getSetSQL(DB.Dialector.Name())
	if len(setSQL) == 0 || len(getSQL) == 0 {
		return
	}

	err := DB.Connection(func(tx *gorm.DB) error {
		if err := tx.Exec(setSQL, expectedName).Error; err != nil {
			return err
		}

		if err := tx.Raw(getSQL).Scan(&actualName).Error; err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		t.Errorf("WithSingleConnection should work, but got err %v", err)
	}

     * @return execution result message, empty if successful or error message if failed
     */
    public String execute() {
        final SearchLogHelper searchLogHelper = ComponentUtil.getSearchLogHelper();

        final StringBuilder resultBuf = new StringBuilder();

        try {
            searchLogHelper.storeSearchLog();
        } catch (final Exception e) {
            logger.error("Failed to store a search log.", e);

     *            may be queried with the <code>toDisplayString</code>, <code>getDomainName</code>, and <code>getAccountName</code>
     *            methods.
     * @throws CIFSException if there is an error resolving the SIDs
     */
    void resolveSids(CIFSContext tc, String authorityServerName, SID[] sids) throws CIFSException;

    /**
     * Resolve part of an array of SIDs using a cache and at most one MSRPC request.