Eclipse/jetty.project
1
0
Fork 0
mirror of https://github.com/jetty/jetty.project.git synced 2025-03-02 20:09:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implemented parser and generator for RST_STREAM frame.

Browse Source
This commit is contained in:
Simone Bordet 2014-06-05 20:30:11 +02:00
parent 21d8435541
commit 6f3f7f5334
9 changed files with 279 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jetty-http2/src/main/java/org/eclipse/jetty/http2/frames/FrameType.java
View File

@ -20,7 +20,7 @@ package org.eclipse.jetty.http2.frames;
public enum FrameType
{
DATA(0), HEADERS(1), PRIORITY(2);
DATA(0), HEADERS(1), PRIORITY(2), RST_STREAM(3);
private final int type;

41
jetty-http2/src/main/java/org/eclipse/jetty/http2/frames/ResetFrame.java Normal file
View File

@ -0,0 +1,41 @@
//
// ========================================================================
// Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http2.frames;
public class ResetFrame
{
private final int streamId;
private final int error;
public ResetFrame(int streamId, int error)
{
this.streamId = streamId;
this.error = error;
}
public int getStreamId()
{
return streamId;
}
public int getError()
{
return error;
}
}

54
jetty-http2/src/main/java/org/eclipse/jetty/http2/generator/Generator.java
View File

@ -43,17 +43,9 @@ public class Generator
if (dependentStreamId < 0)
throw new IllegalArgumentException("Invalid dependent stream id: " + dependentStreamId);
ByteBuffer header = byteBufferPool.acquire(8 + 5, true);
BufferUtil.clearToFill(header);
Result result = new Result(byteBufferPool);
header.putShort((short)5);
header.put((byte)FrameType.PRIORITY.getType());
// No flags.
header.put((byte)0);
header.putInt(dependentStreamId);
ByteBuffer header = generateHeader(FrameType.PRIORITY, 5, 0, dependentStreamId);
if (exclusive)
streamId |= 0x80_00_00_00;
@ -68,6 +60,23 @@ public class Generator
return result;
}
public Result generateReset(int streamId, int error)
{
if (streamId < 0)
throw new IllegalArgumentException("Invalid stream id: " + streamId);
Result result = new Result(byteBufferPool);
ByteBuffer header = generateHeader(FrameType.RST_STREAM, 4, 0, streamId);
header.putInt(error);
BufferUtil.flipToFlush(header, 0);
result.add(header, true);
return result;
}
public Result generateContent(int streamId, int paddingLength, ByteBuffer data, boolean last, boolean compress)
{
if (streamId < 0)
@ -111,13 +120,7 @@ public class Generator
private void generateFrame(Result result, int streamId, int paddingBytes, int paddingLength, ByteBuffer data, boolean last, boolean compress)
{
ByteBuffer header = byteBufferPool.acquire(8 + paddingBytes, true);
BufferUtil.clearToFill(header);
int length = paddingBytes + data.remaining() + paddingLength;
header.putShort((short)length);
header.put((byte)FrameType.DATA.getType());
int flags = 0;
if (last)
@ -128,9 +131,8 @@ public class Generator
flags |= 0x10;
if (compress)
flags |= 0x20;
header.put((byte)flags);
header.putInt(streamId);
ByteBuffer header = generateHeader(FrameType.DATA, 8 + paddingBytes, length, flags, streamId);
if (paddingBytes == 2)
header.putShort((short)paddingLength);
@ -152,6 +154,24 @@ public class Generator
}
}
private ByteBuffer generateHeader(FrameType frameType, int length, int flags, int streamId)
{
return generateHeader(frameType, 8 + length, length, flags, streamId);
}
private ByteBuffer generateHeader(FrameType frameType, int capacity, int length, int flags, int streamId)
{
ByteBuffer header = byteBufferPool.acquire(capacity, true);
BufferUtil.clearToFill(header);
header.putShort((short)length);
header.put((byte)frameType.getType());
header.put((byte)flags);
header.putInt(streamId);
return header;
}
public static class Result
{
private final ByteBufferPool byteBufferPool;

14
jetty-http2/src/main/java/org/eclipse/jetty/http2/parser/BodyParser.java
View File

@ -22,6 +22,7 @@ import java.nio.ByteBuffer;
import org.eclipse.jetty.http2.frames.DataFrame;
import org.eclipse.jetty.http2.frames.PriorityFrame;
import org.eclipse.jetty.http2.frames.ResetFrame;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@ -96,6 +97,19 @@ public abstract class BodyParser
}
}
protected boolean notifyResetFrame(ResetFrame frame)
{
try
{
return listener.onResetFrame(frame);
}
catch (Throwable x)
{
LOG.info("Failure while notifying listener " + listener, x);
return false;
}
}
public enum Result
{
PENDING, ASYNC, COMPLETE

17
jetty-http2/src/main/java/org/eclipse/jetty/http2/parser/Parser.java
View File

@ -21,19 +21,22 @@ package org.eclipse.jetty.http2.parser;
import java.nio.ByteBuffer;
import org.eclipse.jetty.http2.frames.DataFrame;
import org.eclipse.jetty.http2.frames.FrameType;
import org.eclipse.jetty.http2.frames.PriorityFrame;
import org.eclipse.jetty.http2.frames.ResetFrame;
public class Parser
{
private final HeaderParser headerParser = new HeaderParser();
private final BodyParser[] bodyParsers = new BodyParser[3];
private final BodyParser[] bodyParsers = new BodyParser[4];
private State state = State.HEADER;
private BodyParser bodyParser;
public Parser(Listener listener)
{
bodyParsers[0] = new DataBodyParser(headerParser, listener);
bodyParsers[2] = new PriorityBodyParser(headerParser, listener);
bodyParsers[FrameType.DATA.getType()] = new DataBodyParser(headerParser, listener);
bodyParsers[FrameType.PRIORITY.getType()] = new PriorityBodyParser(headerParser, listener);
bodyParsers[FrameType.RST_STREAM.getType()] = new ResetBodyParser(headerParser, listener);
}
private void reset()
@ -87,6 +90,8 @@ public class Parser
public boolean onPriorityFrame(PriorityFrame frame);
public boolean onResetFrame(ResetFrame frame);
public static class Adapter implements Listener
{
@Override
@ -100,6 +105,12 @@ public class Parser
{
return false;
}
@Override
public boolean onResetFrame(ResetFrame frame)
{
return false;
}
}
}

9
jetty-http2/src/main/java/org/eclipse/jetty/http2/parser/PriorityBodyParser.java
View File

@ -92,9 +92,7 @@ public class PriorityBodyParser extends BodyParser
case WEIGHT:
{
int weight = buffer.get() & 0xFF;
boolean async = onPriority(weight);
reset();
return async ? Result.ASYNC : Result.COMPLETE;
return onPriority(weight);
}
default:
{
@ -105,10 +103,11 @@ public class PriorityBodyParser extends BodyParser
return Result.PENDING;
}
private boolean onPriority(int weight)
private Result onPriority(int weight)
{
PriorityFrame frame = new PriorityFrame(streamId, getStreamId(), weight, exclusive);
return notifyPriorityFrame(frame);
reset();
return notifyPriorityFrame(frame) ? Result.ASYNC : Result.COMPLETE;
}
private enum State

78
jetty-http2/src/main/java/org/eclipse/jetty/http2/parser/ResetBodyParser.java Normal file
View File

@ -0,0 +1,78 @@
package org.eclipse.jetty.http2.parser;
import java.nio.ByteBuffer;
import org.eclipse.jetty.http2.frames.ResetFrame;
public class ResetBodyParser extends BodyParser
{
private State state = State.ERROR;
private int cursor;
private int error;
public ResetBodyParser(HeaderParser headerParser, Parser.Listener listener)
{
super(headerParser, listener);
}
@Override
protected void reset()
{
super.reset();
state = State.ERROR;
cursor = 0;
error = 0;
}
@Override
public Result parse(ByteBuffer buffer)
{
while (buffer.hasRemaining())
{
switch (state)
{
case ERROR:
{
if (buffer.remaining() >= 4)
{
return onReset(buffer.getInt());
}
else
{
state = State.ERROR_BYTES;
cursor = 4;
}
break;
}
case ERROR_BYTES:
{
int currByte = buffer.get() & 0xFF;
--cursor;
error += currByte << (8 * cursor);
if (cursor == 0)
{
return onReset(error);
}
break;
}
default:
{
throw new IllegalStateException();
}
}
}
return Result.PENDING;
}
private Result onReset(int error)
{
ResetFrame frame = new ResetFrame(getStreamId(), error);
reset();
return notifyResetFrame(frame) ? Result.ASYNC : Result.COMPLETE;
}
private enum State
{
ERROR, ERROR_BYTES
}
}

1
jetty-http2/src/test/main/org/eclipse/jetty/http2/frames/PriorityGenerateParseTest.java
View File

@ -80,7 +80,6 @@ public class PriorityGenerateParseTest
}
});
frames.clear();
for (ByteBuffer buffer : result.getByteBuffers())
{
while (buffer.hasRemaining())

90
jetty-http2/src/test/main/org/eclipse/jetty/http2/frames/ResetGenerateParseTest.java Normal file
View File

@ -0,0 +1,90 @@
package org.eclipse.jetty.http2.frames;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jetty.http2.generator.Generator;
import org.eclipse.jetty.http2.parser.Parser;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.MappedByteBufferPool;
import org.junit.Assert;
import org.junit.Test;
public class ResetGenerateParseTest
{
private final ByteBufferPool byteBufferPool = new MappedByteBufferPool();
@Test
public void testGenerateParse() throws Exception
{
Generator generator = new Generator(byteBufferPool);
int streamId = 13;
int error = 17;
// Iterate a few times to be sure generator and parser are properly reset.
final List<ResetFrame> frames = new ArrayList<>();
for (int i = 0; i < 2; ++i)
{
Generator.Result result = generator.generateReset(streamId, error);
Parser parser = new Parser(new Parser.Listener.Adapter()
{
@Override
public boolean onResetFrame(ResetFrame frame)
{
frames.add(frame);
return false;
}
});
frames.clear();
for (ByteBuffer buffer : result.getByteBuffers())
{
while (buffer.hasRemaining())
{
parser.parse(buffer);
}
}
}
Assert.assertEquals(1, frames.size());
ResetFrame frame = frames.get(0);
Assert.assertEquals(streamId, frame.getStreamId());
Assert.assertEquals(error, frame.getError());
}
@Test
public void testGenerateParseOneByteAtATime() throws Exception
{
Generator generator = new Generator(byteBufferPool);
int streamId = 13;
int error = 17;
final List<ResetFrame> frames = new ArrayList<>();
Generator.Result result = generator.generateReset(streamId, error);
Parser parser = new Parser(new Parser.Listener.Adapter()
{
@Override
public boolean onResetFrame(ResetFrame frame)
{
frames.add(frame);
return false;
}
});
for (ByteBuffer buffer : result.getByteBuffers())
{
while (buffer.hasRemaining())
{
parser.parse(ByteBuffer.wrap(new byte[]{buffer.get()}));
}
}
Assert.assertEquals(1, frames.size());
ResetFrame frame = frames.get(0);
Assert.assertEquals(streamId, frame.getStreamId());
Assert.assertEquals(error, frame.getError());
}
}