jubilee 1.1.0-java

data/java/src/org/jruby/jubilee/RackEnvironment.java

@@ -0,0 +1,150 @@
+package org.jruby.jubilee;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyString;
+
+import org.jruby.jubilee.utils.RubyHelper;
+import org.vertx.java.core.MultiMap;
+import org.vertx.java.core.http.HttpServerRequest;
+import org.vertx.java.core.http.HttpVersion;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RackEnvironment {
+
+    // When adding a key to the enum be sure to add its RubyString equivalent
+    // to populateRackKeyMap below
+    static enum RACK_KEY {
+        RACK_INPUT, RACK_ERRORS, REQUEST_METHOD, SCRIPT_NAME,
+        PATH_INFO, QUERY_STRING, SERVER_NAME, SERVER_PORT,
+        CONTENT_TYPE, REQUEST_URI, REMOTE_ADDR, URL_SCHEME,
+        VERSION, MULTITHREAD, MULTIPROCESS, RUN_ONCE, CONTENT_LENGTH,
+        HTTPS, HTTP_VERSION
+    }
+    static final int NUM_RACK_KEYS = RACK_KEY.values().length;
+
+    public RackEnvironment(final Ruby runtime) throws IOException {
+        this.runtime = runtime;
+        rackVersion = RubyArray.newArray(runtime, RubyFixnum.one(runtime), RubyFixnum.four(runtime));
+        errors = new RubyIO(runtime, runtime.getErr());
+        errors.setAutoclose(false);
+
+        populateRackKeyMap();
+    }
+
+    private void populateRackKeyMap() {
+        putRack("rack.input", RACK_KEY.RACK_INPUT);
+        putRack("rack.errors", RACK_KEY.RACK_ERRORS);
+        putRack("REQUEST_METHOD", RACK_KEY.REQUEST_METHOD);
+        putRack("SCRIPT_NAME", RACK_KEY.SCRIPT_NAME);
+        putRack("PATH_INFO", RACK_KEY.PATH_INFO);
+        putRack("QUERY_STRING", RACK_KEY.QUERY_STRING);
+        putRack("SERVER_NAME", RACK_KEY.SERVER_NAME);
+        putRack("SERVER_PORT", RACK_KEY.SERVER_PORT);
+        putRack("HTTP_VERSION", RACK_KEY.HTTP_VERSION);
+        putRack("CONTENT_TYPE", RACK_KEY.CONTENT_TYPE);
+        putRack("REQUEST_URI", RACK_KEY.REQUEST_URI);
+        putRack("REMOTE_ADDR", RACK_KEY.REMOTE_ADDR);
+        putRack("rack.url_scheme", RACK_KEY.URL_SCHEME);
+        putRack("rack.version", RACK_KEY.VERSION);
+        putRack("rack.multithread", RACK_KEY.MULTITHREAD);
+        putRack("rack.multiprocess", RACK_KEY.MULTIPROCESS);
+        putRack("rack.run_once", RACK_KEY.RUN_ONCE);
+        putRack("CONTENT_LENGTH", RACK_KEY.CONTENT_LENGTH);
+        putRack("HTTPS", RACK_KEY.HTTPS);
+    }
+
+    private void putRack(String key, RACK_KEY value) {
+        rackKeyMap.put(RubyHelper.toUsAsciiRubyString(runtime, key), value);
+    }
+
+    public RubyHash getEnv(final HttpServerRequest request,
+                           final RackInput input,
+                           final boolean isSSL) throws IOException {
+        MultiMap headers = request.headers();
+        final RackEnvironmentHash env = new RackEnvironmentHash(runtime, headers, rackKeyMap);
+        env.lazyPut(RACK_KEY.RACK_INPUT, input, false);
+        env.lazyPut(RACK_KEY.RACK_ERRORS, errors, false);
+
+        String pathInfo = request.path();
+
+        String scriptName = "";
+        String[] hostInfo = getHostInfo(request.headers().get(Const.HOST));
+
+        env.lazyPut(RACK_KEY.REQUEST_METHOD, request.method(), true);
+        env.lazyPut(RACK_KEY.SCRIPT_NAME, scriptName, false);
+        env.lazyPut(RACK_KEY.PATH_INFO, pathInfo, false);
+        env.lazyPut(RACK_KEY.QUERY_STRING, orEmpty(request.query()), false);
+        env.lazyPut(RACK_KEY.SERVER_NAME, hostInfo[0], false);
+        env.lazyPut(RACK_KEY.SERVER_PORT, hostInfo[1], true);
+        env.lazyPut(RACK_KEY.HTTP_VERSION,
+                request.version() == HttpVersion.HTTP_1_1 ? Const.HTTP_11 : Const.HTTP_10, true);
+        env.lazyPut(RACK_KEY.CONTENT_TYPE, headers.get(HttpHeaders.Names.CONTENT_TYPE), true);
+        env.lazyPut(RACK_KEY.REQUEST_URI, request.uri(), false);
+        env.lazyPut(RACK_KEY.REMOTE_ADDR, getRemoteAddr(request), true);
+        env.lazyPut(RACK_KEY.URL_SCHEME, isSSL? Const.HTTPS : Const.HTTP, true);
+        env.lazyPut(RACK_KEY.VERSION, rackVersion, false);
+        env.lazyPut(RACK_KEY.MULTITHREAD, runtime.getTrue(), false);
+        env.lazyPut(RACK_KEY.MULTIPROCESS, runtime.getFalse(), false);
+        env.lazyPut(RACK_KEY.RUN_ONCE, runtime.getFalse(), false);
+
+        final int contentLength = getContentLength(headers);
+        if (contentLength >= 0) {
+            env.lazyPut(RACK_KEY.CONTENT_LENGTH, contentLength + "", true);
+        }
+
+        if (isSSL) {
+            env.lazyPut(RACK_KEY.HTTPS, "on", true);
+        }
+
+        return env;
+    }
+
+    public String[] getHostInfo(String host) {
+      String[] hostInfo;
+      if (host != null) {
+        int colon = host.indexOf(":");
+        if (colon > 0)
+          hostInfo = new String[]{host.substring(0, colon), host.substring(colon + 1)};
+        else
+          hostInfo = new String[]{host, Const.PORT_80};
+
+      } else {
+        hostInfo = new String[]{Const.LOCALHOST, Const.PORT_80};
+      }
+      return hostInfo;
+    }
+
+    private static String getRemoteAddr(final HttpServerRequest request) {
+        InetSocketAddress sourceAddress = request.remoteAddress();
+        if(sourceAddress == null) {
+            return "";
+        }
+        return sourceAddress.getHostString();
+    }
+
+    private static int getContentLength(final MultiMap headers) {
+        final String contentLengthStr = headers.get(HttpHeaders.Names.CONTENT_LENGTH);
+        if (contentLengthStr == null || contentLengthStr.isEmpty()) {
+            return -1;
+        }
+        return Integer.parseInt(contentLengthStr);
+    }
+
+    private String orEmpty(String val) {
+        return val == null ? "" : val;
+    }
+
+    private final Ruby runtime;
+    private final RubyArray rackVersion;
+    private final RubyIO errors;
+    private final Map<RubyString, RACK_KEY> rackKeyMap = new HashMap<>();
+}

