}
		defer threadNS.Close()

		// switch to target namespace
		if err = NetnsSet(fdable); err != nil {
			return err
		}
		defer func() {
			err := threadNS.Set() // switch back
			if err == nil {
				// Unlock the current thread only when we successfully switched back
				// to the original namespace; otherwise leave the thread locked which

/**
 * This class provides a skeletal implementation of the {@link ListIterator} interface across a
 * fixed number of elements that may be retrieved by position. It does not support {@link #remove},
 * {@link #set}, or {@link #add}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class AbstractIndexedListIterator<E extends @Nullable Object>
    extends UnmodifiableListIterator<E> {

  // the default priority for pods that do not have any priority class.
  // Only one PriorityClass can be marked as `globalDefault`. However, if more than
  // one PriorityClasses exists with their `globalDefault` field set to true,
  // the smallest value of such global default PriorityClasses will be used as the default priority.
  // +optional
  optional bool globalDefault = 3;

    public static final int B_NODE = 0;

    /**
     * A Point-to-Point node, or P node, unicasts queries to a nameserver
     * only. Natrually the <code>jcifs.netbios.nameserver</code> property must
     * be set.
     */

    public static final int P_NODE = 1;

    /**
     * Try Broadcast queries first, then try to resolve the name using the
     * nameserver.
     */

                  for (Integer node : graph.nodes()) {
                    Set<Integer> unused = graph.successors(node);
                  }
                  /*
                   * Also look up an earlier node so that, if the graph is using MapRetrievalCache,
                   * we read one of the fields declared in that class.
                   */
                  Set<Integer> unused = graph.successors(first);
                  return null;

    val connection = AtomicReference<Connection?>()
    client =
      client.newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            connection.set(chain!!.connection())
            chain.proceed(chain.request())
          },
        )
        .build()
    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)

    // the resource is visible to the system class loader.
    assertThrows(IllegalArgumentException.class, () -> Resources.getResource(tempFile.getName()));

    // Now set the context loader to one that should find the resource.
    URL baseUrl = tempFile.getParentFile().toURI().toURL();
    URLClassLoader loader = new URLClassLoader(new URL[] {baseUrl});

     */
    public boolean isAsyncHandled () {
        return this.asyncHandled;
    }


    /**
     * @param asyncHandled
     *            the asyncHandled to set
     */
    public void setAsyncHandled ( boolean asyncHandled ) {
        this.asyncHandled = asyncHandled;
    }


    /**
     * {@inheritDoc}
     *

    private boolean enableBasic;

    private boolean insecureBasic;

    private String realm;

    public void init(ServletConfig config) throws ServletException {
        super.init(config);

        /* Set jcifs.smb1 properties we know we want; soTimeout and cachePolicy to 10min.
         */
        Config.setProperty( "jcifs.smb1.smb.client.soTimeout", "300000" );
        Config.setProperty( "jcifs.smb1.netbios.cachePolicy", "600" );

	  attempts: 10 # number of retries for the job before giving up
	  delay: "500ms" # least amount of delay between each retry
```

You can create and run multiple 'replication' jobs at a time there are no predefined limits set.

## Batch Jobs Terminology

### Job