andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

SPDY: update object hierarchy

Browse Source
This commit is contained in:
Jeff Pinner 2013-06-04 14:32:11 -07:00 committed by Norman Maurer
parent 7f7bf304b0
commit c8ca329932
36 changed files with 531 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyDataFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,17 +16,16 @@
package io.netty.handler.codec.spdy;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.DefaultByteBufHolder;
import io.netty.buffer.IllegalBufferAccessException;
import io.netty.buffer.Unpooled;
import io.netty.util.internal.StringUtil;
/**
* The default {@link SpdyDataFrame} implementation.
*/
public class DefaultSpdyDataFrame extends DefaultByteBufHolder implements SpdyDataFrame {
public class DefaultSpdyDataFrame extends DefaultSpdyStreamFrame implements SpdyDataFrame {
private int streamId;
private boolean last;
private final ByteBuf data;
/**
* Creates a new instance.
@ -44,8 +43,11 @@ public class DefaultSpdyDataFrame extends DefaultByteBufHolder implements SpdyDa
* @param data the payload of the frame. Can not exceed {@link SpdyCodecUtil#SPDY_MAX_LENGTH}
*/
public DefaultSpdyDataFrame(int streamId, ByteBuf data) {
super(validate(data));
setStreamId(streamId);
super(streamId);
if (data == null) {
throw new NullPointerException("data");
}
this.data = validate(data);
}
private static ByteBuf validate(ByteBuf data) {
@ -56,51 +58,60 @@ public class DefaultSpdyDataFrame extends DefaultByteBufHolder implements SpdyDa
return data;
}
@Override
public int getStreamId() {
return streamId;
}
@Override
public SpdyDataFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
super.setStreamId(streamId);
return this;
}
@Override
public boolean isLast() {
return last;
}
@Override
public SpdyDataFrame setLast(boolean last) {
this.last = last;
super.setLast(last);
return this;
}
@Override
public DefaultSpdyDataFrame copy() {
DefaultSpdyDataFrame frame = new DefaultSpdyDataFrame(getStreamId(), content().copy());
public ByteBuf content() {
if (data.refCnt() <= 0) {
throw new IllegalBufferAccessException();
}
return data;
}
@Override
public SpdyDataFrame copy() {
SpdyDataFrame frame = new DefaultSpdyDataFrame(getStreamId(), content().copy());
frame.setLast(isLast());
return frame;
}
@Override
public int refCnt() {
return data.refCnt();
}
@Override
public SpdyDataFrame retain() {
super.retain();
data.retain();
return this;
}
@Override
public SpdyDataFrame retain(int increment) {
super.retain(increment);
data.retain(increment);
return this;
}
@Override
public boolean release() {
return data.release();
}
@Override
public boolean release(int decrement) {
return data.release(decrement);
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
@ -110,7 +121,7 @@ public class DefaultSpdyDataFrame extends DefaultByteBufHolder implements SpdyDa
buf.append(')');
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Size = ");
if (refCnt() == 0) {

12
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyGoAwayFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -48,19 +48,17 @@ public class DefaultSpdyGoAwayFrame implements SpdyGoAwayFrame {
* Creates a new instance.
*
* @param lastGoodStreamId the Last-good-stream-ID of this frame
* @param status the getStatus of this frame
* @param status the status of this frame
*/
public DefaultSpdyGoAwayFrame(int lastGoodStreamId, SpdySessionStatus status) {
setLastGoodStreamId(lastGoodStreamId);
setStatus(status);
}
@Override
public int getLastGoodStreamId() {
return lastGoodStreamId;
}
@Override
public SpdyGoAwayFrame setLastGoodStreamId(int lastGoodStreamId) {
if (lastGoodStreamId < 0) {
throw new IllegalArgumentException("Last-good-stream-ID"
@ -70,12 +68,10 @@ public class DefaultSpdyGoAwayFrame implements SpdyGoAwayFrame {
return this;
}
@Override
public SpdySessionStatus getStatus() {
return status;
}
@Override
public SpdyGoAwayFrame setStatus(SpdySessionStatus status) {
this.status = status;
return this;
@ -87,10 +83,10 @@ public class DefaultSpdyGoAwayFrame implements SpdyGoAwayFrame {
buf.append(getClass().getSimpleName());
buf.append(StringUtil.NEWLINE);
buf.append("--> Last-good-stream-ID = ");
buf.append(lastGoodStreamId);
buf.append(getLastGoodStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Status: ");
buf.append(status.toString());
buf.append(getStatus().toString());
return buf.toString();
}
}

61
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyHeaderBlock.java
View File

@ -1,61 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
import io.netty.util.internal.StringUtil;
import java.util.Map;
/**
* The default {@link SpdyHeaderBlock} implementation.
*/
public class DefaultSpdyHeaderBlock implements SpdyHeaderBlock {
private boolean invalid;
private final SpdyHeaders headers = new DefaultSpdyHeaders();
/**
* Creates a new instance.
*/
protected DefaultSpdyHeaderBlock() {
}
@Override
public boolean isInvalid() {
return invalid;
}
@Override
public SpdyHeaderBlock setInvalid() {
invalid = true;
return this;
}
@Override
public SpdyHeaders headers() {
return headers;
}
protected void appendHeaders(StringBuilder buf) {
for (Map.Entry<String, String> e: headers().entries()) {
buf.append(" ");
buf.append(e.getKey());
buf.append(": ");
buf.append(e.getValue());
buf.append(StringUtil.NEWLINE);
}
}
}

52
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyHeadersFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -15,17 +15,18 @@
*/
package io.netty.handler.codec.spdy;
import java.util.Map;
import io.netty.util.internal.StringUtil;
/**
* The default {@link SpdyHeadersFrame} implementation.
*/
public class DefaultSpdyHeadersFrame extends DefaultSpdyHeaderBlock
public class DefaultSpdyHeadersFrame extends DefaultSpdyStreamFrame
implements SpdyHeadersFrame {
private int streamId;
private boolean last;
private boolean invalid;
private final SpdyHeaders headers = new DefaultSpdyHeaders();
/**
* Creates a new instance.
@ -33,41 +34,34 @@ public class DefaultSpdyHeadersFrame extends DefaultSpdyHeaderBlock
* @param streamId the Stream-ID of this frame
*/
public DefaultSpdyHeadersFrame(int streamId) {
setStreamId(streamId);
}
@Override
public int getStreamId() {
return streamId;
super(streamId);
}
@Override
public SpdyHeadersFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
super.setStreamId(streamId);
return this;
}
@Override
public boolean isLast() {
return last;
}
@Override
public SpdyHeadersFrame setLast(boolean last) {
this.last = last;
super.setLast(last);
return this;
}
@Override
public boolean isInvalid() {
return invalid;
}
public SpdyHeadersFrame setInvalid() {
super.setInvalid();
invalid = true;
return this;
}
public SpdyHeaders headers() {
return headers;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
@ -77,7 +71,7 @@ public class DefaultSpdyHeadersFrame extends DefaultSpdyHeaderBlock
buf.append(')');
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Headers:");
buf.append(StringUtil.NEWLINE);
@ -87,4 +81,14 @@ public class DefaultSpdyHeadersFrame extends DefaultSpdyHeaderBlock
buf.setLength(buf.length() - StringUtil.NEWLINE.length());
return buf.toString();
}
protected void appendHeaders(StringBuilder buf) {
for (Map.Entry<String, String> e: headers().entries()) {
buf.append(" ");
buf.append(e.getKey());
buf.append(": ");
buf.append(e.getValue());
buf.append(StringUtil.NEWLINE);
}
}
}

27
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyNoOpFrame.java
View File

@ -1,27 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
/**
* The default {@link SpdyNoOpFrame} implementation.
*/
public class DefaultSpdyNoOpFrame implements SpdyNoOpFrame {
@Override
public String toString() {
return getClass().getSimpleName();
}
}

6
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyPingFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -33,12 +33,10 @@ public class DefaultSpdyPingFrame implements SpdyPingFrame {
setId(id);
}
@Override
public int getId() {
return id;
}
@Override
public SpdyPingFrame setId(int id) {
this.id = id;
return this;
@ -50,7 +48,7 @@ public class DefaultSpdyPingFrame implements SpdyPingFrame {
buf.append(getClass().getSimpleName());
buf.append(StringUtil.NEWLINE);
buf.append("--> ID = ");
buf.append(id);
buf.append(getId());
return buf.toString();
}
}

31
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyRstStreamFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -20,9 +20,9 @@ import io.netty.util.internal.StringUtil;
/**
* The default {@link SpdyRstStreamFrame} implementation.
*/
public class DefaultSpdyRstStreamFrame implements SpdyRstStreamFrame {
public class DefaultSpdyRstStreamFrame extends DefaultSpdyStreamFrame
implements SpdyRstStreamFrame {
private int streamId;
private SpdyStreamStatus status;
/**
@ -39,34 +39,29 @@ public class DefaultSpdyRstStreamFrame implements SpdyRstStreamFrame {
* Creates a new instance.
*
* @param streamId the Stream-ID of this frame
* @param status the getStatus of this frame
* @param status the status of this frame
*/
public DefaultSpdyRstStreamFrame(int streamId, SpdyStreamStatus status) {
setStreamId(streamId);
super(streamId);
setStatus(status);
}
@Override
public int getStreamId() {
return streamId;
}
@Override
public SpdyRstStreamFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
super.setStreamId(streamId);
return this;
}
@Override
public SpdyRstStreamFrame setLast(boolean last) {
super.setLast(last);
return this;
}
public SpdyStreamStatus getStatus() {
return status;
}
@Override
public SpdyRstStreamFrame setStatus(SpdyStreamStatus status) {
this.status = status;
return this;
@ -78,10 +73,10 @@ public class DefaultSpdyRstStreamFrame implements SpdyRstStreamFrame {
buf.append(getClass().getSimpleName());
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Status: ");
buf.append(status.toString());
buf.append(getStatus().toString());
return buf.toString();
}
}

56
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyStreamFrame.java Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
/**
* The default {@link SpdyStreamFrame} implementation.
*/
public abstract class DefaultSpdyStreamFrame implements SpdyStreamFrame {
private int streamId;
private boolean last;
/**
* Creates a new instance.
*
* @param streamId the Stream-ID of this frame
*/
protected DefaultSpdyStreamFrame(int streamId) {
setStreamId(streamId);
}
public int getStreamId() {
return streamId;
}
public SpdyStreamFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
return this;
}
public boolean isLast() {
return last;
}
public SpdyStreamFrame setLast(boolean last) {
this.last = last;
return this;
}
}

29
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdySynReplyFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -20,44 +20,27 @@ import io.netty.util.internal.StringUtil;
/**
* The default {@link SpdySynReplyFrame} implementation.
*/
public class DefaultSpdySynReplyFrame extends DefaultSpdyHeaderBlock
public class DefaultSpdySynReplyFrame extends DefaultSpdyHeadersFrame
implements SpdySynReplyFrame {
private int streamId;
private boolean last;
/**
* Creates a new instance.
*
* @param streamId the Stream-ID of this frame
*/
public DefaultSpdySynReplyFrame(int streamId) {
setStreamId(streamId);
}
@Override
public int getStreamId() {
return streamId;
super(streamId);
}
@Override
public SpdySynReplyFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
super.setStreamId(streamId);
return this;
}
@Override
public boolean isLast() {
return last;
}
@Override
public SpdySynReplyFrame setLast(boolean last) {
this.last = last;
super.setLast(last);
return this;
}
@ -76,7 +59,7 @@ public class DefaultSpdySynReplyFrame extends DefaultSpdyHeaderBlock
buf.append(')');
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Headers:");
buf.append(StringUtil.NEWLINE);

50
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdySynStreamFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -20,13 +20,11 @@ import io.netty.util.internal.StringUtil;
/**
* The default {@link SpdySynStreamFrame} implementation.
*/
public class DefaultSpdySynStreamFrame extends DefaultSpdyHeaderBlock
public class DefaultSpdySynStreamFrame extends DefaultSpdyHeadersFrame
implements SpdySynStreamFrame {
private int streamId;
private int associatedToStreamId;
private byte priority;
private boolean last;
private boolean unidirectional;
/**
@ -38,23 +36,26 @@ public class DefaultSpdySynStreamFrame extends DefaultSpdyHeaderBlock
*/
public DefaultSpdySynStreamFrame(
int streamId, int associatedToStreamId, byte priority) {
setStreamId(streamId);
super(streamId);
setAssociatedToStreamId(associatedToStreamId);
setPriority(priority);
}
@Override
public int getStreamId() {
return streamId;
public SpdySynStreamFrame setStreamId(int streamId) {
super.setStreamId(streamId);
return this;
}
@Override
public SpdySynStreamFrame setStreamId(int streamId) {
if (streamId <= 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
}
this.streamId = streamId;
public SpdySynStreamFrame setLast(boolean last) {
super.setLast(last);
return this;
}
@Override
public SpdySynStreamFrame setInvalid() {
super.setInvalid();
return this;
}
@ -89,17 +90,6 @@ public class DefaultSpdySynStreamFrame extends DefaultSpdyHeaderBlock
return this;
}
@Override
public boolean isLast() {
return last;
}
@Override
public SpdySynStreamFrame setLast(boolean last) {
this.last = last;
return this;
}
@Override
public boolean isUnidirectional() {
return unidirectional;
@ -111,12 +101,6 @@ public class DefaultSpdySynStreamFrame extends DefaultSpdyHeaderBlock
return this;
}
@Override
public SpdySynStreamFrame setInvalid() {
super.setInvalid();
return this;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
@ -128,15 +112,15 @@ public class DefaultSpdySynStreamFrame extends DefaultSpdyHeaderBlock
buf.append(')');
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
if (associatedToStreamId != 0) {
buf.append("--> Associated-To-Stream-ID = ");
buf.append(associatedToStreamId);
buf.append(getAssociatedToStreamId());
buf.append(StringUtil.NEWLINE);
}
buf.append("--> Priority = ");
buf.append(priority);
buf.append(getPriority());
buf.append(StringUtil.NEWLINE);
buf.append("--> Headers:");
buf.append(StringUtil.NEWLINE);

10
codec-http/src/main/java/io/netty/handler/codec/spdy/DefaultSpdyWindowUpdateFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -43,9 +43,9 @@ public class DefaultSpdyWindowUpdateFrame implements SpdyWindowUpdateFrame {
@Override
public SpdyWindowUpdateFrame setStreamId(int streamId) {
if (streamId <= 0) {
if (streamId < 0) {
throw new IllegalArgumentException(
"Stream-ID must be positive: " + streamId);
"Stream-ID cannot be negative: " + streamId);
}
this.streamId = streamId;
return this;
@ -73,10 +73,10 @@ public class DefaultSpdyWindowUpdateFrame implements SpdyWindowUpdateFrame {
buf.append(getClass().getSimpleName());
buf.append(StringUtil.NEWLINE);
buf.append("--> Stream-ID = ");
buf.append(streamId);
buf.append(getStreamId());
buf.append(StringUtil.NEWLINE);
buf.append("--> Delta-Window-Size = ");
buf.append(deltaWindowSize);
buf.append(getDeltaWindowSize());
return buf.toString();
}
}

23
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyControlFrame.java
View File

@ -1,23 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol Control Frame
*/
public interface SpdyControlFrame extends SpdyDataOrControlFrame {
// Tag interface
}

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyDataFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -20,9 +20,9 @@ import io.netty.buffer.ByteBufHolder;
import io.netty.buffer.Unpooled;
/**
* A SPDY Protocol Data Frame
* A SPDY Protocol DATA Frame
*/
public interface SpdyDataFrame extends ByteBufHolder, SpdyStreamFrame, SpdyDataOrControlFrame {
public interface SpdyDataFrame extends ByteBufHolder, SpdyStreamFrame {
@Override
SpdyDataFrame setStreamId(int streamID);

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyDataOrControlFrame.java → codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrame.java
View File

@ -13,9 +13,11 @@
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
public interface SpdyDataOrControlFrame {
/**
* A SPDY Protocol Frame
*/
public interface SpdyFrame {
// Tag interface
}

3
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameCodec.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -21,7 +21,6 @@ import io.netty.channel.CombinedChannelDuplexHandler;
* A combination of {@link SpdyFrameDecoder} and {@link SpdyFrameEncoder}.
*/
public final class SpdyFrameCodec extends CombinedChannelDuplexHandler<SpdyFrameDecoder, SpdyFrameEncoder> {
/**
* Creates a new instance with the specified {@code version} and
* the default decoder and encoder options

48
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameDecoder.java
View File

@ -25,7 +25,7 @@ import io.netty.handler.codec.TooLongFrameException;
import static io.netty.handler.codec.spdy.SpdyCodecUtil.*;
/**
* Decodes {@link ByteBuf}s into SPDY Data and Control Frames.
* Decodes {@link ByteBuf}s into SPDY Frames.
*/
public class SpdyFrameDecoder extends ByteToMessageDecoder {
@ -37,7 +37,7 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
private State state;
private SpdySettingsFrame spdySettingsFrame;
private SpdyHeaderBlock spdyHeaderBlock;
private SpdyHeadersFrame spdyHeadersFrame;
// SPDY common header fields
private byte flags;
@ -221,12 +221,12 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
case READ_HEADER_BLOCK_FRAME:
try {
spdyHeaderBlock = readHeaderBlockFrame(buffer);
if (spdyHeaderBlock != null) {
spdyHeadersFrame = readHeaderBlockFrame(buffer);
if (spdyHeadersFrame != null) {
if (length == 0) {
state = State.READ_COMMON_HEADER;
Object frame = spdyHeaderBlock;
spdyHeaderBlock = null;
Object frame = spdyHeadersFrame;
spdyHeadersFrame = null;
out.add(frame);
return;
}
@ -247,15 +247,15 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
decodeHeaderBlock(buffer.readSlice(compressedBytes));
} catch (Exception e) {
state = State.FRAME_ERROR;
spdyHeaderBlock = null;
spdyHeadersFrame = null;
decompressed = null;
ctx.fireExceptionCaught(e);
return;
}
if (spdyHeaderBlock != null && spdyHeaderBlock.isInvalid()) {
Object frame = spdyHeaderBlock;
spdyHeaderBlock = null;
if (spdyHeadersFrame != null && spdyHeadersFrame.isInvalid()) {
Object frame = spdyHeadersFrame;
spdyHeadersFrame = null;
decompressed = null;
if (length == 0) {
state = State.READ_COMMON_HEADER;
@ -265,8 +265,8 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
}
if (length == 0) {
Object frame = spdyHeaderBlock;
spdyHeaderBlock = null;
Object frame = spdyHeadersFrame;
spdyHeadersFrame = null;
state = State.READ_COMMON_HEADER;
out.add(frame);
return;
@ -436,7 +436,7 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
}
}
private SpdyHeaderBlock readHeaderBlockFrame(ByteBuf buffer) {
private SpdyHeadersFrame readHeaderBlockFrame(ByteBuf buffer) {
int minLength;
int streamID;
switch (type) {
@ -567,7 +567,7 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
headerBlockDecompressor.setInput(buffer);
headerBlockDecompressor.decode(decompressed);
if (spdyHeaderBlock == null) {
if (spdyHeadersFrame == null) {
// Only decompressing data to keep decompression context in sync
decompressed = null;
return;
@ -582,7 +582,7 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
}
numHeaders = readLengthField();
if (numHeaders < 0) {
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
}
}
@ -601,7 +601,7 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
// Recipients of a zero-length name must issue a stream error
if (nameLength <= 0) {
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
}
headerSize += nameLength;
@ -621,8 +621,8 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
String name = new String(nameBytes, "UTF-8");
// Check for identically named headers
if (spdyHeaderBlock.headers().contains(name)) {
spdyHeaderBlock.setInvalid();
if (spdyHeadersFrame.headers().contains(name)) {
spdyHeadersFrame.setInvalid();
return;
}
@ -636,17 +636,17 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
// Recipients of illegal value fields must issue a stream error
if (valueLength < 0) {
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
}
// SPDY/3 allows zero-length (empty) header values
if (valueLength == 0) {
if (version < 3) {
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
} else {
spdyHeaderBlock.headers().add(name, "");
spdyHeadersFrame.headers().add(name, "");
numHeaders --;
this.headerSize = headerSize;
continue;
@ -678,16 +678,16 @@ public class SpdyFrameDecoder extends ByteToMessageDecoder {
if (index < valueBytes.length && valueBytes[index + 1] == (byte) 0) {
// Received multiple, in-sequence NULL characters
// Recipients of illegal value fields must issue a stream error
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
}
String value = new String(valueBytes, offset, index - offset, "UTF-8");
try {
spdyHeaderBlock.headers().add(name, value);
spdyHeadersFrame.headers().add(name, value);
} catch (IllegalArgumentException e) {
// Name contains NULL or non-ascii characters
spdyHeaderBlock.setInvalid();
spdyHeadersFrame.setInvalid();
return;
}
index ++;

17
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameEncoder.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -29,9 +29,9 @@ import java.util.Set;
import static io.netty.handler.codec.spdy.SpdyCodecUtil.*;
/**
* Encodes a SPDY Data or Control Frame into a {@link ByteBuf}.
* Encodes a SPDY Frame into a {@link ByteBuf}.
*/
public class SpdyFrameEncoder extends MessageToByteEncoder<SpdyDataOrControlFrame> {
public class SpdyFrameEncoder extends MessageToByteEncoder<SpdyFrame> {
private final int version;
private volatile boolean finished;
@ -76,7 +76,7 @@ public class SpdyFrameEncoder extends MessageToByteEncoder<SpdyDataOrControlFram
}
@Override
protected void encode(ChannelHandlerContext ctx, SpdyDataOrControlFrame msg, ByteBuf out) throws Exception {
protected void encode(ChannelHandlerContext ctx, SpdyFrame msg, ByteBuf out) throws Exception {
if (msg instanceof SpdyDataFrame) {
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) msg;
@ -202,13 +202,6 @@ public class SpdyFrameEncoder extends MessageToByteEncoder<SpdyDataOrControlFram
out.writeInt(spdySettingsFrame.getValue(id));
}
} else if (msg instanceof SpdyNoOpFrame) {
out.ensureWritable(SPDY_HEADER_SIZE);
out.writeShort(version | 0x8000);
out.writeShort(SPDY_NOOP_FRAME);
out.writeInt(0);
} else if (msg instanceof SpdyPingFrame) {
SpdyPingFrame spdyPingFrame = (SpdyPingFrame) msg;
@ -285,7 +278,7 @@ public class SpdyFrameEncoder extends MessageToByteEncoder<SpdyDataOrControlFram
}
}
private static ByteBuf encodeHeaderBlock(int version, SpdyHeaderBlock headerFrame)
private static ByteBuf encodeHeaderBlock(int version, SpdyHeadersFrame headerFrame)
throws Exception {
Set<String> names = headerFrame.headers().names();
int numHeaders = names.size();

10
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyGoAwayFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol GOAWAY Control Frame
* A SPDY Protocol GOAWAY Frame
*/
public interface SpdyGoAwayFrame extends SpdyControlFrame {
public interface SpdyGoAwayFrame extends SpdyFrame {
/**
* Returns the Last-good-stream-ID of this frame.
@ -32,12 +32,12 @@ public interface SpdyGoAwayFrame extends SpdyControlFrame {
SpdyGoAwayFrame setLastGoodStreamId(int lastGoodStreamId);
/**
* Returns the getStatus of this frame.
* Returns the status of this frame.
*/
SpdySessionStatus getStatus();
/**
* Sets the getStatus of this frame.
* Sets the status of this frame.
*/
SpdyGoAwayFrame setStatus(SpdySessionStatus status);
}

42
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaderBlock.java
View File

@ -1,42 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
/**
* A SPDY Name/Value Header Block which provides common properties for
* {@link SpdySynStreamFrame}, {@link SpdySynReplyFrame}, and
* {@link SpdyHeadersFrame}.
* @see SpdyHeaders
*/
public interface SpdyHeaderBlock {
/**
* Returns {@code true} if this header block is invalid.
* A RST_STREAM frame with code PROTOCOL_ERROR should be sent.
*/
boolean isInvalid();
/**
* Marks this header block as invalid.
*/
SpdyHeaderBlock setInvalid();
/**
* Returns the {@link SpdyHeaders}.
*/
SpdyHeaders headers();
}

132
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaders.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -27,7 +27,7 @@ import java.util.Set;
/**
* Provides the constants for the standard SPDY HTTP header names and commonly
* used utility methods that access a {@link SpdyHeaderBlock}.
* used utility methods that access a {@link SpdyHeadersFrame}.
*/
public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>> {
@ -166,8 +166,8 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
*
* @return the header value or {@code null} if there is no such header
*/
public static String getHeader(SpdyHeaderBlock block, String name) {
return block.headers().get(name);
public static String getHeader(SpdyHeadersFrame frame, String name) {
return frame.headers().get(name);
}
/**
@ -178,8 +178,8 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
* @return the header value or the {@code defaultValue} if there is no such
* header
*/
public static String getHeader(SpdyHeaderBlock block, String name, String defaultValue) {
String value = block.headers().get(name);
public static String getHeader(SpdyHeadersFrame frame, String name, String defaultValue) {
String value = frame.headers().get(name);
if (value == null) {
return defaultValue;
}
@ -190,66 +190,66 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
* Sets a new header with the specified name and value. If there is an
* existing header with the same name, the existing header is removed.
*/
public static void setHeader(SpdyHeaderBlock block, String name, Object value) {
block.headers().set(name, value);
public static void setHeader(SpdyHeadersFrame frame, String name, Object value) {
frame.headers().set(name, value);
}
/**
* Sets a new header with the specified name and values. If there is an
* existing header with the same name, the existing header is removed.
*/
public static void setHeader(SpdyHeaderBlock block, String name, Iterable<?> values) {
block.headers().set(name, values);
public static void setHeader(SpdyHeadersFrame frame, String name, Iterable<?> values) {
frame.headers().set(name, values);
}
/**
* Adds a new header with the specified name and value.
*/
public static void addHeader(SpdyHeaderBlock block, String name, Object value) {
block.headers().add(name, value);
public static void addHeader(SpdyHeadersFrame frame, String name, Object value) {
frame.headers().add(name, value);
}
/**
* Removes the SPDY host header.
*/
public static void removeHost(SpdyHeaderBlock block) {
block.headers().remove(HttpNames.HOST);
public static void removeHost(SpdyHeadersFrame frame) {
frame.headers().remove(HttpNames.HOST);
}
/**
* Returns the SPDY host header.
*/
public static String getHost(SpdyHeaderBlock block) {
return block.headers().get(HttpNames.HOST);
public static String getHost(SpdyHeadersFrame frame) {
return frame.headers().get(HttpNames.HOST);
}
/**
* Set the SPDY host header.
*/
public static void setHost(SpdyHeaderBlock block, String host) {
block.headers().set(HttpNames.HOST, host);
public static void setHost(SpdyHeadersFrame frame, String host) {
frame.headers().set(HttpNames.HOST, host);
}
/**
* Removes the HTTP method header.
*/
public static void removeMethod(int spdyVersion, SpdyHeaderBlock block) {
public static void removeMethod(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
block.headers().remove(Spdy2HttpNames.METHOD);
frame.headers().remove(Spdy2HttpNames.METHOD);
} else {
block.headers().remove(HttpNames.METHOD);
frame.headers().remove(HttpNames.METHOD);
}
}
/**
* Returns the {@link HttpMethod} represented by the HTTP method header.
*/
public static HttpMethod getMethod(int spdyVersion, SpdyHeaderBlock block) {
public static HttpMethod getMethod(int spdyVersion, SpdyHeadersFrame frame) {
try {
if (spdyVersion < 3) {
return HttpMethod.valueOf(block.headers().get(Spdy2HttpNames.METHOD));
return HttpMethod.valueOf(frame.headers().get(Spdy2HttpNames.METHOD));
} else {
return HttpMethod.valueOf(block.headers().get(HttpNames.METHOD));
return HttpMethod.valueOf(frame.headers().get(HttpNames.METHOD));
}
} catch (Exception e) {
return null;
@ -259,68 +259,68 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
/**
* Sets the HTTP method header.
*/
public static void setMethod(int spdyVersion, SpdyHeaderBlock block, HttpMethod method) {
public static void setMethod(int spdyVersion, SpdyHeadersFrame frame, HttpMethod method) {
if (spdyVersion < 3) {
block.headers().set(Spdy2HttpNames.METHOD, method.name());
frame.headers().set(Spdy2HttpNames.METHOD, method.name());
} else {
block.headers().set(HttpNames.METHOD, method.name());
frame.headers().set(HttpNames.METHOD, method.name());
}
}
/**
* Removes the URL scheme header.
*/
public static void removeScheme(int spdyVersion, SpdyHeaderBlock block) {
public static void removeScheme(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 2) {
block.headers().remove(Spdy2HttpNames.SCHEME);
frame.headers().remove(Spdy2HttpNames.SCHEME);
} else {
block.headers().remove(HttpNames.SCHEME);
frame.headers().remove(HttpNames.SCHEME);
}
}
/**
* Returns the value of the URL scheme header.
*/
public static String getScheme(int spdyVersion, SpdyHeaderBlock block) {
public static String getScheme(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
return block.headers().get(Spdy2HttpNames.SCHEME);
return frame.headers().get(Spdy2HttpNames.SCHEME);
} else {
return block.headers().get(HttpNames.SCHEME);
return frame.headers().get(HttpNames.SCHEME);
}
}
/**
* Sets the URL scheme header.
*/
public static void setScheme(int spdyVersion, SpdyHeaderBlock block, String scheme) {
public static void setScheme(int spdyVersion, SpdyHeadersFrame frame, String scheme) {
if (spdyVersion < 3) {
block.headers().set(Spdy2HttpNames.SCHEME, scheme);
frame.headers().set(Spdy2HttpNames.SCHEME, scheme);
} else {
block.headers().set(HttpNames.SCHEME, scheme);
frame.headers().set(HttpNames.SCHEME, scheme);
}
}
/**
* Removes the HTTP response status header.
*/
public static void removeStatus(int spdyVersion, SpdyHeaderBlock block) {
public static void removeStatus(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
block.headers().remove(Spdy2HttpNames.STATUS);
frame.headers().remove(Spdy2HttpNames.STATUS);
} else {
block.headers().remove(HttpNames.STATUS);
frame.headers().remove(HttpNames.STATUS);
}
}
/**
* Returns the {@link HttpResponseStatus} represented by the HTTP response status header.
*/
public static HttpResponseStatus getStatus(int spdyVersion, SpdyHeaderBlock block) {
public static HttpResponseStatus getStatus(int spdyVersion, SpdyHeadersFrame frame) {
try {
String status;
if (spdyVersion < 3) {
status = block.headers().get(Spdy2HttpNames.STATUS);
status = frame.headers().get(Spdy2HttpNames.STATUS);
} else {
status = block.headers().get(HttpNames.STATUS);
status = frame.headers().get(HttpNames.STATUS);
}
int space = status.indexOf(' ');
if (space == -1) {
@ -343,67 +343,67 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
/**
* Sets the HTTP response status header.
*/
public static void setStatus(int spdyVersion, SpdyHeaderBlock block, HttpResponseStatus status) {
public static void setStatus(int spdyVersion, SpdyHeadersFrame frame, HttpResponseStatus status) {
if (spdyVersion < 3) {
block.headers().set(Spdy2HttpNames.STATUS, status.toString());
frame.headers().set(Spdy2HttpNames.STATUS, status.toString());
} else {
block.headers().set(HttpNames.STATUS, status.toString());
frame.headers().set(HttpNames.STATUS, status.toString());
}
}
/**
* Removes the URL path header.
*/
public static void removeUrl(int spdyVersion, SpdyHeaderBlock block) {
public static void removeUrl(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
block.headers().remove(Spdy2HttpNames.URL);
frame.headers().remove(Spdy2HttpNames.URL);
} else {
block.headers().remove(HttpNames.PATH);
frame.headers().remove(HttpNames.PATH);
}
}
/**
* Returns the value of the URL path header.
*/
public static String getUrl(int spdyVersion, SpdyHeaderBlock block) {
public static String getUrl(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
return block.headers().get(Spdy2HttpNames.URL);
return frame.headers().get(Spdy2HttpNames.URL);
} else {
return block.headers().get(HttpNames.PATH);
return frame.headers().get(HttpNames.PATH);
}
}
/**
* Sets the URL path header.
*/
public static void setUrl(int spdyVersion, SpdyHeaderBlock block, String path) {
public static void setUrl(int spdyVersion, SpdyHeadersFrame frame, String path) {
if (spdyVersion < 3) {
block.headers().set(Spdy2HttpNames.URL, path);
frame.headers().set(Spdy2HttpNames.URL, path);
} else {
block.headers().set(HttpNames.PATH, path);
frame.headers().set(HttpNames.PATH, path);
}
}
/**
* Removes the HTTP version header.
*/
public static void removeVersion(int spdyVersion, SpdyHeaderBlock block) {
public static void removeVersion(int spdyVersion, SpdyHeadersFrame frame) {
if (spdyVersion < 3) {
block.headers().remove(Spdy2HttpNames.VERSION);
frame.headers().remove(Spdy2HttpNames.VERSION);
} else {
block.headers().remove(HttpNames.VERSION);
frame.headers().remove(HttpNames.VERSION);
}
}
/**
* Returns the {@link HttpVersion} represented by the HTTP version header.
*/
public static HttpVersion getVersion(int spdyVersion, SpdyHeaderBlock block) {
public static HttpVersion getVersion(int spdyVersion, SpdyHeadersFrame frame) {
try {
if (spdyVersion < 3) {
return HttpVersion.valueOf(block.headers().get(Spdy2HttpNames.VERSION));
return HttpVersion.valueOf(frame.headers().get(Spdy2HttpNames.VERSION));
} else {
return HttpVersion.valueOf(block.headers().get(HttpNames.VERSION));
return HttpVersion.valueOf(frame.headers().get(HttpNames.VERSION));
}
} catch (Exception e) {
return null;
@ -413,11 +413,11 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
/**
* Sets the HTTP version header.
*/
public static void setVersion(int spdyVersion, SpdyHeaderBlock block, HttpVersion httpVersion) {
public static void setVersion(int spdyVersion, SpdyHeadersFrame frame, HttpVersion httpVersion) {
if (spdyVersion < 3) {
block.headers().set(Spdy2HttpNames.VERSION, httpVersion.text());
frame.headers().set(Spdy2HttpNames.VERSION, httpVersion.text());
} else {
block.headers().set(HttpNames.VERSION, httpVersion.text());
frame.headers().set(HttpNames.VERSION, httpVersion.text());
}
}
@Override
@ -443,7 +443,7 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
public abstract List<String> getAll(String name);
/**
* Returns all header names and values that this block contains.
* Returns all header names and values that this frame contains.
*
* @return the {@link List} of the header name-value pairs. An empty list
* if there is no header in this message.
@ -457,7 +457,7 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
public abstract boolean contains(String name);
/**
* Returns the {@link Set} of all header names that this block contains.
* Returns the {@link Set} of all header names that this frame contains.
*/
public abstract Set<String> names();
@ -490,7 +490,7 @@ public abstract class SpdyHeaders implements Iterable<Map.Entry<String, String>>
public abstract SpdyHeaders remove(String name);
/**
* Removes all headers from this block.
* Removes all headers from this frame.
*/
public abstract SpdyHeaders clear();

26
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeadersFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,17 +16,29 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol HEADERS Control Frame
* A SPDY Protocol HEADERS Frame
*/
public interface SpdyHeadersFrame extends SpdyHeaderBlock, SpdyControlFrame, SpdyStreamFrame {
public interface SpdyHeadersFrame extends SpdyStreamFrame {
/**
* Returns {@code true} if this header block is invalid.
* A RST_STREAM frame with code PROTOCOL_ERROR should be sent.
*/
boolean isInvalid();
/**
* Marks this header block as invalid.
*/
SpdyHeadersFrame setInvalid();
/**
* Returns the {@link SpdyHeaders}.
*/
SpdyHeaders headers();
@Override
SpdyHeadersFrame setStreamId(int streamID);
@Override
SpdyHeadersFrame setLast(boolean last);
@Override
SpdyHeadersFrame setInvalid();
}

3
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHttpCodec.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -22,7 +22,6 @@ import io.netty.channel.CombinedChannelDuplexHandler;
*/
public final class SpdyHttpCodec
extends CombinedChannelDuplexHandler<SpdyHttpDecoder, SpdyHttpEncoder> {
/**
* Creates a new instance with the specified decoder options.
*/

10
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHttpDecoder.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -37,7 +37,7 @@ import java.util.Map;
* Decodes {@link SpdySynStreamFrame}s, {@link SpdySynReplyFrame}s,
* and {@link SpdyDataFrame}s into {@link FullHttpRequest}s and {@link FullHttpResponse}s.
*/
public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyDataOrControlFrame> {
public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyFrame> {
private final int spdyVersion;
private final int maxContentLength;
@ -91,7 +91,7 @@ public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyDataOrControlFr
}
@Override
protected void decode(ChannelHandlerContext ctx, SpdyDataOrControlFrame msg, MessageList<Object> out)
protected void decode(ChannelHandlerContext ctx, SpdyFrame msg, MessageList<Object> out)
throws Exception {
if (msg instanceof SpdySynStreamFrame) {
@ -252,7 +252,7 @@ public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyDataOrControlFr
}
}
private static FullHttpRequest createHttpRequest(int spdyVersion, SpdyHeaderBlock requestFrame)
private static FullHttpRequest createHttpRequest(int spdyVersion, SpdyHeadersFrame requestFrame)
throws Exception {
// Create the first line of the request from the name/value pairs
HttpMethod method = SpdyHeaders.getMethod(spdyVersion, requestFrame);
@ -287,7 +287,7 @@ public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyDataOrControlFr
return req;
}
private static FullHttpResponse createHttpResponse(int spdyVersion, SpdyHeaderBlock responseFrame)
private static FullHttpResponse createHttpResponse(int spdyVersion, SpdyHeadersFrame responseFrame)
throws Exception {
// Create the first line of the response from the name/value pairs
HttpResponseStatus status = SpdyHeaders.getStatus(spdyVersion, responseFrame);

2
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHttpEncoder.java
View File

@ -266,7 +266,7 @@ public class SpdyHttpEncoder extends MessageToMessageEncoder<HttpObject> {
int streamID = SpdyHttpHeaders.getStreamId(httpResponse);
SpdyHttpHeaders.removeStreamId(httpResponse);
// The Connection, Keep-Alive, Proxy-Connection, and Transfer-ENcoding
// The Connection, Keep-Alive, Proxy-Connection, and Transfer-Encoding
// headers are not valid and MUST not be sent.
httpResponse.headers().remove(HttpHeaders.Names.CONNECTION);
httpResponse.headers().remove("Keep-Alive");

23
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyNoOpFrame.java
View File

@ -1,23 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol NOOP Control Frame
*/
public interface SpdyNoOpFrame extends SpdyControlFrame {
// Tag interface
}

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyPingFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol PING Control Frame
* A SPDY Protocol PING Frame
*/
public interface SpdyPingFrame extends SpdyControlFrame {
public interface SpdyPingFrame extends SpdyFrame {
/**
* Returns the ID of this frame.

28
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyRstStreamFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,27 +16,23 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol RST_STREAM Control Frame
* A SPDY Protocol RST_STREAM Frame
*/
public interface SpdyRstStreamFrame extends SpdyControlFrame {
public interface SpdyRstStreamFrame extends SpdyStreamFrame {
/**
* Returns the Stream-ID of this frame.
*/
int getStreamId();
/**
* Sets the Stream-ID of this frame. The Stream-ID must be positive.
*/
SpdyControlFrame setStreamId(int streamID);
/**
* Returns the getStatus of this frame.
* Returns the status of this frame.
*/
SpdyStreamStatus getStatus();
/**
* Sets the getStatus of this frame.
* Sets the status of this frame.
*/
SpdyControlFrame setStatus(SpdyStreamStatus status);
SpdyRstStreamFrame setStatus(SpdyStreamStatus status);
@Override
SpdyRstStreamFrame setStreamId(int streamId);
@Override
SpdyRstStreamFrame setLast(boolean last);
}

177
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdySessionHandler.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -135,27 +135,29 @@ public class SpdySessionHandler
*/
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) msg;
int streamID = spdyDataFrame.getStreamId();
int streamId = spdyDataFrame.getStreamId();
// Check if we received a data frame for a Stream-ID which is not open
if (!spdySession.isActiveStream(streamID)) {
if (streamID <= lastGoodStreamId) {
issueStreamError(ctx, streamID, SpdyStreamStatus.PROTOCOL_ERROR, out);
if (!spdySession.isActiveStream(streamId)) {
if (streamId <= lastGoodStreamId) {
issueStreamError(ctx, streamId, SpdyStreamStatus.PROTOCOL_ERROR, out);
} else if (!sentGoAwayFrame) {
issueStreamError(ctx, streamID, SpdyStreamStatus.INVALID_STREAM, out);
issueStreamError(ctx, streamId, SpdyStreamStatus.INVALID_STREAM, out);
}
return;
}
// Check if we received a data frame for a stream which is half-closed
if (spdySession.isRemoteSideClosed(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.STREAM_ALREADY_CLOSED, out);
if (spdySession.isRemoteSideClosed(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.STREAM_ALREADY_CLOSED, out);
return;
}
// Check if we received a data frame before receiving a SYN_REPLY
if (!isRemoteInitiatedID(streamID) && !spdySession.hasReceivedReply(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.PROTOCOL_ERROR, out);
if (!isRemoteInitiatedID(streamId) && !spdySession.hasReceivedReply(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.PROTOCOL_ERROR, out);
return;
}
@ -168,15 +170,15 @@ public class SpdySessionHandler
if (flowControl) {
// Update receive window size
int deltaWindowSize = -1 * spdyDataFrame.content().readableBytes();
int newWindowSize = spdySession.updateReceiveWindowSize(streamID, deltaWindowSize);
int newWindowSize = spdySession.updateReceiveWindowSize(streamId, deltaWindowSize);
// Window size can become negative if we sent a SETTINGS frame that reduces the
// size of the transfer window after the peer has written data frames.
// The value is bounded by the length that SETTINGS frame decrease the window.
// This difference is stored for the session when writing the SETTINGS frame
// and is cleared once we send a WINDOW_UPDATE frame.
if (newWindowSize < spdySession.getReceiveWindowSizeLowerBound(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.FLOW_CONTROL_ERROR, out);
if (newWindowSize < spdySession.getReceiveWindowSizeLowerBound(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.FLOW_CONTROL_ERROR, out);
return;
}
@ -184,7 +186,7 @@ public class SpdySessionHandler
// Send data frames upstream in initialReceiveWindowSize chunks
if (newWindowSize < 0) {
while (spdyDataFrame.content().readableBytes() > initialReceiveWindowSize) {
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamID,
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamId,
spdyDataFrame.content().readSlice(initialReceiveWindowSize).retain());
ctx.write(partialDataFrame);
}
@ -193,16 +195,16 @@ public class SpdySessionHandler
// Send a WINDOW_UPDATE frame if less than half the window size remains
if (newWindowSize <= initialReceiveWindowSize / 2 && !spdyDataFrame.isLast()) {
deltaWindowSize = initialReceiveWindowSize - newWindowSize;
spdySession.updateReceiveWindowSize(streamID, deltaWindowSize);
spdySession.updateReceiveWindowSize(streamId, deltaWindowSize);
SpdyWindowUpdateFrame spdyWindowUpdateFrame =
new DefaultSpdyWindowUpdateFrame(streamID, deltaWindowSize);
new DefaultSpdyWindowUpdateFrame(streamId, deltaWindowSize);
ctx.write(spdyWindowUpdateFrame);
}
}
// Close the remote side of the stream if this is the last frame
if (spdyDataFrame.isLast()) {
halfCloseStream(streamID, true);
halfCloseStream(streamId, true);
}
} else if (msg instanceof SpdySynStreamFrame) {
@ -222,18 +224,18 @@ public class SpdySessionHandler
*/
SpdySynStreamFrame spdySynStreamFrame = (SpdySynStreamFrame) msg;
int streamID = spdySynStreamFrame.getStreamId();
int streamId = spdySynStreamFrame.getStreamId();
// Check if we received a valid SYN_STREAM frame
if (spdySynStreamFrame.isInvalid() ||
!isRemoteInitiatedID(streamID) ||
spdySession.isActiveStream(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.PROTOCOL_ERROR, out);
!isRemoteInitiatedID(streamId) ||
spdySession.isActiveStream(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.PROTOCOL_ERROR, out);
return;
}
// Stream-IDs must be monotonically increasing
if (streamID <= lastGoodStreamId) {
if (streamId <= lastGoodStreamId) {
issueSessionError(ctx, SpdySessionStatus.PROTOCOL_ERROR);
return;
}
@ -242,8 +244,8 @@ public class SpdySessionHandler
byte priority = spdySynStreamFrame.getPriority();
boolean remoteSideClosed = spdySynStreamFrame.isLast();
boolean localSideClosed = spdySynStreamFrame.isUnidirectional();
if (!acceptStream(streamID, priority, remoteSideClosed, localSideClosed)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.REFUSED_STREAM, out);
if (!acceptStream(streamId, priority, remoteSideClosed, localSideClosed)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.REFUSED_STREAM, out);
return;
}
@ -257,27 +259,27 @@ public class SpdySessionHandler
*/
SpdySynReplyFrame spdySynReplyFrame = (SpdySynReplyFrame) msg;
int streamID = spdySynReplyFrame.getStreamId();
int streamId = spdySynReplyFrame.getStreamId();
// Check if we received a valid SYN_REPLY frame
if (spdySynReplyFrame.isInvalid() ||
isRemoteInitiatedID(streamID) ||
spdySession.isRemoteSideClosed(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.INVALID_STREAM, out);
isRemoteInitiatedID(streamId) ||
spdySession.isRemoteSideClosed(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.INVALID_STREAM, out);
return;
}
// Check if we have received multiple frames for the same Stream-ID
if (spdySession.hasReceivedReply(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.STREAM_IN_USE, out);
if (spdySession.hasReceivedReply(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.STREAM_IN_USE, out);
return;
}
spdySession.receivedReply(streamID);
spdySession.receivedReply(streamId);
// Close the remote side of the stream if this is the last frame
if (spdySynReplyFrame.isLast()) {
halfCloseStream(streamID, true);
halfCloseStream(streamId, true);
}
} else if (msg instanceof SpdyRstStreamFrame) {
@ -351,22 +353,22 @@ public class SpdySessionHandler
} else if (msg instanceof SpdyHeadersFrame) {
SpdyHeadersFrame spdyHeadersFrame = (SpdyHeadersFrame) msg;
int streamID = spdyHeadersFrame.getStreamId();
int streamId = spdyHeadersFrame.getStreamId();
// Check if we received a valid HEADERS frame
if (spdyHeadersFrame.isInvalid()) {
issueStreamError(ctx, streamID, SpdyStreamStatus.PROTOCOL_ERROR, out);
issueStreamError(ctx, streamId, SpdyStreamStatus.PROTOCOL_ERROR, out);
return;
}
if (spdySession.isRemoteSideClosed(streamID)) {
issueStreamError(ctx, streamID, SpdyStreamStatus.INVALID_STREAM, out);
if (spdySession.isRemoteSideClosed(streamId)) {
issueStreamError(ctx, streamId, SpdyStreamStatus.INVALID_STREAM, out);
return;
}
// Close the remote side of the stream if this is the last frame
if (spdyHeadersFrame.isLast()) {
halfCloseStream(streamID, true);
halfCloseStream(streamId, true);
}
} else if (msg instanceof SpdyWindowUpdateFrame) {
@ -383,21 +385,21 @@ public class SpdySessionHandler
if (flowControl) {
SpdyWindowUpdateFrame spdyWindowUpdateFrame = (SpdyWindowUpdateFrame) msg;
int streamID = spdyWindowUpdateFrame.getStreamId();
int streamId = spdyWindowUpdateFrame.getStreamId();
int deltaWindowSize = spdyWindowUpdateFrame.getDeltaWindowSize();
// Ignore frames for half-closed streams
if (spdySession.isLocalSideClosed(streamID)) {
if (spdySession.isLocalSideClosed(streamId)) {
return;
}
// Check for numerical overflow
if (spdySession.getSendWindowSize(streamID) > Integer.MAX_VALUE - deltaWindowSize) {
issueStreamError(ctx, streamID, SpdyStreamStatus.FLOW_CONTROL_ERROR, out);
if (spdySession.getSendWindowSize(streamId) > Integer.MAX_VALUE - deltaWindowSize) {
issueStreamError(ctx, streamId, SpdyStreamStatus.FLOW_CONTROL_ERROR, out);
return;
}
updateSendWindowSize(streamID, deltaWindowSize, out);
updateSendWindowSize(streamId, deltaWindowSize, out);
}
}
@ -459,10 +461,10 @@ public class SpdySessionHandler
if (msg instanceof SpdyDataFrame) {
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) msg;
final int streamID = spdyDataFrame.getStreamId();
final int streamId = spdyDataFrame.getStreamId();
// Frames must not be sent on half-closed streams
if (spdySession.isLocalSideClosed(streamID)) {
if (spdySession.isLocalSideClosed(streamId)) {
throw PROTOCOL_EXCEPTION;
}
@ -482,22 +484,22 @@ public class SpdySessionHandler
if (flowControl) {
synchronized (flowControlLock) {
int dataLength = spdyDataFrame.content().readableBytes();
int sendWindowSize = spdySession.getSendWindowSize(streamID);
int sendWindowSize = spdySession.getSendWindowSize(streamId);
if (sendWindowSize <= 0) {
// Stream is stalled -- enqueue Data frame and return
spdySession.putPendingWrite(streamID, spdyDataFrame);
spdySession.putPendingWrite(streamId, spdyDataFrame);
return;
} else if (sendWindowSize < dataLength) {
// Stream is not stalled but we cannot send the entire frame
spdySession.updateSendWindowSize(streamID, -1 * sendWindowSize);
spdySession.updateSendWindowSize(streamId, -1 * sendWindowSize);
// Create a partial data frame whose length is the current window size
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamID,
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamId,
spdyDataFrame.content().readSlice(sendWindowSize).retain());
// Enqueue the remaining data (will be the first frame queued)
spdySession.putPendingWrite(streamID, spdyDataFrame);
spdySession.putPendingWrite(streamId, spdyDataFrame);
// The transfer window size is pre-decremented when sending a data frame downstream.
// Close the stream on write failures that leaves the transfer window in a corrupt state.
@ -511,7 +513,7 @@ public class SpdySessionHandler
// @Override
// public void operationComplete(ChannelFuture future) throws Exception {
// if (!future.isSuccess()) {
// issueStreamError(context, streamID, SpdyStreamStatus.INTERNAL_ERROR);
// issueStreamError(context, streamId, SpdyStreamStatus.INTERNAL_ERROR);
// }
// }
//});
@ -520,7 +522,7 @@ public class SpdySessionHandler
return;
} else {
// Window size is large enough to send entire data frame
spdySession.updateSendWindowSize(streamID, -1 * dataLength);
spdySession.updateSendWindowSize(streamId, -1 * dataLength);
// The transfer window size is pre-decremented when sending a data frame downstream.
// Close the stream on write failures that leaves the transfer window in a corrupt state.
@ -533,7 +535,7 @@ public class SpdySessionHandler
// @Override
// public void operationComplete(ChannelFuture future) throws Exception {
// if (!future.isSuccess()) {
// issueStreamError(context, streamID, SpdyStreamStatus.INTERNAL_ERROR);
// issueStreamError(context, streamId, SpdyStreamStatus.INTERNAL_ERROR);
// }
// }
//});
@ -543,38 +545,38 @@ public class SpdySessionHandler
// Close the local side of the stream if this is the last frame
if (spdyDataFrame.isLast()) {
halfCloseStream(streamID, false);
halfCloseStream(streamId, false);
}
} else if (msg instanceof SpdySynStreamFrame) {
SpdySynStreamFrame spdySynStreamFrame = (SpdySynStreamFrame) msg;
int streamID = spdySynStreamFrame.getStreamId();
int streamId = spdySynStreamFrame.getStreamId();
if (isRemoteInitiatedID(streamID)) {
if (isRemoteInitiatedID(streamId)) {
throw PROTOCOL_EXCEPTION;
}
byte priority = spdySynStreamFrame.getPriority();
boolean remoteSideClosed = spdySynStreamFrame.isUnidirectional();
boolean localSideClosed = spdySynStreamFrame.isLast();
if (!acceptStream(streamID, priority, remoteSideClosed, localSideClosed)) {
if (!acceptStream(streamId, priority, remoteSideClosed, localSideClosed)) {
throw PROTOCOL_EXCEPTION;
}
} else if (msg instanceof SpdySynReplyFrame) {
SpdySynReplyFrame spdySynReplyFrame = (SpdySynReplyFrame) msg;
int streamID = spdySynReplyFrame.getStreamId();
int streamId = spdySynReplyFrame.getStreamId();
// Frames must not be sent on half-closed streams
if (!isRemoteInitiatedID(streamID) || spdySession.isLocalSideClosed(streamID)) {
if (!isRemoteInitiatedID(streamId) || spdySession.isLocalSideClosed(streamId)) {
throw PROTOCOL_EXCEPTION;
}
// Close the local side of the stream if this is the last frame
if (spdySynReplyFrame.isLast()) {
halfCloseStream(streamID, false);
halfCloseStream(streamId, false);
}
} else if (msg instanceof SpdyRstStreamFrame) {
@ -627,16 +629,16 @@ public class SpdySessionHandler
} else if (msg instanceof SpdyHeadersFrame) {
SpdyHeadersFrame spdyHeadersFrame = (SpdyHeadersFrame) msg;
int streamID = spdyHeadersFrame.getStreamId();
int streamId = spdyHeadersFrame.getStreamId();
// Frames must not be sent on half-closed streams
if (spdySession.isLocalSideClosed(streamID)) {
if (spdySession.isLocalSideClosed(streamId)) {
throw PROTOCOL_EXCEPTION;
}
// Close the local side of the stream if this is the last frame
if (spdyHeadersFrame.isLast()) {
halfCloseStream(streamID, false);
halfCloseStream(streamId, false);
}
} else if (msg instanceof SpdyWindowUpdateFrame) {
@ -675,12 +677,11 @@ public class SpdySessionHandler
* Note: this is only called by the worker thread
*/
private void issueStreamError(
ChannelHandlerContext ctx, int streamID, SpdyStreamStatus status, MessageList<Object> in) {
ChannelHandlerContext ctx, int streamId, SpdyStreamStatus status, MessageList<Object> in) {
boolean fireMessageReceived = !spdySession.isRemoteSideClosed(streamId);
removeStream(ctx, streamId);
boolean fireMessageReceived = !spdySession.isRemoteSideClosed(streamID);
removeStream(ctx, streamID);
SpdyRstStreamFrame spdyRstStreamFrame = new DefaultSpdyRstStreamFrame(streamID, status);
SpdyRstStreamFrame spdyRstStreamFrame = new DefaultSpdyRstStreamFrame(streamId, status);
ctx.write(spdyRstStreamFrame);
if (fireMessageReceived) {
in.add(spdyRstStreamFrame);
@ -694,8 +695,8 @@ public class SpdySessionHandler
*/
private boolean isRemoteInitiatedID(int id) {
boolean serverID = SpdyCodecUtil.isServerId(id);
return server && !serverID || !server && serverID;
boolean serverId = SpdyCodecUtil.isServerId(id);
return server && !serverId || !server && serverId;
}
private void updateConcurrentStreams(int newConcurrentStreams, boolean remote) {
@ -741,7 +742,7 @@ public class SpdySessionHandler
// need to synchronize accesses to sentGoAwayFrame, lastGoodStreamId, and initial window sizes
private synchronized boolean acceptStream(
int streamID, byte priority, boolean remoteSideClosed, boolean localSideClosed) {
int streamId, byte priority, boolean remoteSideClosed, boolean localSideClosed) {
// Cannot initiate any new streams after receiving or sending GOAWAY
if (receivedGoAwayFrame || sentGoAwayFrame) {
return false;
@ -753,27 +754,27 @@ public class SpdySessionHandler
return false;
}
spdySession.acceptStream(
streamID, priority, remoteSideClosed, localSideClosed,
streamId, priority, remoteSideClosed, localSideClosed,
initialSendWindowSize, initialReceiveWindowSize);
if (isRemoteInitiatedID(streamID)) {
lastGoodStreamId = streamID;
if (isRemoteInitiatedID(streamId)) {
lastGoodStreamId = streamId;
}
return true;
}
private void halfCloseStream(int streamID, boolean remote) {
private void halfCloseStream(int streamId, boolean remote) {
if (remote) {
spdySession.closeRemoteSide(streamID);
spdySession.closeRemoteSide(streamId);
} else {
spdySession.closeLocalSide(streamID);
spdySession.closeLocalSide(streamId);
}
if (closeSessionFuture != null && spdySession.noActiveStreams()) {
closeSessionFuture.trySuccess();
}
}
private void removeStream(ChannelHandlerContext ctx, int streamID) {
if (spdySession.removeStream(streamID)) {
private void removeStream(ChannelHandlerContext ctx, int streamId) {
if (spdySession.removeStream(streamId)) {
ctx.fireExceptionCaught(STREAM_CLOSED);
}
@ -782,13 +783,13 @@ public class SpdySessionHandler
}
}
private void updateSendWindowSize(final int streamID, int deltaWindowSize, MessageList<Object> out) {
private void updateSendWindowSize(final int streamId, int deltaWindowSize, MessageList<Object> out) {
synchronized (flowControlLock) {
int newWindowSize = spdySession.updateSendWindowSize(streamID, deltaWindowSize);
int newWindowSize = spdySession.updateSendWindowSize(streamId, deltaWindowSize);
while (newWindowSize > 0) {
// Check if we have unblocked a stalled stream
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) spdySession.getPendingWrite(streamID);
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) spdySession.getPendingWrite(streamId);
if (spdyDataFrame == null) {
break;
}
@ -797,8 +798,8 @@ public class SpdySessionHandler
if (newWindowSize >= dataFrameSize) {
// Window size is large enough to send entire data frame
spdySession.removePendingWrite(streamID);
newWindowSize = spdySession.updateSendWindowSize(streamID, -1 * dataFrameSize);
spdySession.removePendingWrite(streamId);
newWindowSize = spdySession.updateSendWindowSize(streamId, -1 * dataFrameSize);
// The transfer window size is pre-decremented when sending a data frame downstream.
// Close the stream on write failures that leaves the transfer window in a corrupt state.
@ -811,23 +812,23 @@ public class SpdySessionHandler
// @Override
// public void operationComplete(ChannelFuture future) throws Exception {
// if (!future.isSuccess()) {
// issueStreamError(context, streamID, SpdyStreamStatus.INTERNAL_ERROR);
// issueStreamError(context, streamId, SpdyStreamStatus.INTERNAL_ERROR);
// }
// }
//});
// Close the local side of the stream if this is the last frame
if (spdyDataFrame.isLast()) {
halfCloseStream(streamID, false);
halfCloseStream(streamId, false);
}
out.add(spdyDataFrame);
} else {
// We can send a partial frame
spdySession.updateSendWindowSize(streamID, -1 * newWindowSize);
spdySession.updateSendWindowSize(streamId, -1 * newWindowSize);
// Create a partial data frame whose length is the current window size
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamID,
SpdyDataFrame partialDataFrame = new DefaultSpdyDataFrame(streamId,
spdyDataFrame.content().readSlice(newWindowSize).retain());
// The transfer window size is pre-decremented when sending a data frame downstream.
@ -842,7 +843,7 @@ public class SpdySessionHandler
// @Override
// public void operationComplete(ChannelFuture future) throws Exception {
// if (!future.isSuccess()) {
// issueStreamError(context, streamID, SpdyStreamStatus.INTERNAL_ERROR);
// issueStreamError(context, streamId, SpdyStreamStatus.INTERNAL_ERROR);
// }
// }
//});

10
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdySessionStatus.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,7 +16,7 @@
package io.netty.handler.codec.spdy;
/**
* The SPDY session getStatus code and its description.
* The SPDY session status code and its description.
*/
public class SpdySessionStatus implements Comparable<SpdySessionStatus> {
@ -40,7 +40,7 @@ public class SpdySessionStatus implements Comparable<SpdySessionStatus> {
/**
* Returns the {@link SpdySessionStatus} represented by the specified code.
* If the specified code is a defined SPDY getStatus code, a cached instance
* If the specified code is a defined SPDY status code, a cached instance
* will be returned. Otherwise, a new instance will be returned.
*/
public static SpdySessionStatus valueOf(int code) {
@ -74,14 +74,14 @@ public class SpdySessionStatus implements Comparable<SpdySessionStatus> {
}
/**
* Returns the code of this getStatus.
* Returns the code of this status.
*/
public int getCode() {
return code;
}
/**
* Returns the getStatus phrase of this getStatus.
* Returns the status phrase of this status.
*/
public String getStatusPhrase() {
return statusPhrase;

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdySettingsFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -18,9 +18,9 @@ package io.netty.handler.codec.spdy;
import java.util.Set;
/**
* A SPDY Protocol SETTINGS Control Frame
* A SPDY Protocol SETTINGS Frame
*/
public interface SpdySettingsFrame extends SpdyControlFrame {
public interface SpdySettingsFrame extends SpdyFrame {
int SETTINGS_UPLOAD_BANDWIDTH = 1;
int SETTINGS_DOWNLOAD_BANDWIDTH = 2;

4
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyStreamFrame.java
View File

@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A frame which is part of a stream
* A SPDY Protocol Frame that is associated with an individual SPDY Stream
*/
public interface SpdyStreamFrame {
public interface SpdyStreamFrame extends SpdyFrame {
/**
* Returns the Stream-ID of this frame.

14
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyStreamStatus.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,7 +16,7 @@
package io.netty.handler.codec.spdy;
/**
* The SPDY stream getStatus code and its description.
* The SPDY stream status code and its description.
*/
public class SpdyStreamStatus implements Comparable<SpdyStreamStatus> {
@ -88,13 +88,13 @@ public class SpdyStreamStatus implements Comparable<SpdyStreamStatus> {
/**
* Returns the {@link SpdyStreamStatus} represented by the specified code.
* If the specified code is a defined SPDY getStatus code, a cached instance
* If the specified code is a defined SPDY status code, a cached instance
* will be returned. Otherwise, a new instance will be returned.
*/
public static SpdyStreamStatus valueOf(int code) {
if (code == 0) {
throw new IllegalArgumentException(
"0 is not a valid getStatus code for a RST_STREAM");
"0 is not a valid status code for a RST_STREAM");
}
switch (code) {
@ -136,7 +136,7 @@ public class SpdyStreamStatus implements Comparable<SpdyStreamStatus> {
public SpdyStreamStatus(int code, String statusPhrase) {
if (code == 0) {
throw new IllegalArgumentException(
"0 is not a valid getStatus code for a RST_STREAM");
"0 is not a valid status code for a RST_STREAM");
}
if (statusPhrase == null) {
@ -148,14 +148,14 @@ public class SpdyStreamStatus implements Comparable<SpdyStreamStatus> {
}
/**
* Returns the code of this getStatus.
* Returns the code of this status.
*/
public int getCode() {
return code;
}
/**
* Returns the getStatus phrase of this getStatus.
* Returns the status phrase of this status.
*/
public String getStatusPhrase() {
return statusPhrase;

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdySynReplyFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol SYN_REPLY Control Frame
* A SPDY Protocol SYN_REPLY Frame
*/
public interface SpdySynReplyFrame extends SpdyHeaderBlock, SpdyControlFrame, SpdyStreamFrame {
public interface SpdySynReplyFrame extends SpdyHeadersFrame {
@Override
SpdySynReplyFrame setStreamId(int streamID);

6
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdySynStreamFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol SYN_STREAM Control Frame
* A SPDY Protocol SYN_STREAM Frame
*/
public interface SpdySynStreamFrame extends SpdyHeaderBlock, SpdyControlFrame , SpdyStreamFrame {
public interface SpdySynStreamFrame extends SpdyHeadersFrame {
/**
* Returns the Associated-To-Stream-ID of this frame.

8
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyWindowUpdateFrame.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -16,9 +16,9 @@
package io.netty.handler.codec.spdy;
/**
* A SPDY Protocol WINDOW_UPDATE Control Frame
* A SPDY Protocol WINDOW_UPDATE Frame
*/
public interface SpdyWindowUpdateFrame extends SpdyControlFrame {
public interface SpdyWindowUpdateFrame extends SpdyFrame {
/**
* Returns the Stream-ID of this frame.
@ -26,7 +26,7 @@ public interface SpdyWindowUpdateFrame extends SpdyControlFrame {
int getStreamId();
/**
* Sets the Stream-ID of this frame. The Stream-ID must be positive.
* Sets the Stream-ID of this frame. The Stream-ID cannot be negative.
*/
SpdyWindowUpdateFrame setStreamId(int streamID);

196
codec-http/src/test/java/io/netty/handler/codec/spdy/SpdySessionHandlerTest.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012 The Netty Project
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
@ -18,6 +18,7 @@ package io.netty.handler.codec.spdy;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.MessageList;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
@ -40,40 +41,25 @@ public class SpdySessionHandlerTest {
closeMessage.setValue(closeSignal, 0);
}
private static void assertHeaderBlock(SpdyHeaderBlock received, SpdyHeaderBlock expected) {
for (String name: expected.headers().names()) {
List<String> expectedValues = expected.headers().getAll(name);
List<String> receivedValues = received.headers().getAll(name);
assertTrue(receivedValues.containsAll(expectedValues));
receivedValues.removeAll(expectedValues);
assertTrue(receivedValues.isEmpty());
received.headers().remove(name);
}
assertTrue(received.headers().entries().isEmpty());
}
private static void assertDataFrame(Object msg, int streamID, boolean last) {
private static void assertDataFrame(Object msg, int streamId, boolean last) {
assertNotNull(msg);
assertTrue(msg instanceof SpdyDataFrame);
SpdyDataFrame spdyDataFrame = (SpdyDataFrame) msg;
assertEquals(spdyDataFrame.getStreamId(), streamID);
assertEquals(spdyDataFrame.getStreamId(), streamId);
assertEquals(spdyDataFrame.isLast(), last);
}
private static void assertSynReply(Object msg, int streamID, boolean last, SpdyHeaderBlock headers) {
private static void assertSynReply(Object msg, int streamId, boolean last, SpdyHeaders headers) {
assertNotNull(msg);
assertTrue(msg instanceof SpdySynReplyFrame);
SpdySynReplyFrame spdySynReplyFrame = (SpdySynReplyFrame) msg;
assertEquals(spdySynReplyFrame.getStreamId(), streamID);
assertEquals(spdySynReplyFrame.isLast(), last);
assertHeaderBlock(spdySynReplyFrame, headers);
assertHeaders(msg, streamId, last, headers);
}
private static void assertRstStream(Object msg, int streamID, SpdyStreamStatus status) {
private static void assertRstStream(Object msg, int streamId, SpdyStreamStatus status) {
assertNotNull(msg);
assertTrue(msg instanceof SpdyRstStreamFrame);
SpdyRstStreamFrame spdyRstStreamFrame = (SpdyRstStreamFrame) msg;
assertEquals(spdyRstStreamFrame.getStreamId(), streamID);
assertEquals(spdyRstStreamFrame.getStreamId(), streamId);
assertEquals(spdyRstStreamFrame.getStatus(), status);
}
@ -84,19 +70,28 @@ public class SpdySessionHandlerTest {
assertEquals(spdyPingFrame.getId(), id);
}
private static void assertGoAway(Object msg, int lastGoodStreamID) {
private static void assertGoAway(Object msg, int lastGoodStreamId) {
assertNotNull(msg);
assertTrue(msg instanceof SpdyGoAwayFrame);
SpdyGoAwayFrame spdyGoAwayFrame = (SpdyGoAwayFrame) msg;
assertEquals(spdyGoAwayFrame.getLastGoodStreamId(), lastGoodStreamID);
assertEquals(spdyGoAwayFrame.getLastGoodStreamId(), lastGoodStreamId);
}
private static void assertHeaders(Object msg, int streamID, SpdyHeaderBlock headers) {
private static void assertHeaders(Object msg, int streamId, boolean last, SpdyHeaders headers) {
assertNotNull(msg);
assertTrue(msg instanceof SpdyHeadersFrame);
SpdyHeadersFrame spdyHeadersFrame = (SpdyHeadersFrame) msg;
assertEquals(spdyHeadersFrame.getStreamId(), streamID);
assertHeaderBlock(spdyHeadersFrame, headers);
assertEquals(spdyHeadersFrame.getStreamId(), streamId);
assertEquals(spdyHeadersFrame.isLast(), last);
for (String name: headers.names()) {
List<String> expectedValues = headers.getAll(name);
List<String> receivedValues = spdyHeadersFrame.headers().getAll(name);
assertTrue(receivedValues.containsAll(expectedValues));
receivedValues.removeAll(expectedValues);
assertTrue(receivedValues.isEmpty());
spdyHeadersFrame.headers().remove(name);
}
assertTrue(spdyHeadersFrame.headers().entries().isEmpty());
}
private static void testSpdySessionHandler(int version, boolean server) {
@ -107,71 +102,71 @@ public class SpdySessionHandlerTest {
continue;
}
int localStreamID = server ? 1 : 2;
int remoteStreamID = server ? 2 : 1;
int localStreamId = server ? 1 : 2;
int remoteStreamId = server ? 2 : 1;
SpdyPingFrame localPingFrame = new DefaultSpdyPingFrame(localStreamID);
SpdyPingFrame remotePingFrame = new DefaultSpdyPingFrame(remoteStreamID);
SpdyPingFrame localPingFrame = new DefaultSpdyPingFrame(localStreamId);
SpdyPingFrame remotePingFrame = new DefaultSpdyPingFrame(remoteStreamId);
SpdySynStreamFrame spdySynStreamFrame =
new DefaultSpdySynStreamFrame(localStreamID, 0, (byte) 0);
new DefaultSpdySynStreamFrame(localStreamId, 0, (byte) 0);
spdySynStreamFrame.headers().set("Compression", "test");
SpdyDataFrame spdyDataFrame = new DefaultSpdyDataFrame(localStreamID);
SpdyDataFrame spdyDataFrame = new DefaultSpdyDataFrame(localStreamId);
spdyDataFrame.setLast(true);
// Check if session handler returns INVALID_STREAM if it receives
// a data frame for a Stream-ID that is not open
sessionHandler.writeInbound(new DefaultSpdyDataFrame(localStreamID));
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.INVALID_STREAM);
sessionHandler.writeInbound(new DefaultSpdyDataFrame(localStreamId));
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.INVALID_STREAM);
assertNull(sessionHandler.readOutbound());
// Check if session handler returns PROTOCOL_ERROR if it receives
// a data frame for a Stream-ID before receiving a SYN_REPLY frame
sessionHandler.writeInbound(new DefaultSpdyDataFrame(remoteStreamID));
assertRstStream(sessionHandler.readOutbound(), remoteStreamID, SpdyStreamStatus.PROTOCOL_ERROR);
sessionHandler.writeInbound(new DefaultSpdyDataFrame(remoteStreamId));
assertRstStream(sessionHandler.readOutbound(), remoteStreamId, SpdyStreamStatus.PROTOCOL_ERROR);
assertNull(sessionHandler.readOutbound());
remoteStreamID += 2;
remoteStreamId += 2;
// Check if session handler returns PROTOCOL_ERROR if it receives
// multiple SYN_REPLY frames for the same active Stream-ID
sessionHandler.writeInbound(new DefaultSpdySynReplyFrame(remoteStreamID));
sessionHandler.writeInbound(new DefaultSpdySynReplyFrame(remoteStreamId));
assertNull(sessionHandler.readOutbound());
sessionHandler.writeInbound(new DefaultSpdySynReplyFrame(remoteStreamID));
assertRstStream(sessionHandler.readOutbound(), remoteStreamID, SpdyStreamStatus.STREAM_IN_USE);
sessionHandler.writeInbound(new DefaultSpdySynReplyFrame(remoteStreamId));
assertRstStream(sessionHandler.readOutbound(), remoteStreamId, SpdyStreamStatus.STREAM_IN_USE);
assertNull(sessionHandler.readOutbound());
remoteStreamID += 2;
remoteStreamId += 2;
// Check if frame codec correctly compresses/uncompresses headers
sessionHandler.writeInbound(spdySynStreamFrame);
assertSynReply(sessionHandler.readOutbound(), localStreamID, false, spdySynStreamFrame);
assertSynReply(sessionHandler.readOutbound(), localStreamId, false, spdySynStreamFrame.headers());
assertNull(sessionHandler.readOutbound());
SpdyHeadersFrame spdyHeadersFrame = new DefaultSpdyHeadersFrame(localStreamID);
SpdyHeadersFrame spdyHeadersFrame = new DefaultSpdyHeadersFrame(localStreamId);
spdyHeadersFrame.headers().add("HEADER", "test1");
spdyHeadersFrame.headers().add("HEADER", "test2");
sessionHandler.writeInbound(spdyHeadersFrame);
assertHeaders(sessionHandler.readOutbound(), localStreamID, spdyHeadersFrame);
assertHeaders(sessionHandler.readOutbound(), localStreamId, false, spdyHeadersFrame.headers());
assertNull(sessionHandler.readOutbound());
localStreamID += 2;
localStreamId += 2;
// Check if session handler closed the streams using the number
// of concurrent streams and that it returns REFUSED_STREAM
// if it receives a SYN_STREAM frame it does not wish to accept
spdySynStreamFrame.setStreamId(localStreamID);
spdySynStreamFrame.setStreamId(localStreamId);
spdySynStreamFrame.setLast(true);
spdySynStreamFrame.setUnidirectional(true);
sessionHandler.writeInbound(spdySynStreamFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.REFUSED_STREAM);
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.REFUSED_STREAM);
assertNull(sessionHandler.readOutbound());
// Check if session handler drops active streams if it receives
// a RST_STREAM frame for that Stream-ID
sessionHandler.writeInbound(new DefaultSpdyRstStreamFrame(remoteStreamID, 3));
sessionHandler.writeInbound(new DefaultSpdyRstStreamFrame(remoteStreamId, 3));
assertNull(sessionHandler.readOutbound());
remoteStreamID += 2;
remoteStreamId += 2;
// Check if session handler honors UNIDIRECTIONAL streams
spdySynStreamFrame.setLast(false);
@ -182,17 +177,17 @@ public class SpdySessionHandlerTest {
// Check if session handler returns PROTOCOL_ERROR if it receives
// multiple SYN_STREAM frames for the same active Stream-ID
sessionHandler.writeInbound(spdySynStreamFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.PROTOCOL_ERROR);
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.PROTOCOL_ERROR);
assertNull(sessionHandler.readOutbound());
localStreamID += 2;
localStreamId += 2;
// Check if session handler returns PROTOCOL_ERROR if it receives
// a SYN_STREAM frame with an invalid Stream-ID
spdySynStreamFrame.setStreamId(localStreamID - 1);
spdySynStreamFrame.setStreamId(localStreamId - 1);
sessionHandler.writeInbound(spdySynStreamFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID - 1, SpdyStreamStatus.PROTOCOL_ERROR);
assertRstStream(sessionHandler.readOutbound(), localStreamId - 1, SpdyStreamStatus.PROTOCOL_ERROR);
assertNull(sessionHandler.readOutbound());
spdySynStreamFrame.setStreamId(localStreamID);
spdySynStreamFrame.setStreamId(localStreamId);
// Check if session handler correctly limits the number of
// concurrent streams in the SETTINGS frame
@ -201,33 +196,33 @@ public class SpdySessionHandlerTest {
sessionHandler.writeInbound(spdySettingsFrame);
assertNull(sessionHandler.readOutbound());
sessionHandler.writeInbound(spdySynStreamFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.REFUSED_STREAM);
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.REFUSED_STREAM);
assertNull(sessionHandler.readOutbound());
spdySettingsFrame.setValue(SpdySettingsFrame.SETTINGS_MAX_CONCURRENT_STREAMS, 4);
sessionHandler.writeInbound(spdySettingsFrame);
assertNull(sessionHandler.readOutbound());
sessionHandler.writeInbound(spdySynStreamFrame);
assertSynReply(sessionHandler.readOutbound(), localStreamID, false, spdySynStreamFrame);
assertSynReply(sessionHandler.readOutbound(), localStreamId, false, spdySynStreamFrame.headers());
assertNull(sessionHandler.readOutbound());
// Check if session handler rejects HEADERS for closed streams
int testStreamID = spdyDataFrame.getStreamId();
int testStreamId = spdyDataFrame.getStreamId();
sessionHandler.writeInbound(spdyDataFrame);
assertDataFrame(sessionHandler.readOutbound(), testStreamID, spdyDataFrame.isLast());
assertDataFrame(sessionHandler.readOutbound(), testStreamId, spdyDataFrame.isLast());
assertNull(sessionHandler.readOutbound());
spdyHeadersFrame.setStreamId(testStreamID);
spdyHeadersFrame.setStreamId(testStreamId);
sessionHandler.writeInbound(spdyHeadersFrame);
assertRstStream(sessionHandler.readOutbound(), testStreamID, SpdyStreamStatus.INVALID_STREAM);
assertRstStream(sessionHandler.readOutbound(), testStreamId, SpdyStreamStatus.INVALID_STREAM);
assertNull(sessionHandler.readOutbound());
// Check if session handler returns PROTOCOL_ERROR if it receives
// an invalid HEADERS frame
spdyHeadersFrame.setStreamId(localStreamID);
spdyHeadersFrame.setStreamId(localStreamId);
spdyHeadersFrame.setInvalid();
sessionHandler.writeInbound(spdyHeadersFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.PROTOCOL_ERROR);
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.PROTOCOL_ERROR);
assertNull(sessionHandler.readOutbound());
// Check if session handler returns identical local PINGs
@ -241,20 +236,20 @@ public class SpdySessionHandlerTest {
// Check if session handler sends a GOAWAY frame when closing
sessionHandler.writeInbound(closeMessage);
assertGoAway(sessionHandler.readOutbound(), localStreamID);
assertGoAway(sessionHandler.readOutbound(), localStreamId);
assertNull(sessionHandler.readOutbound());
localStreamID += 2;
localStreamId += 2;
// Check if session handler returns REFUSED_STREAM if it receives
// SYN_STREAM frames after sending a GOAWAY frame
spdySynStreamFrame.setStreamId(localStreamID);
spdySynStreamFrame.setStreamId(localStreamId);
sessionHandler.writeInbound(spdySynStreamFrame);
assertRstStream(sessionHandler.readOutbound(), localStreamID, SpdyStreamStatus.REFUSED_STREAM);
assertRstStream(sessionHandler.readOutbound(), localStreamId, SpdyStreamStatus.REFUSED_STREAM);
assertNull(sessionHandler.readOutbound());
// Check if session handler ignores Data frames after sending
// a GOAWAY frame
spdyDataFrame.setStreamId(localStreamID);
spdyDataFrame.setStreamId(localStreamId);
sessionHandler.writeInbound(spdyDataFrame);
assertNull(sessionHandler.readOutbound());
@ -279,7 +274,7 @@ public class SpdySessionHandlerTest {
// Echo Handler opens 4 half-closed streams on session connection
// and then sets the number of concurrent streams to 3
private static class EchoHandler extends ChannelInboundHandlerAdapter {
private static class EchoHandler extends SimpleChannelInboundHandler<Object> {
private final int closeSignal;
private final boolean server;
@ -291,9 +286,9 @@ public class SpdySessionHandlerTest {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// Initiate 4 new streams
int streamID = server ? 2 : 1;
int streamId = server ? 2 : 1;
SpdySynStreamFrame spdySynStreamFrame =
new DefaultSpdySynStreamFrame(streamID, 0, (byte) 0);
new DefaultSpdySynStreamFrame(streamId, 0, (byte) 0);
spdySynStreamFrame.setLast(true);
ctx.write(spdySynStreamFrame);
spdySynStreamFrame.setStreamId(spdySynStreamFrame.getStreamId() + 2);
@ -310,38 +305,39 @@ public class SpdySessionHandlerTest {
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageList<Object> messages) throws Exception {
for (int i = 0; i < messages.size(); i++) {
Object msg = messages.get(i);
if (msg instanceof SpdyDataFrame ||
msg instanceof SpdyPingFrame ||
msg instanceof SpdyHeadersFrame) {
public void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof SpdySynStreamFrame) {
ctx.write(msg);
return;
}
if (msg instanceof SpdySynStreamFrame) {
SpdySynStreamFrame spdySynStreamFrame = (SpdySynStreamFrame) msg;
if (!spdySynStreamFrame.isUnidirectional()) {
int streamID = spdySynStreamFrame.getStreamId();
SpdySynReplyFrame spdySynReplyFrame = new DefaultSpdySynReplyFrame(streamID);
spdySynReplyFrame.setLast(spdySynStreamFrame.isLast());
for (Map.Entry<String, String> entry: spdySynStreamFrame.headers()) {
spdySynReplyFrame.headers().add(entry.getKey(), entry.getValue());
}
ctx.write(spdySynReplyFrame);
SpdySynStreamFrame spdySynStreamFrame = (SpdySynStreamFrame) msg;
if (!spdySynStreamFrame.isUnidirectional()) {
int streamId = spdySynStreamFrame.getStreamId();
SpdySynReplyFrame spdySynReplyFrame = new DefaultSpdySynReplyFrame(streamId);
spdySynReplyFrame.setLast(spdySynStreamFrame.isLast());
for (Map.Entry<String, String> entry: spdySynStreamFrame.headers()) {
spdySynReplyFrame.headers().add(entry.getKey(), entry.getValue());
}
return;
}
if (msg instanceof SpdySettingsFrame) {
SpdySettingsFrame spdySettingsFrame = (SpdySettingsFrame) msg;
if (spdySettingsFrame.isSet(closeSignal)) {
ctx.close();
}
ctx.write(spdySynReplyFrame);
}
return;
}
if (msg instanceof SpdySynReplyFrame) {
return;
}
if (msg instanceof SpdyDataFrame ||
msg instanceof SpdyPingFrame ||
msg instanceof SpdyHeadersFrame) {
ctx.write(msg);
return;
}
if (msg instanceof SpdySettingsFrame) {
SpdySettingsFrame spdySettingsFrame = (SpdySettingsFrame) msg;
if (spdySettingsFrame.isSet(closeSignal)) {
ctx.close();
}
}
}