data/java/src/org/jruby/jubilee/RackEnvironmentHash.java

@@ -0,0 +1,449 @@
+package org.jruby.jubilee;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.jubilee.utils.RubyHelper;
+import org.vertx.java.core.MultiMap;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RackEnvironmentHash extends RubyHash {
+
+    public RackEnvironmentHash(final Ruby runtime, final MultiMap headers,
+                               final Map<RubyString, RackEnvironment.RACK_KEY> rackKeyMap) {
+        super(runtime);
+        this.headers = headers;
+        this.rackKeyMap = rackKeyMap;
+        this.headerKeyMap = new HashMap<>();
+    }
+
+    public void lazyPut(RackEnvironment.RACK_KEY rackKey, final Object value, boolean usAscii) {
+        rackValues[rackKey.ordinal()] = value;
+        usAsciiValues[rackKey.ordinal()] = usAscii;
+    }
+
+    // synchronized probably isn't needed here since we create a new RackEnvironment
+    // per request, but we can't guarantee users aren't spawning a new thread and
+    // passing the env to that new thread
+    private synchronized void fillKey(final IRubyObject rubyKey) {
+        if (!filledEntireHash) {
+            if (rubyKey instanceof RubyString && !containsKey(rubyKey)) {
+                if (! filledHeaderKeyMap) populateHeaderKeyMap();
+                byte[] keyBytes = ((RubyString) rubyKey).getBytes();
+                if (keyBytes.length > 5 && keyBytes[0] == 'H'
+                        && keyBytes[1] == 'T' && keyBytes[2] == 'T'
+                        && keyBytes[3] == 'P' && keyBytes[4] == '_') {
+
+                    fillHeaderKey((RubyString) rubyKey);
+                } else {
+                    fillRackKey((RubyString) rubyKey);
+                }
+            }
+        }
+    }
+    private synchronized void fillEntireHash() {
+        if (!filledEntireHash) {
+            for (RubyString key : rackKeyMap.keySet()) {
+                fillRackKey(key);
+            }
+
+            for (String headerKey : headers.names()) {
+                RubyString rubyKey = RubyHelper.toUsAsciiRubyString(getRuntime(), rackHeaderNameToBytes(headerKey));
+                putHeaderKey(rubyKey, headerKey);
+                fillHeaderKey(rubyKey, headerKey);
+            }
+            filledEntireHash = true;
+        }
+    }
+    private synchronized void fillRackKey(final RubyString key) {
+        RackEnvironment.RACK_KEY rackKey = rackKeyMap.get(key);
+        if (rackKey != null) {
+            Object value = rackValues[rackKey.ordinal()];
+            if (value != null) {
+                if (value instanceof String) {
+                    boolean usAscii = usAsciiValues[rackKey.ordinal()];
+                    RubyString rubyValue = usAscii ? RubyHelper.toUsAsciiRubyString(getRuntime(), (String) value) :
+                            RubyHelper.toUnicodeRubyString(getRuntime(), (String) value);
+                    put(key, rubyValue);
+                } else {
+                    put(key, value);
+                }
+                rackValues[rackKey.ordinal()] = null;
+            }
+        }
+    }
+
+    private synchronized  void populateHeaderKeyMap() {
+        for (String key : headers.names()) {
+            byte[] rubyKeyBytes = rackHeaderNameToBytes(key);
+            RubyString rubyKey = RubyHelper.toUsAsciiRubyString(getRuntime(), rubyKeyBytes);
+            putHeaderKey(rubyKey, key);
+        }
+        this.filledHeaderKeyMap = true;
+    }
+
+    private void putHeaderKey(RubyString rubyKey, String key) {
+        this.headerKeyMap.put(rubyKey, key);
+    }
+    private synchronized void fillHeaderKey(final RubyString rubyKey) {
+        String headerKey = this.headerKeyMap.get(rubyKey);
+        if (headerKey != null) fillHeaderKey(rubyKey, headerKey);
+    }
+    private synchronized void fillHeaderKey(final RubyString rubyKey, String key) {
+        // RACK spec says not to create HTTP_CONTENT_TYPE or HTTP_CONTENT_LENGTH headers
+        if (!key.equals(HttpHeaders.Names.CONTENT_TYPE) && !key.equals(HttpHeaders.Names.CONTENT_LENGTH)) {
+            List<String> headerValues = headers.getAll(key);
+            if (!headerValues.isEmpty()) {
+                String headerValue = headerValues.get(0);
+                int valueIndex = 1;
+                while (valueIndex < headerValues.size()) {
+                    headerValue += "\n" + headerValues.get(valueIndex++);
+                }
+                put(rubyKey, RubyHelper.toUnicodeRubyString(getRuntime(), headerValue));
+            }
+        }
+    }
+
+    private static byte[] rackHeaderNameToBytes(final String headerName) {
+        // This is a more performant implemention of:
+        // "HTTP_" + headerName.toUpperCase().replace('-', '_');
+        byte[] envNameBytes = new byte[headerName.length() + 5];
+        envNameBytes[0] = 'H';
+        envNameBytes[1] = 'T';
+        envNameBytes[2] = 'T';
+        envNameBytes[3] = 'P';
+        envNameBytes[4] = '_';
+        for (int i = 5; i < envNameBytes.length; i++) {
+            envNameBytes[i] = (byte) rackHeaderize(headerName.charAt(i - 5));
+        }
+        return envNameBytes;
+    }
+
+    private static char rackHeaderize(char c) {
+        if (c == '-') {
+            c = '_';
+        }
+        return toUpperCase(c);
+    }
+
+    private static char toUpperCase(char c) {
+        if (c >= 'a' && c <= 'z') {
+            c -= 32;
+        }
+        return c;
+    }
+
+    private final Object[] rackValues = new Object[RackEnvironment.NUM_RACK_KEYS];
+    private final boolean[] usAsciiValues = new boolean[RackEnvironment.NUM_RACK_KEYS];
+    private final MultiMap headers;
+    private final Map<RubyString, RackEnvironment.RACK_KEY> rackKeyMap;
+    private final Map<RubyString, String> headerKeyMap;
+    private boolean filledEntireHash = false;
+    private boolean filledHeaderKeyMap = false;
+
+
+
+    //
+    // Overridden RubyHash methods that operate on individual keys
+    //
+    @Override
+    public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
+        fillKey(key);
+        return super.op_aref(context, key);
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject key, Block block) {
+        fillKey(key);
+        return super.fetch(context, key, block);
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject key, IRubyObject _default, Block block) {
+        fillKey(key);
+        return super.fetch(context, key ,_default, block);
+    }
+    @Override
+    public RubyBoolean has_key_p(IRubyObject key) {
+        fillKey(key);
+        return super.has_key_p(key);
+    }
+    @Override
+    public IRubyObject op_aset(ThreadContext context, IRubyObject key, IRubyObject value) {
+        fillKey(key);
+        return super.op_aset(context, key, value);
+    }
+    @Override
+    public IRubyObject delete(ThreadContext context, IRubyObject key, Block block) {
+        fillKey(key);
+        return super.delete(context, key, block);
+    }
+
+    //
+    // Overridden RubyHash methods that don't operate on individual keys so we
+    // fill the entire hash
+    //
+    @Override
+    public IRubyObject inspect(ThreadContext context) {
+        fillEntireHash();
+        return super.inspect(context);
+    }
+    @Override
+    public IRubyObject inspect19(ThreadContext context) {
+        fillEntireHash();
+        return super.inspect19(context);
+    }
+    @Override
+    public RubyFixnum rb_size() {
+        fillEntireHash();
+        return super.rb_size();
+    }
+    @Override
+    public RubyBoolean empty_p() {
+        fillEntireHash();
+        return super.empty_p();
+    }
+    @Override
+    public RubyArray to_a() {
+        fillEntireHash();
+        return super.to_a();
+    }
+    @Override
+    public IRubyObject to_s(ThreadContext context) {
+        fillEntireHash();
+        return super.to_s(context);
+    }
+    @Override
+    public IRubyObject to_s19(ThreadContext context) {
+        fillEntireHash();
+        return super.to_s19(context);
+    }
+    @Override
+    public RubyHash rehash() {
+        fillEntireHash();
+        return super.rehash();
+    }
+    @Override
+    public IRubyObject op_equal(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.op_equal(context, other);
+    }
+    @Override
+    public IRubyObject op_eql19(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.op_eql19(context, other);
+    }
+    @Override
+    public RubyFixnum hash() {
+        fillEntireHash();
+        return super.hash();
+    }
+    @Override
+    public RubyFixnum hash19() {
+        fillEntireHash();
+        return super.hash19();
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) {
+        fillEntireHash();
+        return super.fetch(context, args, block);
+    }
+    @Override
+    public RubyBoolean has_value_p(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.has_value_p(context, expected);
+    }
+    @Override
+    public IRubyObject each(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each(context, block);
+    }
+    @Override
+    public IRubyObject each19(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each19(context, block);
+    }
+    @Override
+    public IRubyObject each_value(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each_value(context, block);
+    }
+    @Override
+    public IRubyObject each_key(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each_key(context, block);
+    }
+    @Override
+    public IRubyObject select_bang(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select_bang(context, block);
+    }
+    @Override
+    public IRubyObject keep_if(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.keep_if(context, block);
+    }
+    @Override
+    public IRubyObject sort(ThreadContext context, Block block) {
+        fillEntireHash();
+        return super.sort(context, block);
+    }
+    @Override
+    public IRubyObject index(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.index(context, expected);
+    }
+    @Override
+    public IRubyObject index19(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.index19(context, expected);
+    }
+    @Override
+    public IRubyObject key(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.key(context, expected);
+    }
+    @Override
+    public RubyArray indices(ThreadContext context, IRubyObject[] indices) {
+        fillEntireHash();
+        return super.indices(context, indices);
+    }
+    @Override
+    public RubyArray keys() {
+        fillEntireHash();
+        return super.keys();
+    }
+    @Override
+    public RubyArray rb_values() {
+        fillEntireHash();
+        return super.rb_values();
+    }
+    @Override
+    public IRubyObject shift(ThreadContext context) {
+        fillEntireHash();
+        return super.shift(context);
+    }
+    @Override
+    public IRubyObject select(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select(context, block);
+    }
+    @Override
+    public IRubyObject select19(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select19(context, block);
+    }
+    @Override
+    public IRubyObject delete_if(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.delete_if(context, block);
+    }
+    @Override
+    public IRubyObject reject(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.reject(context, block);
+    }
+    @Override
+    public IRubyObject reject_bang(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.reject_bang(context, block);
+    }
+    @Override
+    public RubyHash rb_clear() {
+        fillEntireHash();
+        return super.rb_clear();
+    }
+    @Override
+    public RubyHash invert(final ThreadContext context) {
+        fillEntireHash();
+        return super.invert(context);
+    }
+    @Override
+    public RubyHash merge_bang(final ThreadContext context, final IRubyObject other, final Block block) {
+        fillEntireHash();
+        return super.merge_bang(context, other, block);
+    }
+    @Override
+    public RubyHash merge_bang19(final ThreadContext context, final IRubyObject other, final Block block) {
+        fillEntireHash();
+        return super.merge_bang19(context, other, block);
+    }
+    @Override
+    public RubyHash merge(ThreadContext context, IRubyObject other, Block block) {
+        fillEntireHash();
+        return super.merge(context, other, block);
+    }
+    @Override
+    public RubyHash initialize_copy(ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.initialize_copy(context, other);
+    }
+    @Override
+    public RubyHash initialize_copy19(ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.initialize_copy19(context, other);
+    }
+    @Override
+    public RubyHash replace(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.replace(context, other);
+    }
+    @Override
+    public RubyHash replace19(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.replace19(context, other);
+    }
+    @Override
+    public RubyArray values_at(ThreadContext context, IRubyObject[] args) {
+        fillEntireHash();
+        return super.values_at(context, args);
+    }
+    @Override
+    public IRubyObject assoc(final ThreadContext context, final IRubyObject obj) {
+        fillEntireHash();
+        return super.assoc(context, obj);
+    }
+    @Override
+    public IRubyObject rassoc(final ThreadContext context, final IRubyObject obj) {
+        fillEntireHash();
+        return super.rassoc(context, obj);
+    }
+    @Override
+    public IRubyObject flatten(ThreadContext context) {
+        fillEntireHash();
+        return super.flatten(context);
+    }
+    @Override
+    public IRubyObject flatten(ThreadContext context, IRubyObject level) {
+        fillEntireHash();
+        return super.flatten(context, level);
+    }
+    @Override
+    public IRubyObject getCompareByIdentity(ThreadContext context) {
+        fillEntireHash();
+        return super.getCompareByIdentity(context);
+    }
+    @Override
+    public IRubyObject getCompareByIdentity_p(ThreadContext context) {
+        fillEntireHash();
+        return super.getCompareByIdentity_p(context);
+    }
+    @Override
+    public IRubyObject dup(ThreadContext context) {
+        fillEntireHash();
+        return super.dup(context);
+    }
+    @Override
+    public IRubyObject rbClone(ThreadContext context) {
+        fillEntireHash();
+        return super.rbClone(context);
+    }
+}