* concurrently.
 */

public abstract class Transport implements Runnable {

    static int id = 0;
    static LogStream log = LogStream.getInstance();

    public static int readn( InputStream in,
                byte[] b,
                int off,
                int len ) throws IOException {
        int i = 0, n = -5;

        while (i < len) {
            n = in.read( b, off + i, len - i );
            if (n <= 0) {

    keepalive_timeout  65;

    # include /etc/nginx/conf.d/*.conf;

    upstream minio {
        server minio1:9000 max_fails=1 fail_timeout=10s;
        server minio2:9000 max_fails=1 fail_timeout=10s;
        server minio3:9000 max_fails=1 fail_timeout=10s;
        server minio4:9000 max_fails=1 fail_timeout=10s;
    }

    upstream console {
        ip_hash;
        server minio1:9001;
        server minio2:9001;

        });

        final EditBody body = createEditBody(entity);
        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
        body.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                .filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));

            }
            // 404
            throw responseManager.new404("Thumbnail for " + form.docId + " is under generating.");
        }

        return asStream(form.docId).contentType(getImageMimeType(thumbnailFile)).stream(out -> {
            try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(thumbnailFile))) {
                out.write(in);
            }
        });
    }

            Collection<? extends MavenProject> projects, boolean transitive, boolean upstream) {
        List<MavenProject> filtered = new ArrayList<>(projects.size());
        for (MavenProject project : projects) {
            if (whiteList.containsKey(project)) {
                filtered.add(project);
            } else if (!transitive) {
                filtered.addAll(upstream ? getUpstreamProjects(project, false) : getDownstreamProjects(project, false));

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    # include /etc/nginx/conf.d/*.conf;

    upstream minio {
        server minio1:9000;
        server minio2:9000;
        server minio3:9000;
        server minio4:9000;
    }

    # main minio
    server {
        listen       9000;
        listen  [::]:9000;

    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {
    ImmutableIntArray.of().stream().forEach(i -> fail());
    ImmutableIntArray.of(0, 1, 3).subArray(1, 1).stream().forEach(i -> fail());
    assertThat(ImmutableIntArray.of(0, 1, 3).stream().toArray()).isEqualTo(new int[] {0, 1, 3});
  }

  public void testSubArray() {
    ImmutableIntArray iia0 = ImmutableIntArray.of();

    sendfile        on;
    keepalive_timeout  65;

    # include /etc/nginx/conf.d/*.conf;

    upstream minio {
        server site1-minio1:9000;
        server site1-minio2:9000;
        server site1-minio3:9000;
        server site1-minio4:9000;
    }

    server {
        listen       9001;
        listen  [::]:9001;
        server_name  localhost;

    sendfile        on;
    keepalive_timeout  65;

    # include /etc/nginx/conf.d/*.conf;

    upstream minio {
        server site2-minio1:9000;
        server site2-minio2:9000;
        server site2-minio3:9000;
        server site2-minio4:9000;
    }

    server {
        listen       9002;
        listen  [::]:9002;
        server_name  localhost;

		}
		return true
	})
	if debugReqs {
		fmt.Println(c.String(), "Disconnected. Clearing outgoing.")
	}
	c.outgoing.Clear()
	c.inStream.Range(func(key uint64, client *muxServer) bool {
		client.cancel()
		return true
	})
	c.inStream.Clear()
}

func (c *Connection) receive(conn net.Conn, r receiver) error {
	b, op, err := wsutil.ReadData(conn, c.side)
	if err != nil {
		return err