}

	updatedAt, err := sys.store.SetPolicy(ctx, policyName, p)
	if err != nil {
		return updatedAt, err
	}

	if !sys.HasWatcher() {
		// Notify all other MinIO peers to reload policy
		for _, nerr := range globalNotificationSys.LoadPolicy(ctx, policyName) {
			if nerr.Err != nil {
				logger.GetReqInfo(ctx).SetTags("peerAddress", nerr.Host.String())
				iamLogIf(ctx, nerr.Err)
			}
		}

### Dokumentation live

Während der lokalen Entwicklung gibt es ein Skript, das die Site erstellt, auf Änderungen prüft und direkt neu lädt (Live Reload):

<div class="termy">

```console
$ python ./scripts/docs.py live

<span style="color: green;">[INFO]</span> Serving on http://127.0.0.1:8008

	}

	r.wg.Add(1)
	defer r.wg.Done()
	n, err = r.read(p)
	for err == ErrIsEmpty && r.block {
		r.writeCond.Wait()
		if err = r.readErr(true); err != nil {
			break
		}
		n, err = r.read(p)
	}
	if r.block && n > 0 {
		r.readCond.Broadcast()
	}
	return n, err
}

// TryRead read up to len(p) bytes into p like Read but it is not blocking.

    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (this) {
      if (!executed) {

        } else if (!this.propertiesFile.isFile()) {
            throw new FileAccessException("ECL0111", new Object[] { file.getAbsolutePath() });
        }
        load();
    }

    public synchronized void reload(final String path) {
        final File file = new File(path);
        if (!file.exists()) {
            final File parentDir = file.getParentFile();
            if (!parentDir.exists()) {

     * may be necessary that an addition thread be used to read and
     * write to a Named Pipe.
     */

    public InputStream getNamedPipeInputStream() throws IOException {
        if( pipeIn == null ) {
            if(( pipeType & PIPE_TYPE_CALL ) == PIPE_TYPE_CALL ||
                    ( pipeType & PIPE_TYPE_TRANSACT ) == PIPE_TYPE_TRANSACT ) {
                pipeIn = new TransactNamedPipeInputStream( this );
            } else {

 * the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.Thread.currentThread;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;

            try ( SmbTreeHandle th = f.getTreeHandle() ) {
                Assume.assumeTrue("Not SMB2", th.isSMB2());
            }

            f.exists();
            Thread.sleep(wait);

            try ( SmbResource r = f.resolve("test") ) {
                r.exists();
            }
        }
        catch ( SmbUnsupportedOperationException e ) {

        /*
         * Note the Transport thread isn't running yet so we can
         * read from the socket here.
         */
        try {
            this.socket.setSoTimeout(this.transportContext.getConfig().getConnTimeout());
            if ( peekKey() == null ) /* try to read header */
                throw new IOException("transport closed in negotiate");
        }

   * comparable.
   *
   * <p>This method is safe to use even when {@code elements} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws ClassCastException if the elements are not mutually comparable
   * @throws NullPointerException if any of {@code elements} is null
   * @since 7.0 (source-compatible since 2.0)
   */