) {
          response.close()
        }
      }
    repeat(10_000) {
      okhttp.newCall(Request.Builder().url(server.url("/")).build()).enqueue(callback)
    }
    okhttp.dispatcher.executorService.shutdown()
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/**
 * Thrown when an HTTP/2 connection is shutdown (either explicitly or if the peer has sent a GOAWAY
 * frame) and an attempt is made to use the connection.
 */

        verify(mockChannelManager, atLeast(1)).establishReplacementChannel();
    }

    @Test
    void testShutdown() {
        failover.shutdown();

        // Should not throw any exceptions
        assertDoesNotThrow(() -> failover.shutdown());
    }

    @Test
    void testConcurrentFailureHandling() throws InterruptedException {
        IOException error = new IOException("Connection failed");

  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse = MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }

  open fun shutdown() {}

    override fun peek(): mockwebserver3.MockResponse = delegate.peek().wrap()

    override fun close() {
      delegate.shutdown()
    }
  }
}

internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
  val result = mockwebserver3.MockResponse.Builder()
  val copyFromWebSocketListener = webSocketListener

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

  fun setFailFast(failFast: Boolean) {
    delegate.setFailFast(failFast)
  }

  fun setFailFast(failFastResponse: MockResponse?) {

func (er erasureObjects) NewNSLock(bucket string, objects ...string) RWLocker {
	return er.nsMutex.NewNSLock(er.getLockers, bucket, objects...)
}

// Shutdown function for object storage interface.
func (er erasureObjects) Shutdown(ctx context.Context) error {
	// Add any object layer shutdown activities here.
	closeStorageDisks(er.getDisks()...)
	return nil
}

// defaultWQuorum write quorum based on setDriveCount and defaultParityCount

    protected String filterPathEncoding;

    /** An array of supported language codes. */
    protected String[] supportedLanguages;

    /** A list of shutdown hooks to be executed on system shutdown. */
    protected List<Runnable> shutdownHookList = new ArrayList<>();

    /** The previous state of the cluster. */
    protected AtomicInteger previousClusterState = new AtomicInteger(0);

      client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")

        println(response.request.url)
      }
    } finally {
      server.shutdown()
    }
  }
}

fun main() {
  DevServer().run()

# Set to "infinity" if you use the 'bootstrap.mlockall: true' option
# in fess.yml and 'MAX_LOCKED_MEMORY=unlimited' in ${packaging.env.file}
#LimitMEMLOCK=infinity

# Shutdown delay in seconds, before process is tried to be killed with KILL (if configured)
TimeoutStopSec=20

[Install]
WantedBy=multi-user.target