← Back to branch summary

~elambert/gearmanij/gearman_java_library

« back to all changes in this revision

Viewing changes to src/org/gearman/common/GearmanPacketImpl.java

  • Committer: Eric Lambert
  • Date: 2009-07-10 04:58:00 UTC
  • Revision ID: eric.d.lambert@gmail.com-20090710045800-9ucm5k18t3dejefe
renamed Packet classes

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/gearman/common/GearmanPacketImpl.java
25
25
 * type, which the receiver uses to determine what additional data should be in
26
26
 * the packet, as well as how to interpret the data.
27
27
 */
28
 
public class Packet implements GearmanPacket {
29
 
 
30
 
 
31
 
    private final PacketMagic magic;
32
 
 
33
 
    private final PacketType type;
 
28
public class GearmanPacketImpl implements GearmanPacket {
 
29
 
 
30
 
 
31
    private final GearmanPacketMagic magic;
 
32
 
 
33
    private final GearmanPacketType type;
34
34
 
35
35
    private final byte[] data;
36
36
 
37
 
    public Packet(PacketMagic magic, PacketType type, byte[] data) {
 
37
    public GearmanPacketImpl(GearmanPacketMagic magic, GearmanPacketType type, byte[] data) {
38
38
        this.magic = magic;
39
39
        this.type = type;
40
40
        this.data = ByteUtils.copy(data);
41
41
    }
42
42
 
43
 
    public Packet(InputStream in) {
44
 
        byte[] bytes = new byte[PacketHeader.HEADER_LENGTH];
 
43
    public GearmanPacketImpl(InputStream in) {
 
44
        byte[] bytes = new byte[GearmanPacketHeader.HEADER_LENGTH];
45
45
 
46
46
        blockUntilReadFully(in, bytes);
47
47
 
48
 
        PacketHeader header = new PacketHeader(bytes);
 
48
        GearmanPacketHeader header = new GearmanPacketHeader(bytes);
49
49
        byte[] data = new byte[header.getDataLength()];
50
50
        if (data.length > 0) {
51
51
            IOUtil.readFully(in, data);
57
57
 
58
58
    private void blockUntilReadFully(InputStream in, byte[] bytes) {
59
59
        try {
60
 
            while (in.available() < PacketHeader.HEADER_LENGTH) {
 
60
            while (in.available() < GearmanPacketHeader.HEADER_LENGTH) {
61
61
                try {
62
62
                    Thread.sleep(10);
63
63
                } catch (InterruptedException e) {
84
84
        return data.length;
85
85
    }
86
86
 
87
 
    public PacketType getPacketType() {
 
87
    public GearmanPacketType getPacketType() {
88
88
        return type;
89
89
    }
90
90
 
91
 
    public PacketMagic getMagic() {
 
91
    public GearmanPacketMagic getMagic() {
92
92
        return magic;
93
93
    }
94
94
 
147
147
        /*
148
148
         * HEADER
149
149
         */
150
 
        new PacketHeader(magic, type, getDataSize()).write(os);
 
150
        new GearmanPacketHeader(magic, type, getDataSize()).write(os);
151
151
 
152
152
        /*
153
153
         * DATA
160
160
        IOUtil.write(os, data);
161
161
    }
162
162
 
163
 
    public PacketType getType() {
 
163
    public GearmanPacketType getType() {
164
164
        return type;
165
165
    }
166
166
 
173
173
    }
174
174
 
175
175
    public boolean requiresResponse() {
176
 
        if (magic.equals(PacketMagic.RES)) {
 
176
        if (magic.equals(GearmanPacketMagic.RES)) {
177
177
            return false;
178
178
        }
179
 
        if (type.equals(PacketType.PRE_SLEEP) ||
180
 
                type.equals(PacketType.GRAB_JOB) ||
181
 
                type.equals(PacketType.GRAB_JOB_UNIQ) ||
182
 
                type.equals(PacketType.GET_STATUS) ||
183
 
                type.equals(PacketType.ECHO_REQ) ||
184
 
                type.equals(PacketType.SUBMIT_JOB) ||
185
 
                type.equals(PacketType.SUBMIT_JOB_BG) ||
186
 
                type.equals(PacketType.SUBMIT_JOB_LOW) ||
187
 
                type.equals(PacketType.SUBMIT_JOB_LOW_BG) ||
188
 
                type.equals(PacketType.SUBMIT_JOB_HIGH) ||
189
 
                type.equals(PacketType.SUBMIT_JOB_HIGH_BG) ||
190
 
                type.equals(PacketType.OPTION_REQ)) {
 
179
        if (type.equals(GearmanPacketType.PRE_SLEEP) ||
 
180
                type.equals(GearmanPacketType.GRAB_JOB) ||
 
181
                type.equals(GearmanPacketType.GRAB_JOB_UNIQ) ||
 
182
                type.equals(GearmanPacketType.GET_STATUS) ||
 
183
                type.equals(GearmanPacketType.ECHO_REQ) ||
 
184
                type.equals(GearmanPacketType.SUBMIT_JOB) ||
 
185
                type.equals(GearmanPacketType.SUBMIT_JOB_BG) ||
 
186
                type.equals(GearmanPacketType.SUBMIT_JOB_LOW) ||
 
187
                type.equals(GearmanPacketType.SUBMIT_JOB_LOW_BG) ||
 
188
                type.equals(GearmanPacketType.SUBMIT_JOB_HIGH) ||
 
189
                type.equals(GearmanPacketType.SUBMIT_JOB_HIGH_BG) ||
 
190
                type.equals(GearmanPacketType.OPTION_REQ)) {
191
191
            return true;
192
192
        } else {
193
193
            return false;